From 9649921ed1fc5ab60adf6952dafb039333ca9929 Mon Sep 17 00:00:00 2001
From: nonight <378099757@qq.com>
Date: Thu, 6 Feb 2025 11:30:35 +0800
Subject: [PATCH 1/2] =?UTF-8?q?feat:=201=E3=80=81=E8=B0=83=E6=95=B4?=
 =?UTF-8?q?=E8=8E=B7=E5=8F=96=E5=BC=95=E6=93=8E=20hash=E6=96=B9=E6=B3=95?=
 =?UTF-8?q?=E7=9A=84=E4=BD=8D=E7=BD=AE=202=E3=80=81=E5=B0=86=E8=8E=B7?=
 =?UTF-8?q?=E5=8F=96=E7=89=88=E6=9C=AC=E5=8F=B7=E3=80=81hash=E5=80=BC?=
 =?UTF-8?q?=E7=9A=84=E6=8E=A5=E5=8F=A3=E5=8F=82=E6=95=B0=E6=9A=B4=E9=9C=B2?=
 =?UTF-8?q?,=20=E5=8F=AF=E4=BB=A5=E8=87=AA=E5=AE=9A=E4=B9=89=E6=8E=A7?=
 =?UTF-8?q?=E5=88=B6=203=E3=80=81=E7=AE=80=E5=8C=96=E4=BA=86uilayout?=
 =?UTF-8?q?=E9=87=8C=E4=B8=80=E4=BA=9B=E5=8F=98=E9=87=8F=E7=9A=84=E8=AE=BE?=
 =?UTF-8?q?=E7=BD=AE=E9=80=BB=E8=BE=91=204=E3=80=81=E8=B0=83=E6=95=B4?=
 =?UTF-8?q?=E4=BA=86=E8=87=AA=E5=AE=9A=E4=B9=89hook-useGetSetState?=
 =?UTF-8?q?=E7=9A=84=E5=AE=9A=E4=B9=89=205=E3=80=81=E8=BD=AF=E4=BB=B6?=
 =?UTF-8?q?=E5=90=AF=E5=8A=A8=E9=80=BB=E8=BE=91=E8=B0=83=E6=95=B4:=20yakit?=
 =?UTF-8?q?=E6=9B=B4=E6=96=B0=E5=AF=B9=E6=AF=94=E5=92=8C=E5=BC=95=E6=93=8E?=
 =?UTF-8?q?=E5=86=85=E7=BD=AE=E5=AF=B9=E6=AF=94;=20=E8=8E=B7=E5=8F=96?=
 =?UTF-8?q?=E6=8E=A5=E5=8F=A3=E7=9A=84=E5=B9=B6=E5=8F=91=E6=89=A7=E8=A1=8C?=
 =?UTF-8?q?;=20=E8=B0=83=E6=95=B4=E6=89=A7=E8=A1=8C=E9=A1=BA=E5=BA=8F(yaki?=
 =?UTF-8?q?t=E5=AF=B9=E6=AF=94-=E5=BC=95=E6=93=8E=E5=86=85=E7=BD=AE?=
 =?UTF-8?q?=E5=AF=B9=E6=AF=94-=E5=BC=95=E6=93=8E=E6=A0=A1=E9=AA=8C?=
 =?UTF-8?q?=E5=AF=B9=E6=AF=94);?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 app/main/handlers/upgradeUtil.js              | 428 ++++++------
 app/main/handlers/utils/network.js            |  58 +-
 .../handlers/utils/requestWithProgress.js     |   2 +-
 app/main/uiOperate/yaklangAndYakit.js         |  51 +-
 app/renderer/src/main/src/NewApp.tsx          |   7 +-
 app/renderer/src/main/src/apiUtils/grpc.ts    |  76 ++-
 .../main/src/components/layout/FuncDomain.tsx |   2 +-
 .../src/components/layout/GlobalState.tsx     |  10 +-
 .../src/components/layout/HelpDoc/HelpDoc.tsx |   8 +-
 .../layout/LocalEngine/LocalEngine.tsx        | 559 ++++++++--------
 .../layout/LocalEngine/LocalEngineType.d.ts   |   4 +-
 .../main/src/components/layout/UILayout.tsx   | 178 ++---
 .../layout/update/InstallEngine.tsx           |   8 +-
 .../update/UpdateYakitAndYaklang.module.scss  | 179 ++---
 .../layout/update/UpdateYakitAndYaklang.tsx   | 629 +++++++-----------
 .../src/main/src/constants/hardware.ts        |   3 +
 .../pages/pluginHub/hooks/useGetSetState.ts   |  19 +-
 .../eventBus/events/updateYakitYaklang.ts     |   2 -
 18 files changed, 1055 insertions(+), 1168 deletions(-)

diff --git a/app/main/handlers/upgradeUtil.js b/app/main/handlers/upgradeUtil.js
index 2bc7d182ab..d605a44706 100644
--- a/app/main/handlers/upgradeUtil.js
+++ b/app/main/handlers/upgradeUtil.js
@@ -1,14 +1,14 @@
-const { app, ipcMain, shell } = require("electron");
-const childProcess = require("child_process");
-const process = require("process");
-const path = require("path");
-const os = require("os");
-const fs = require("fs");
-const gracefulfs = require("graceful-fs");
-const https = require("https");
-const EventEmitter = require('events');
-const zip = require('node-stream-zip');
-const crypto = require("crypto");
+const {ipcMain, shell} = require("electron")
+const childProcess = require("child_process")
+const process = require("process")
+const path = require("path")
+const os = require("os")
+const fs = require("fs")
+const gracefulfs = require("graceful-fs")
+const https = require("https")
+const EventEmitter = require("events")
+const zip = require("node-stream-zip")
+const crypto = require("crypto")
 
 const {
     YakitProjectPath,
@@ -26,33 +26,29 @@ const {
     getYakitEEDownloadUrl,
     getYakitCommunityDownloadUrl,
     downloadYakEngine
-} = require("./utils/network");
-const {
-    engineCancelRequestWithProgress,
-    yakitCancelRequestWithProgress
-} = require("./utils/requestWithProgress");
-const { getCheckTextUrl } = require("../handlers/utils/network")
-
-const userChromeDataDir = path.join(YakitProjectPath, "chrome-profile");
-const authMeta = [];
+} = require("./utils/network")
+const {engineCancelRequestWithProgress, yakitCancelRequestWithProgress} = require("./utils/requestWithProgress")
+const {getCheckTextUrl} = require("../handlers/utils/network")
 
+const userChromeDataDir = path.join(YakitProjectPath, "chrome-profile")
+const authMeta = []
 
 const initMkbaseDir = async () => {
     return new Promise((resolve, reject) => {
         try {
-            fs.mkdirSync(remoteLinkDir, { recursive: true })
-            fs.mkdirSync(basicDir, { recursive: true })
-            fs.mkdirSync(userChromeDataDir, { recursive: true })
-            fs.mkdirSync(yaklangEngineDir, { recursive: true })
-            fs.mkdirSync(codeDir, { recursive: true })
+            fs.mkdirSync(remoteLinkDir, {recursive: true})
+            fs.mkdirSync(basicDir, {recursive: true})
+            fs.mkdirSync(userChromeDataDir, {recursive: true})
+            fs.mkdirSync(yaklangEngineDir, {recursive: true})
+            fs.mkdirSync(codeDir, {recursive: true})
 
             try {
                 console.info("Start checking bins/resources")
-                const extraResources = loadExtraFilePath(path.join("bins", "resources"));
-                const resourceBase = basicDir;
+                const extraResources = loadExtraFilePath(path.join("bins", "resources"))
+                const resourceBase = basicDir
                 if (!fs.existsSync(path.join(resourceBase, "flag.txt"))) {
                     console.info("Start to load bins/resources ...")
-                    fs.readdirSync(extraResources).forEach(value => {
+                    fs.readdirSync(extraResources).forEach((value) => {
                         if (value.endsWith(".txt")) {
                             try {
                                 fs.copyFileSync(path.join(extraResources, value), path.join(resourceBase, value))
@@ -76,8 +72,8 @@ const initMkbaseDir = async () => {
 const loadSecrets = () => {
     authMeta.splice(0, authMeta.length)
     try {
-        const data = fs.readFileSync(path.join(remoteLinkDir, "yakit-remote.json"));
-        JSON.parse(data).forEach(i => {
+        const data = fs.readFileSync(path.join(remoteLinkDir, "yakit-remote.json"))
+        JSON.parse(data).forEach((i) => {
             if (!(i["host"] && i["port"])) {
                 return
             }
@@ -88,12 +84,11 @@ const loadSecrets = () => {
                 port: i["port"],
                 tls: i["tls"] || false,
                 password: i["password"] || "",
-                caPem: i["caPem"] || "",
+                caPem: i["caPem"] || ""
             })
         })
-    } catch (e) {
-    }
-};
+    } catch (e) {}
+}
 
 function saveSecret(name, host, port, tls, password, caPem) {
     if (!host || !port) {
@@ -101,26 +96,30 @@ function saveSecret(name, host, port, tls, password, caPem) {
     }
 
     authMeta.push({
-        host, port, tls, password, caPem, name: name || `${host}:${port}`,
+        host,
+        port,
+        tls,
+        password,
+        caPem,
+        name: name || `${host}:${port}`
     })
     saveAllSecret([...authMeta])
-};
+}
 
-const isWindows = process.platform === "win32";
+const isWindows = process.platform === "win32"
 
 const saveAllSecret = (authInfos) => {
     try {
         fs.unlinkSync(remoteLinkFile)
-    } catch (e) {
-
-    }
-
+    } catch (e) {}
 
-    const authFileStr = JSON.stringify([...authInfos.filter((v, i, arr) => {
-        return arr.findIndex(origin => origin.name === v.name) === i
-    })]);
+    const authFileStr = JSON.stringify([
+        ...authInfos.filter((v, i, arr) => {
+            return arr.findIndex((origin) => origin.name === v.name) === i
+        })
+    ])
     fs.writeFileSync(remoteLinkFile, new Buffer(authFileStr, "utf8"))
-};
+}
 
 const getLatestYakLocalEngine = () => {
     switch (process.platform) {
@@ -149,38 +148,43 @@ const getYakitPlatform = () => {
 }
 
 module.exports = {
-    getLatestYakLocalEngine, initial: async () => {
-        return await initMkbaseDir();
-    }, register: (win, getClient) => {
+    getLatestYakLocalEngine,
+    initial: async () => {
+        return await initMkbaseDir()
+    },
+    register: (win, getClient) => {
         ipcMain.handle("save-yakit-remote-auth", async (e, params) => {
-            let { name, host, port, tls, caPem, password } = params;
+            let {name, host, port, tls, caPem, password} = params
             name = name || `${host}:${port}`
-            saveAllSecret([...authMeta.filter(i => {
-                return i.name !== name
-            })]);
+            saveAllSecret([
+                ...authMeta.filter((i) => {
+                    return i.name !== name
+                })
+            ])
             loadSecrets()
             saveSecret(name, host, port, tls, password, caPem)
         })
         ipcMain.handle("remove-yakit-remote-auth", async (e, name) => {
-            saveAllSecret([...authMeta.filter(i => {
-                return i.name !== name
-            })]);
-            loadSecrets();
+            saveAllSecret([
+                ...authMeta.filter((i) => {
+                    return i.name !== name
+                })
+            ])
+            loadSecrets()
         })
         ipcMain.handle("get-yakit-remote-auth-all", async (e, name) => {
             loadSecrets()
-            return authMeta;
+            return authMeta
         })
         ipcMain.handle("get-yakit-remote-auth-dir", async (e, name) => {
-            return remoteLinkDir;
+            return remoteLinkDir
         })
 
-        class YakVersionEmitter extends EventEmitter {
-        }
+        class YakVersionEmitter extends EventEmitter {}
 
-        const yakVersionEmitter = new YakVersionEmitter();
-        let isFetchingVersion = false;
-        let latestVersionCache = null;
+        const yakVersionEmitter = new YakVersionEmitter()
+        let isFetchingVersion = false
+        let latestVersionCache = null
 
         /** clear latestVersionCache value */
         ipcMain.handle("clear-local-yaklang-version-cache", async (e) => {
@@ -193,48 +197,50 @@ module.exports = {
             return new Promise((resolve, reject) => {
                 if (latestVersionCache) {
                     resolve(latestVersionCache)
-                    return;
+                    return
                 }
 
                 console.info("YAK-VERSION: mount version")
-                yakVersionEmitter.once('version', (err, version) => {
+                yakVersionEmitter.once("version", (err, version) => {
                     if (err) {
-                        diagnosingYakVersion().catch(err => {
-                            console.info("YAK-VERSION(DIAG): fetch error: " + `${err}`)
-                            reject(err)
-                        }).then(() => {
-                            console.info("YAK-VERSION: fetch error: " + `${err}`)
-                            reject(err)
-                        })
+                        diagnosingYakVersion()
+                            .catch((err) => {
+                                console.info("YAK-VERSION(DIAG): fetch error: " + `${err}`)
+                                reject(err)
+                            })
+                            .then(() => {
+                                console.info("YAK-VERSION: fetch error: " + `${err}`)
+                                reject(err)
+                            })
                     } else {
                         console.info("YAK-VERSION: hit version: " + `${version}`)
-                        resolve(version);
+                        resolve(version)
                     }
                 })
                 if (isFetchingVersion) {
                     console.info("YAK-VERSION is executing...")
-                    return;
+                    return
                 }
 
                 console.info("YAK-VERSION process is executing...")
-                isFetchingVersion = true;
+                isFetchingVersion = true
                 childProcess.execFile(getLatestYakLocalEngine(), ["-v"], (err, stdout) => {
                     console.info(stdout)
                     if (err) {
-                        yakVersionEmitter.emit('version', err, null);
+                        yakVersionEmitter.emit("version", err, null)
                         isFetchingVersion = false
-                        return;
+                        return
                     }
                     // const version = stdout.replaceAll("yak version ()", "").trim();
-                    const match = /.*?yak(\.exe)?\s+version\s+(\S+)/.exec(stdout);
-                    const version = match && match[2];
+                    const match = /.*?yak(\.exe)?\s+version\s+(\S+)/.exec(stdout)
+                    const version = match && match[2]
                     if (!version) {
-                        const error = new Error("[unknown reason] cannot fetch yak version (yak -v)");
-                        yakVersionEmitter.emit('version', error, null);
-                        isFetchingVersion = false;
+                        const error = new Error("[unknown reason] cannot fetch yak version (yak -v)")
+                        yakVersionEmitter.emit("version", error, null)
+                        isFetchingVersion = false
                     } else {
-                        latestVersionCache = version;
-                        yakVersionEmitter.emit('version', null, version);
+                        latestVersionCache = version
+                        yakVersionEmitter.emit("version", null, version)
                         isFetchingVersion = false
                     }
                 })
@@ -244,57 +250,65 @@ module.exports = {
             return await asyncGetCurrentLatestYakVersion(params)
         })
 
-        const diagnosingYakVersion = () => new Promise((resolve, reject) => {
-            const commandPath = getLatestYakLocalEngine()
-            fs.access(commandPath, fs.constants.X_OK, err => {
-                if (err) {
-                    if (err.code === 'ENOENT') {
-                        reject(new Error(`命令未找到: ${commandPath}`));
-                    } else if (err.code === 'EACCES') {
-                        reject(new Error(`命令无法执行(无权限): ${commandPath}`));
-                    } else {
-                        reject(new Error(`命令无法执行: ${commandPath}`));
+        const diagnosingYakVersion = () =>
+            new Promise((resolve, reject) => {
+                const commandPath = getLatestYakLocalEngine()
+                fs.access(commandPath, fs.constants.X_OK, (err) => {
+                    if (err) {
+                        if (err.code === "ENOENT") {
+                            reject(new Error(`命令未找到: ${commandPath}`))
+                        } else if (err.code === "EACCES") {
+                            reject(new Error(`命令无法执行(无权限): ${commandPath}`))
+                        } else {
+                            reject(new Error(`命令无法执行: ${commandPath}`))
+                        }
+                        return
                     }
-                    return;
-                }
 
-                childProcess.execFile(commandPath, ['-v'], { timeout: 20000 }, (error, stdout, stderr) => {
-                    if (error) {
-                        let errorMessage = `命令执行失败: ${error.message}\nStdout: ${stdout}\nStderr: ${stderr}`;
-                        if (error.code === 'ENOENT') {
-                            errorMessage = `无法执行命令，引擎未找到: ${commandPath}\nStderr: ${stderr}`;
-                        } else if (error.killed) {
-                            errorMessage = `引擎启动被系统强制终止，可能的原因为内存占用过多或系统退出或安全防护软件: ${commandPath}\nStderr: ${stderr}`;
-                        } else if (error.signal) {
-                            errorMessage = `引擎由于信号而终止: ${error.signal}\nStderr: ${stderr}`;
-                        } else if (error.code === 'ETIMEDOUT') {
-                            errorMessage = `命令执行超时，进程遭遇未知问题，需要用户在命令行中执行引擎调试: ${commandPath}\nStdout: ${stdout}\nStderr: ${stderr}`;
-                        }
+                    childProcess.execFile(commandPath, ["-v"], {timeout: 20000}, (error, stdout, stderr) => {
+                        if (error) {
+                            let errorMessage = `命令执行失败: ${error.message}\nStdout: ${stdout}\nStderr: ${stderr}`
+                            if (error.code === "ENOENT") {
+                                errorMessage = `无法执行命令，引擎未找到: ${commandPath}\nStderr: ${stderr}`
+                            } else if (error.killed) {
+                                errorMessage = `引擎启动被系统强制终止，可能的原因为内存占用过多或系统退出或安全防护软件: ${commandPath}\nStderr: ${stderr}`
+                            } else if (error.signal) {
+                                errorMessage = `引擎由于信号而终止: ${error.signal}\nStderr: ${stderr}`
+                            } else if (error.code === "ETIMEDOUT") {
+                                errorMessage = `命令执行超时，进程遭遇未知问题，需要用户在命令行中执行引擎调试: ${commandPath}\nStdout: ${stdout}\nStderr: ${stderr}`
+                            }
 
-                        reject(new Error(errorMessage));
-                        return;
-                    }
+                            reject(new Error(errorMessage))
+                            return
+                        }
 
-                    resolve(stdout);
+                        resolve(stdout)
+                    })
                 })
             })
-        })
-        ipcMain.handle('diagnosing-yak-version', async (e, params) => {
+        ipcMain.handle("diagnosing-yak-version", async (e, params) => {
             return diagnosingYakVersion()
         })
 
         // asyncDownloadLatestYak wrapper
         const asyncDownloadLatestYak = (version) => {
             return new Promise(async (resolve, reject) => {
-                const dest = path.join(yaklangEngineDir, version.startsWith('dev/') ? 'yak-' + version.replace('dev/', 'dev-') : `yak-${version}`);
+                const dest = path.join(
+                    yaklangEngineDir,
+                    version.startsWith("dev/") ? "yak-" + version.replace("dev/", "dev-") : `yak-${version}`
+                )
                 try {
                     fs.unlinkSync(dest)
-                } catch (e) {
-
-                }
-                await downloadYakEngine(version, dest, state => {
-                    win.webContents.send("download-yak-engine-progress", state)
-                }, resolve, reject)
+                } catch (e) {}
+                await downloadYakEngine(
+                    version,
+                    dest,
+                    (state) => {
+                        win.webContents.send("download-yak-engine-progress", state)
+                    },
+                    resolve,
+                    reject
+                )
             })
         }
         ipcMain.handle("download-latest-yak", async (e, version) => {
@@ -303,7 +317,10 @@ module.exports = {
 
         // 判断历史引擎版本是否存在以及正确性
         const asyncYakEngineVersionExistsAndCorrectness = (version) => {
-            const dest = path.join(yaklangEngineDir, version.startsWith('dev/') ? 'yak-' + version.replace('dev/', 'dev-') : `yak-${version}`);
+            const dest = path.join(
+                yaklangEngineDir,
+                version.startsWith("dev/") ? "yak-" + version.replace("dev/", "dev-") : `yak-${version}`
+            )
             return new Promise(async (resolve, reject) => {
                 try {
                     const url = await getCheckTextUrl(version)
@@ -327,12 +344,13 @@ module.exports = {
                             }).on("error", (err) => reject(err))
                         })
                         rsp.on("error", (err) => reject(err))
-                        rsp.setTimeout(3000, () => { // 设置请求超时时间为3秒
+                        rsp.setTimeout(3000, () => {
+                            // 设置请求超时时间为3秒
                             rsp.destroy() // 超时后中止请求
-                            reject('Request timeout')
+                            reject("Request timeout")
                         })
                     } else {
-                        reject('Engine version directory does not exist')
+                        reject("Engine version directory does not exist")
                     }
                 } catch (error) {
                     reject(error)
@@ -356,29 +374,42 @@ module.exports = {
 
                 console.info("start to fetching download-url for yakit")
 
-                const downloadUrl = isEnterprise ? await getYakitEEDownloadUrl(version) : await getYakitCommunityDownloadUrl(version)
+                const downloadUrl = isEnterprise
+                    ? await getYakitEEDownloadUrl(version)
+                    : await getYakitCommunityDownloadUrl(version)
                 // 可能存在中文的下载文件夹，就判断下Downloads文件夹是否存在，不存在则新建一个
-                if (!fs.existsSync(yakitInstallDir)) fs.mkdirSync(yakitInstallDir, { recursive: true })
-                const dest = path.join(yakitInstallDir, path.basename(downloadUrl));
+                if (!fs.existsSync(yakitInstallDir)) fs.mkdirSync(yakitInstallDir, {recursive: true})
+                const dest = path.join(yakitInstallDir, path.basename(downloadUrl))
                 try {
                     fs.unlinkSync(dest)
-                } catch (e) {
-                }
+                } catch (e) {}
 
                 console.info(`start to download yakit from ${downloadUrl} to ${dest}`)
 
                 if (isEnterprise) {
-                    await downloadYakitEE(version, dest, state => {
-                        if (!!state) {
-                            win.webContents.send("download-yakit-engine-progress", state)
-                        }
-                    }, resolve, reject)
+                    await downloadYakitEE(
+                        version,
+                        dest,
+                        (state) => {
+                            if (!!state) {
+                                win.webContents.send("download-yakit-engine-progress", state)
+                            }
+                        },
+                        resolve,
+                        reject
+                    )
                 } else {
-                    await downloadYakitCommunity(version, dest, state => {
-                        if (!!state) {
-                            win.webContents.send("download-yakit-engine-progress", state)
-                        }
-                    }, resolve, reject)
+                    await downloadYakitCommunity(
+                        version,
+                        dest,
+                        (state) => {
+                            if (!!state) {
+                                win.webContents.send("download-yakit-engine-progress", state)
+                            }
+                        },
+                        resolve,
+                        reject
+                    )
                 }
             })
         }
@@ -398,11 +429,11 @@ module.exports = {
         })
 
         ipcMain.handle("update-enpritrace-info", async () => {
-            return await { version: getYakitPlatform() }
+            return await {version: getYakitPlatform()}
         })
 
         ipcMain.handle("get-windows-install-dir", async (e) => {
-            return getLatestYakLocalEngine();
+            return getLatestYakLocalEngine()
             //systemRoot := os.Getenv("WINDIR")
             // 			if systemRoot == "" {
             // 				systemRoot = os.Getenv("windir")
@@ -420,15 +451,17 @@ module.exports = {
             //     return "%WINDIR%\\System32\\yak.exe"
             // }
             // return getWindowsInstallPath();
-
-        });
+        })
 
         const installYakEngine = (version) => {
             return new Promise((resolve, reject) => {
-                let origin = path.join(yaklangEngineDir, version.startsWith('dev/') ? 'yak-' + version.replace('dev/', 'dev-') : `yak-${version}`);
-                origin = origin.replaceAll(`"`, `\"`);
+                let origin = path.join(
+                    yaklangEngineDir,
+                    version.startsWith("dev/") ? "yak-" + version.replace("dev/", "dev-") : `yak-${version}`
+                )
+                origin = origin.replaceAll(`"`, `\"`)
 
-                let dest = getLatestYakLocalEngine(); //;isWindows ? getWindowsInstallPath() : "/usr/local/bin/yak";
+                let dest = getLatestYakLocalEngine() //;isWindows ? getWindowsInstallPath() : "/usr/local/bin/yak";
                 dest = dest.replaceAll(`"`, `\"`)
                 // setTimeout childProcess.exec执行顺序 确保childProcess.exec执行后不会再执行tryUnlink
                 let flag = false
@@ -439,39 +472,44 @@ module.exports = {
                     } catch (err) {
                         if (err.message.indexOf("operation not permitted") > -1) {
                             if (retriesLeft > 0) {
-                                setTimeout(() => tryUnlink(retriesLeft - 1), 500);
+                                setTimeout(() => tryUnlink(retriesLeft - 1), 500)
                             } else {
                                 reject("operation not permitted")
                             }
                         }
                     }
-
                 }
-                tryUnlink(2);
-                childProcess.exec(isWindows ? `copy "${origin}" "${dest}"` : `cp "${origin}" "${dest}" && chmod +x "${dest}"`, err => {
-                    flag = true
-                    if (err) {
-                        if (err.message.indexOf('The process cannot access the file because it is being used by another process') !== -1) {
-                            reject("operation not permitted")
-                        } else {
-                            reject(err)
+                tryUnlink(2)
+                childProcess.exec(
+                    isWindows ? `copy "${origin}" "${dest}"` : `cp "${origin}" "${dest}" && chmod +x "${dest}"`,
+                    (err) => {
+                        flag = true
+                        if (err) {
+                            if (
+                                err.message.indexOf(
+                                    "The process cannot access the file because it is being used by another process"
+                                ) !== -1
+                            ) {
+                                reject("operation not permitted")
+                            } else {
+                                reject(err)
+                            }
+                            return
                         }
-                        return
+                        resolve()
                     }
-                    resolve()
-                })
+                )
             })
-
         }
 
         ipcMain.handle("install-yak-engine", async (e, version) => {
-            return await installYakEngine(version);
+            return await installYakEngine(version)
         })
 
         // 获取yak code文件根目录路径
         ipcMain.handle("fetch-code-path", () => {
             return codeDir
-        });
+        })
 
         // 打开指定路径文件
         ipcMain.handle("open-specified-file", async (e, path) => {
@@ -488,7 +526,8 @@ module.exports = {
                 }
                 console.log("start to gen cert script")
                 const zipHandler = new zip({
-                    file: loadExtraFilePath(path.join("bins/scripts", all)), storeEntries: true,
+                    file: loadExtraFilePath(path.join("bins/scripts", all)),
+                    storeEntries: true
                 })
                 zipHandler.on("ready", () => {
                     const targetPath = path.join(YakitProjectPath, output_name)
@@ -498,14 +537,14 @@ module.exports = {
                         } else {
                             // 如果不是 Windows，给脚本文件添加执行权限
                             if (!isWindows) {
-                                fs.chmodSync(targetPath, 0o755);
+                                fs.chmodSync(targetPath, 0o755)
                             }
                             resolve(targetPath)
                         }
-                        zipHandler.close();
+                        zipHandler.close()
                     })
                 })
-                zipHandler.on("error", err => {
+                zipHandler.on("error", (err) => {
                     console.info(err)
                     reject(`${err}`)
                     zipHandler.close()
@@ -513,7 +552,6 @@ module.exports = {
             })
         }
 
-
         ipcMain.handle("generate-install-script", async (e) => {
             return await generateInstallScript()
         })
@@ -528,16 +566,17 @@ module.exports = {
 
                 console.info("Start to Extract yak.zip")
                 const zipHandler = new zip({
-                    file: loadExtraFilePath(path.join("bins", "yak.zip")), storeEntries: true,
+                    file: loadExtraFilePath(path.join("bins", "yak.zip")),
+                    storeEntries: true
                 })
                 console.info("Start to Extract yak.zip: Set `ready`")
                 zipHandler.on("ready", () => {
-                    const buildInPath = path.join(yaklangEngineDir, "yak.build-in");
+                    const buildInPath = path.join(yaklangEngineDir, "yak.build-in")
 
-                    console.log('Entries read: ' + zipHandler.entriesCount);
+                    console.log("Entries read: " + zipHandler.entriesCount)
                     for (const entry of Object.values(zipHandler.entries())) {
-                        const desc = entry.isDirectory ? 'directory' : `${entry.size} bytes`;
-                        console.log(`Entry ${entry.name}: ${desc}`);
+                        const desc = entry.isDirectory ? "directory" : `${entry.size} bytes`
+                        console.log(`Entry ${entry.name}: ${desc}`)
                     }
 
                     console.info("we will extract file to: " + buildInPath)
@@ -567,7 +606,6 @@ module.exports = {
                         if (!fs.existsSync(buildInPath)) {
                             reject(`Extract BuildIn Engine Failed`)
                         } else {
-
                             /**
                              * 复制引擎到真实地址
                              * */
@@ -585,11 +623,11 @@ module.exports = {
                             }
                         }
                         console.info("zipHandler closing...")
-                        zipHandler.close();
+                        zipHandler.close()
                     })
                 })
                 console.info("Start to Extract yak.zip: Set `error`")
-                zipHandler.on("error", err => {
+                zipHandler.on("error", (err) => {
                     console.info(err)
                     reject(`${err}`)
                     zipHandler.close()
@@ -606,21 +644,24 @@ module.exports = {
             if (fs.existsSync(targetFile)) {
                 return
             }
-            const buildinDBFile = loadExtraFilePath(path.join("bins", "database", "default-cve.db.gzip"));
+            const buildinDBFile = loadExtraFilePath(path.join("bins", "database", "default-cve.db.gzip"))
             if (fs.existsSync(buildinDBFile)) {
                 fs.copyFileSync(buildinDBFile, targetFile)
             }
         })
 
         // 获取内置引擎版本
-        ipcMain.handle("GetBuildInEngineVersion"
-            /*"IsBinsExisted"*/, async (e) => {
-                const yakZipName = path.join("bins", "yak.zip")
-                if (!fs.existsSync(loadExtraFilePath(yakZipName))) {
-                    throw Error(`Cannot found yak.zip, bins: ${loadExtraFilePath(yakZipName)}`)
+        ipcMain.handle(
+            "GetBuildInEngineVersion",
+            /*"IsBinsExisted"*/ async (e) => {
+                const yakZipPath = path.join("bins", "yak.zip")
+                if (!fs.existsSync(loadExtraFilePath(yakZipPath))) {
+                    throw Error(`Cannot found yak.zip, bins: ${loadExtraFilePath(yakZipPath)}`)
                 }
-                return fs.readFileSync(loadExtraFilePath(path.join("bins", "engine-version.txt"))).toString("utf8")
-            })
+                const versionPath = path.join("bins", "engine-version.txt")
+                return fs.readFileSync(loadExtraFilePath(versionPath)).toString("utf8")
+            }
+        )
 
         // asyncRestoreEngineAndPlugin wrapper
         ipcMain.handle("RestoreEngineAndPlugin", async (e, params) => {
@@ -640,7 +681,6 @@ module.exports = {
                 if (fs.existsSync(cacheFlagLock)) {
                     fs.unlinkSync(cacheFlagLock)
                 }
-
             } catch (e) {
                 throw e
             }
@@ -653,14 +693,14 @@ module.exports = {
                 } catch (err) {
                     if (err.message.indexOf("operation not permitted") > -1) {
                         if (retriesLeft > 0) {
-                            setTimeout(() => tryUnlink(retriesLeft - 1), 500);
+                            setTimeout(() => tryUnlink(retriesLeft - 1), 500)
                         } else {
                             throw e
                         }
                     }
                 }
             }
-            tryUnlink(2);
+            tryUnlink(2)
             return await asyncInitBuildInEngine({})
         })
 
@@ -681,7 +721,8 @@ module.exports = {
                     return
                 }
                 const zipHandler = new zip({
-                    file: loadExtraFilePath(path.join("bins/scripts", all)), storeEntries: true,
+                    file: loadExtraFilePath(path.join("bins/scripts", all)),
+                    storeEntries: true
                 })
                 zipHandler.on("ready", () => {
                     const targetPath = path.join(yaklangEngineDir, output_name)
@@ -691,14 +732,14 @@ module.exports = {
                         } else {
                             // 如果不是 Windows，给脚本文件添加执行权限
                             if (!isWindows) {
-                                fs.chmodSync(targetPath, 0o755);
+                                fs.chmodSync(targetPath, 0o755)
                             }
                             resolve("")
                         }
-                        zipHandler.close();
+                        zipHandler.close()
                     })
                 })
-                zipHandler.on("error", err => {
+                zipHandler.on("error", (err) => {
                     console.info(err)
                     reject(`${err}`)
                     zipHandler.close()
@@ -706,9 +747,8 @@ module.exports = {
             })
         }
 
-
         ipcMain.handle("generate-start-engine", async (e) => {
             return await generateStartEngineGRPC()
         })
-    },
-}
\ No newline at end of file
+    }
+}
diff --git a/app/main/handlers/utils/network.js b/app/main/handlers/utils/network.js
index 4ccecbcc80..2f87fd5e81 100644
--- a/app/main/handlers/utils/network.js
+++ b/app/main/handlers/utils/network.js
@@ -101,7 +101,7 @@ async function getAvailableOSSDomain() {
     }
 }
 
-/**获取校验url */
+/** 获取校验url */
 const getCheckTextUrl = async (version) => {
     const domain = await getAvailableOSSDomain()
     let system_mode = ""
@@ -136,6 +136,21 @@ const getCheckTextUrl = async (version) => {
     }
     return url
 }
+/** 获取指定版本号的引擎Hash值 */
+const fetchSpecifiedYakVersionHash = async (version, requestConfig) => {
+    const url = await getCheckTextUrl(version)
+    if (url === "") {
+        throw new Error(`No Find ${version} Hash Url`)
+    }
+    return axios.get(url, {...(requestConfig || {}), httpsAgent: getHttpsAgentByDomain(url)}).then((response) => {
+        const versionData = Buffer.from(response.data).toString("utf8")
+        if (versionData.length > 0) {
+            return Buffer.from(response.data).toString("utf8")
+        } else {
+            throw new Error("校验值不存在")
+        }
+    })
+}
 /** 获取最新 yak 版本号 */
 const fetchLatestYakEngineVersion = async () => {
     const domain = await getAvailableOSSDomain()
@@ -150,30 +165,34 @@ const fetchLatestYakEngineVersion = async () => {
     })
 }
 /** 获取最新 yakit 版本号 */
-const fetchLatestYakitVersion = async () => {
+const fetchLatestYakitVersion = async (requestConfig) => {
     const domain = await getAvailableOSSDomain()
     const versionUrl = `https://${domain}/yak/latest/yakit-version.txt`
-    return axios.get(versionUrl, {httpsAgent: getHttpsAgentByDomain(domain)}).then((response) => {
-        const versionData = `${response.data}`.trim()
-        if (versionData.length > 0) {
-            return versionData.startsWith("v") ? versionData : `v${versionData}`
-        } else {
-            throw new Error("Failed to fetch version data")
-        }
-    })
+    return axios
+        .get(versionUrl, {...(requestConfig || {}), httpsAgent: getHttpsAgentByDomain(domain)})
+        .then((response) => {
+            const versionData = `${response.data}`.trim()
+            if (versionData.length > 0) {
+                return versionData.startsWith("v") ? versionData : `v${versionData}`
+            } else {
+                throw new Error("Failed to fetch version data")
+            }
+        })
 }
 /** 获取最新 yakit EE 版本号 */
-const fetchLatestYakitEEVersion = async () => {
+const fetchLatestYakitEEVersion = async (requestConfig) => {
     const domain = await getAvailableOSSDomain()
     const versionUrl = `https://${domain}/vip/latest/yakit-version.txt`
-    return axios.get(versionUrl, {httpsAgent: getHttpsAgentByDomain(domain)}).then((response) => {
-        const versionData = `${response.data}`.trim()
-        if (versionData.length > 0) {
-            return versionData.startsWith("v") ? versionData : `v${versionData}`
-        } else {
-            throw new Error("Failed to fetch version data")
-        }
-    })
+    return axios
+        .get(versionUrl, {...(requestConfig || {}), httpsAgent: getHttpsAgentByDomain(domain)})
+        .then((response) => {
+            const versionData = `${response.data}`.trim()
+            if (versionData.length > 0) {
+                return versionData.startsWith("v") ? versionData : `v${versionData}`
+            } else {
+                throw new Error("Failed to fetch version data")
+            }
+        })
 }
 /** 引擎下载地址 */
 const getYakEngineDownloadUrl = async (version) => {
@@ -295,6 +314,7 @@ const downloadYakitEE = async (version, destination, progressHandler, onFinished
 
 module.exports = {
     getCheckTextUrl,
+    fetchSpecifiedYakVersionHash,
     fetchLatestYakEngineVersion,
     fetchLatestYakitVersion,
     fetchLatestYakitEEVersion,
diff --git a/app/main/handlers/utils/requestWithProgress.js b/app/main/handlers/utils/requestWithProgress.js
index da48abc3c3..6d6626239c 100644
--- a/app/main/handlers/utils/requestWithProgress.js
+++ b/app/main/handlers/utils/requestWithProgress.js
@@ -156,7 +156,7 @@ function yakitCancelRequestWithProgress() {
     return new Promise((resolve, reject) => {
         if (writer) {
             writer.on("close", () => {
-                reject(new Error("Write operation cancelled"))
+                reject(new Error("Write operation stoped"))
             })
             writer.destroy(new Error("Write operation cancelled"))
         } else {
diff --git a/app/main/uiOperate/yaklangAndYakit.js b/app/main/uiOperate/yaklangAndYakit.js
index f6ab09bafd..5e9f7e0dc2 100644
--- a/app/main/uiOperate/yaklangAndYakit.js
+++ b/app/main/uiOperate/yaklangAndYakit.js
@@ -9,6 +9,7 @@ const {
     fetchLatestYakitEEVersion,
     fetchLatestYakitVersion,
     getAvailableOSSDomain,
+    fetchSpecifiedYakVersionHash
 } = require("../handlers/utils/network")
 const {getCheckTextUrl} = require("../handlers/utils/network")
 
@@ -41,10 +42,11 @@ module.exports = (win, getClient) => {
     })
 
     /** 获取Yakit最新版本号 */
-    const asyncFetchLatestYakitVersion = (isEnterprise) => {
+    const asyncFetchLatestYakitVersion = (params) => {
+        const {config, isEnterprise} = params
         return new Promise((resolve, reject) => {
             const fetchPromise = isEnterprise ? fetchLatestYakitEEVersion : fetchLatestYakitVersion
-            fetchPromise()
+            fetchPromise(config)
                 .then((version) => {
                     resolve(version)
                 })
@@ -54,8 +56,8 @@ module.exports = (win, getClient) => {
         })
     }
     /** 获取Yakit最新版本号 */
-    ipcMain.handle("fetch-latest-yakit-version", async (e, isEnterprise) => {
-        return await asyncFetchLatestYakitVersion(isEnterprise)
+    ipcMain.handle("fetch-latest-yakit-version", async (e, params) => {
+        return await asyncFetchLatestYakitVersion(params)
     })
 
     /** 获取Yakit本地版本号 */
@@ -68,20 +70,6 @@ module.exports = (win, getClient) => {
         win.webContents.send("kill-old-engine-process-callback", type)
     })
 
-    /** 获取软件当前版本对应的引擎版本号 */
-    ipcMain.handle("fetch-built-in-engine-version", (e) => {
-        const versionPath = loadExtraFilePath(path.join("bins", "engine-version.txt"))
-        if (fs.existsSync(versionPath)) {
-            try {
-                return fs.readFileSync(versionPath).toString("utf8")
-            } catch (error) {
-                return ""
-            }
-        } else {
-            return ""
-        }
-    })
-
     /** 获取Yaklang所有版本 */
     const asyncFetchYaklangVersionList = async () => {
         return new Promise(async (resolve, reject) => {
@@ -100,31 +88,8 @@ module.exports = (win, getClient) => {
         return await asyncFetchYaklangVersionList()
     })
 
-    const asyncFetchCheckYaklangSource = (version) => {
-        return new Promise(async (resolve, reject) => {
-            try {
-                const url = await getCheckTextUrl(version)
-                if (url === "") {
-                    reject(`Unsupported platform: ${process.platform}`)
-                }
-                let rsp = https.get(url)
-                rsp.on("response", (rsp) => {
-                    rsp.on("data", (data) => {
-                        if (rsp.statusCode == 200) {
-                            resolve(Buffer.from(data).toString("utf8"))
-                        } else {
-                            reject("校验值不存在")
-                        }
-                    }).on("error", (err) => reject(err))
-                })
-                rsp.on("error", reject)
-            } catch (error) {
-                reject(error)
-            }
-        })
-    }
     /** 校验Yaklang来源是否正确 */
-    ipcMain.handle("fetch-check-yaklang-source", async (e, version) => {
-        return await asyncFetchCheckYaklangSource(version)
+    ipcMain.handle("fetch-check-yaklang-source", async (e, version, requestConfig) => {
+        return await fetchSpecifiedYakVersionHash(version, requestConfig)
     })
 }
diff --git a/app/renderer/src/main/src/NewApp.tsx b/app/renderer/src/main/src/NewApp.tsx
index 482d7f3782..5208d9561c 100644
--- a/app/renderer/src/main/src/NewApp.tsx
+++ b/app/renderer/src/main/src/NewApp.tsx
@@ -18,7 +18,7 @@ import {useTemporaryProjectStore} from "./store/temporaryProject"
 import {useRunNodeStore} from "./store/runNode"
 import {LocalGVS} from "./enums/localGlobal"
 import {handleFetchSystemInfo} from "./constants/hardware"
-import { closeWebSocket, startWebSocket } from "./utils/webSocket/webSocket"
+import {closeWebSocket, startWebSocket} from "./utils/webSocket/webSocket"
 
 /** 部分页面懒加载 */
 const Main = lazy(() => import("./pages/MainOperator"))
@@ -46,6 +46,7 @@ function NewApp() {
     useEffect(() => {
         // 解压命令执行引擎脚本压缩包
         ipcRenderer.invoke("generate-start-engine")
+        // 获取系统信息
         handleFetchSystemInfo()
         // 告诉主进程软件的版本(CE|EE)
         ipcRenderer.invoke("is-enpritrace-to-domain", !isCommunityEdition())
@@ -308,13 +309,13 @@ function NewApp() {
     }, [userInfo.isLogin])
 
     // 在页面打开时，执行一次，用于初始化WebSocket推送（DuplexConnection）
-    useEffect(()=>{
+    useEffect(() => {
         startWebSocket()
         return () => {
             // 当组件销毁的时候，关闭WebSocket
             closeWebSocket()
         }
-    },[])
+    }, [])
 
     if (!agreed) {
         return (
diff --git a/app/renderer/src/main/src/apiUtils/grpc.ts b/app/renderer/src/main/src/apiUtils/grpc.ts
index 2b34bc1056..853506f92a 100644
--- a/app/renderer/src/main/src/apiUtils/grpc.ts
+++ b/app/renderer/src/main/src/apiUtils/grpc.ts
@@ -1,14 +1,21 @@
 import {yakitNotify} from "@/utils/notification"
-import {APINoRequestFunc} from "./type"
+import {APIFunc, APINoRequestFunc, APIOptionalFunc} from "./type"
 import {isCommunityEdition} from "@/utils/envfile"
 
 const {ipcRenderer} = window.require("electron")
 
+interface GrpcToHTTPRequestProps {
+    timeout?: number
+}
+
 /** @name 获取Yakit最新版本号 */
-export const grpcFetchLatestYakitVersion: APINoRequestFunc<string> = (hiddenError) => {
+export const grpcFetchLatestYakitVersion: APIOptionalFunc<GrpcToHTTPRequestProps, string> = (config, hiddenError) => {
     return new Promise(async (resolve, reject) => {
         ipcRenderer
-            .invoke("fetch-latest-yakit-version", !isCommunityEdition())
+            .invoke("fetch-latest-yakit-version", {
+                config: config,
+                isEnterprise: !isCommunityEdition()
+            })
             .then(resolve)
             .catch((e) => {
                 if (!hiddenError) yakitNotify("error", "获取最新软件版本失败:" + e)
@@ -17,19 +24,22 @@ export const grpcFetchLatestYakitVersion: APINoRequestFunc<string> = (hiddenErro
     })
 }
 
-let ossDomain: string = "";
+let ossDomain: string = ""
 
 /** @name OSS域名 */
 export const grpcFetchLatestOSSDomain: APINoRequestFunc<string> = (hiddenError) => {
     return new Promise(async (resolve, reject) => {
-        if(ossDomain && ossDomain.length > 0){
+        if (ossDomain && ossDomain.length > 0) {
             resolve(ossDomain)
             return
         }
-        ipcRenderer.invoke("get-available-oss-domain").then((domain)=>{
-            ossDomain = domain
-            resolve(domain)
-        }).catch(reject)
+        ipcRenderer
+            .invoke("get-available-oss-domain")
+            .then((domain) => {
+                ossDomain = domain
+                resolve(domain)
+            })
+            .catch(reject)
     })
 }
 
@@ -55,14 +65,14 @@ export const grpcFetchLocalYakitVersion: APINoRequestFunc<string> = (hiddenError
         ipcRenderer
             .invoke("fetch-yakit-version")
             .then((version: string) => {
-                let newVersion=version
+                let newVersion = version
                 // 如果存在-ce，则软件是 CE 版本
-                if(version.endsWith("-ce")){
+                if (version.endsWith("-ce")) {
                     newVersion = version.replace("-ce", "")
-               }
+                }
                 // 如果存在-ee，则软件是 EE 版本
-                if(version.endsWith("-ee")){
-                     newVersion = version.replace("-ee", "")
+                if (version.endsWith("-ee")) {
+                    newVersion = version.replace("-ee", "")
                 }
                 resolve(newVersion)
             })
@@ -98,3 +108,41 @@ export const grpcFetchYakInstallResult: APINoRequestFunc<boolean> = (hiddenError
             })
     })
 }
+
+/**
+ * @name 获取Yak内置引擎版本号
+ * 如果没有内置引擎压缩包，也算无法获取到内置引擎版本号
+ */
+export const grpcFetchBuildInYakVersion: APINoRequestFunc<string> = (hiddenError) => {
+    return new Promise(async (resolve, reject) => {
+        ipcRenderer
+            .invoke("GetBuildInEngineVersion")
+            .then((res) => {
+                // 考虑文件里的版本号可能有换行符，需要去掉
+                const version = (res || "").replace(/\r?\n/g, "")
+                resolve(version)
+            })
+            .catch((e) => {
+                if (!hiddenError) yakitNotify("error", "获取内置引擎版本失败:" + e)
+                reject(e)
+            })
+    })
+}
+
+/** @name 获取指定Yak引擎版本号的校验Hash值 */
+export const grpcFetchSpecifiedYakVersionHash: APIFunc<{version: string; config: GrpcToHTTPRequestProps}, string> = (
+    request,
+    hiddenError
+) => {
+    const {version, config} = request
+
+    return new Promise(async (resolve, reject) => {
+        ipcRenderer
+            .invoke("fetch-check-yaklang-source", version, config)
+            .then(resolve)
+            .catch((e) => {
+                if (!hiddenError) yakitNotify("error", "获取最新软件版本失败:" + e)
+                reject(e)
+            })
+    })
+}
diff --git a/app/renderer/src/main/src/components/layout/FuncDomain.tsx b/app/renderer/src/main/src/components/layout/FuncDomain.tsx
index 0a06f28b99..1a31d7eb87 100644
--- a/app/renderer/src/main/src/components/layout/FuncDomain.tsx
+++ b/app/renderer/src/main/src/components/layout/FuncDomain.tsx
@@ -1676,7 +1676,7 @@ const UIOpNotice: React.FC<UIOpNoticeProp> = React.memo((props) => {
     const fetchYakitLastVersion = useMemoizedFn(() => {
         /** 社区版埋点 */
         if (isCommunityEdition()) visitorsStatisticsFun()
-        grpcFetchLatestYakitVersion(true)
+        grpcFetchLatestYakitVersion(undefined, true)
             .then((data: string) => {
                 setYakitLastVersion(data)
             })
diff --git a/app/renderer/src/main/src/components/layout/GlobalState.tsx b/app/renderer/src/main/src/components/layout/GlobalState.tsx
index 5b58fcad15..1c45973dc9 100644
--- a/app/renderer/src/main/src/components/layout/GlobalState.tsx
+++ b/app/renderer/src/main/src/components/layout/GlobalState.tsx
@@ -35,7 +35,7 @@ import emiter from "@/utils/eventBus/eventBus"
 import {serverPushStatus} from "@/utils/duplex/duplex"
 import {openABSFileLocated} from "@/utils/openWebsite"
 import {showYakitModal} from "../yakitUI/YakitModal/YakitModalConfirm"
-import {grpcFetchLocalYakVersion} from "@/apiUtils/grpc"
+import {grpcFetchBuildInYakVersion, grpcFetchLocalYakVersion, grpcFetchSpecifiedYakVersionHash} from "@/apiUtils/grpc"
 
 const {ipcRenderer} = window.require("electron")
 
@@ -270,12 +270,12 @@ export const GlobalState: React.FC<GlobalReverseStateProp> = React.memo((props)
                 })
         })
     }
-    const timeout = (ms: number) =>
-        new Promise((_, reject) => setTimeout(() => reject(new Error("Check engine source request timed out")), ms))
     const checkEngineSource = async (localYaklang: string, resolve, reject) => {
         try {
             const [res1, res2] = await Promise.all([
-                Promise.race([ipcRenderer.invoke("fetch-check-yaklang-source", localYaklang), timeout(3000)]),
+                // 远端
+                grpcFetchSpecifiedYakVersionHash({version: localYaklang, config: {timeout: 3000}}, true),
+                // 本地
                 ipcRenderer.invoke("CalcEngineSha265")
             ])
             if (res1 === res2) {
@@ -291,7 +291,7 @@ export const GlobalState: React.FC<GlobalReverseStateProp> = React.memo((props)
     }
     const onUseOfficialEngine = async () => {
         try {
-            const res = await ipcRenderer.invoke("GetBuildInEngineVersion")
+            const res = await grpcFetchBuildInYakVersion(true)
             if (res !== "") {
                 emiter.emit("useOfficialEngineByDownloadByBuiltIn")
             } else {
diff --git a/app/renderer/src/main/src/components/layout/HelpDoc/HelpDoc.tsx b/app/renderer/src/main/src/components/layout/HelpDoc/HelpDoc.tsx
index a548c2c013..fffe709098 100644
--- a/app/renderer/src/main/src/components/layout/HelpDoc/HelpDoc.tsx
+++ b/app/renderer/src/main/src/components/layout/HelpDoc/HelpDoc.tsx
@@ -7,6 +7,7 @@ import {useMemoizedFn} from "ahooks"
 import {OutlineQuestionmarkcircleIcon} from "@/assets/icon/outline"
 import {grpcFetchLocalYakitVersion, grpcFetchLocalYakVersion} from "@/apiUtils/grpc"
 import {WebsiteGV} from "@/enums/website"
+import {SystemInfo} from "@/constants/hardware"
 
 import classNames from "classnames"
 import styles from "./HelpDoc.module.scss"
@@ -15,13 +16,12 @@ const {ipcRenderer} = window.require("electron")
 
 interface HelpDocProps {
     system: YakitSystem
-    arch: string
     engineLink: boolean
 }
 
 /** @name Yakit软件更新下载弹窗 */
 export const HelpDoc: React.FC<HelpDocProps> = React.memo((props) => {
-    const {system, arch, engineLink} = props
+    const {system, engineLink} = props
 
     const [currentYakit, setCurrentYakit] = useState<string>("")
     const [currentYaklang, setCurrentYaklang] = useState<string>("")
@@ -29,12 +29,12 @@ export const HelpDoc: React.FC<HelpDocProps> = React.memo((props) => {
     const info = useMemo(() => {
         const info: LocalInfoProps = {
             system: system,
-            arch: arch,
+            arch: SystemInfo.architecture || "",
             localYakit: currentYakit,
             localYaklang: currentYaklang
         }
         return info
-    }, [system, arch, currentYakit, currentYaklang])
+    }, [system, currentYakit, currentYaklang])
 
     useEffect(() => {
         grpcFetchLocalYakitVersion(true)
diff --git a/app/renderer/src/main/src/components/layout/LocalEngine/LocalEngine.tsx b/app/renderer/src/main/src/components/layout/LocalEngine/LocalEngine.tsx
index b4f7da30db..0d65e1e042 100644
--- a/app/renderer/src/main/src/components/layout/LocalEngine/LocalEngine.tsx
+++ b/app/renderer/src/main/src/components/layout/LocalEngine/LocalEngine.tsx
@@ -1,22 +1,21 @@
-import React, {forwardRef, memo, useEffect, useImperativeHandle, useMemo, useRef, useState} from "react"
+import React, {forwardRef, memo, useEffect, useImperativeHandle, useRef, useState} from "react"
 import {LocalEngineProps} from "./LocalEngineType"
 import {LocalGVS} from "@/enums/localGlobal"
 import {getLocalValue} from "@/utils/kv"
 import {useMemoizedFn} from "ahooks"
 import {getRandomLocalEnginePort} from "../WelcomeConsoleUtil"
 import {isEnpriTraceAgent} from "@/utils/envfile"
-import {failed, info, yakitNotify} from "@/utils/notification"
+import {failed, info} from "@/utils/notification"
 import {YakitHint} from "@/components/yakitUI/YakitHint/YakitHint"
-import {UpdateYakitAndYaklang} from "../update/UpdateYakitAndYaklang"
-import {showYakitModal} from "@/components/yakitUI/YakitModal/YakitModalConfirm"
-import {YakitButton} from "@/components/yakitUI/YakitButton/YakitButton"
+import {UpdateYakHint, UpdateYakitHint} from "../update/UpdateYakitAndYaklang"
 import emiter from "@/utils/eventBus/eventBus"
-import {handleFetchIsDev, SystemInfo} from "@/constants/hardware"
+import {SystemInfo} from "@/constants/hardware"
 import {
+    grpcFetchBuildInYakVersion,
     grpcFetchLatestYakitVersion,
-    grpcFetchLatestYakVersion,
     grpcFetchLocalYakitVersion,
-    grpcFetchLocalYakVersion
+    grpcFetchLocalYakVersion,
+    grpcFetchSpecifiedYakVersionHash
 } from "@/apiUtils/grpc"
 
 const {ipcRenderer} = window.require("electron")
@@ -25,301 +24,260 @@ export const LocalEngine: React.FC<LocalEngineProps> = memo(
     forwardRef((props, ref) => {
         const {system, setLog, onLinkEngine, setYakitStatus, checkEngineDownloadLatestVersion} = props
 
-        const isDevRef = useRef<boolean | undefined>(SystemInfo.isDev)
-        useEffect(() => {
-            if (isDevRef.current === undefined) {
-                handleFetchIsDev(() => (isDevRef.current = SystemInfo.isDev))
-            }
-        }, [])
-
-        const [localPort, setLocalPort] = useState<number>(0)
-
-        const [currentYakit, setCurrentYakit] = useState<string>("")
-        const [latestYakit, setLatestYakit] = useState<string>("")
-        const [currentYaklang, setCurrentYaklang] = useState<string>("")
-        const [latestYaklang, setLatestYaklang] = useState<string>("")
-        const [moreYaklangVersionList, setMoreYaklangVersionList] = useState<string[]>([]) // 更多引擎版本list
-
         /**
          * 只在软件打开时|引擎从无到有时执行该逻辑
          * 检查本地数据库权限
          */
         const handleCheckDataBase = useMemoizedFn(() => {
-            const firstHint = "开始检查数据库权限是否正常"
-            setLog([firstHint])
+            setLog(["检查数据库权限是否正常(非WIN系统检查)..."])
             let isError: boolean = false
             ipcRenderer
                 .invoke("check-local-database")
                 .then((e) => {
                     isError = e === "not allow to write" && system !== "Windows_NT"
                     if (isError) {
-                        setLog([firstHint, "数据库权限错误，开始进行调整操作(非WIN系统检查)"])
+                        setLog((old) => old.concat(["数据库权限错误，开始进行修复操作(非WIN系统检查)"]))
                         setDatabaseErrorVisible(true)
                     } else {
-                        setLog([firstHint, "数据库权限无问题"])
+                        setLog((old) => old.concat(["数据库权限无问题"]))
                         handleLinkEnginePort(true)
                     }
                 })
                 .catch((e) => {
-                    setLog([firstHint, `检查出错: ${e}`])
+                    setLog((old) => old.concat([`检查出错: ${e}`]))
                     handleLinkEnginePort(true)
                 })
         })
 
+        // 本地引擎连接端口
+        const localPort = useRef<number>(0)
         /** 获取上次本地连接引擎的端口缓存 */
         const handleLinkEnginePort = useMemoizedFn((isInit: boolean) => {
             getLocalValue(LocalGVS.YaklangEnginePort)
                 .then((portRaw) => {
-                    const port = parseInt(portRaw)
+                    const port = Number(portRaw) || 0
                     if (!port) {
                         getRandomLocalEnginePort((p) => {
+                            localPort.current = p
                             if (isInit) {
-                                onFetchLocalAndLatsVersion()
+                                handlePreCheckForLinkEngine()
                             } else {
-                                handleFetchYakitAndYaklangLocalVersion(() => {}, false)
+                                handleFetchYakLocalVersionToLink()
                             }
-                            setLocalPort(p)
                         })
                     } else {
+                        localPort.current = port
                         if (isInit) {
-                            onFetchLocalAndLatsVersion()
+                            handlePreCheckForLinkEngine()
                         } else {
-                            handleFetchYakitAndYaklangLocalVersion(() => {}, false)
+                            handleFetchYakLocalVersionToLink()
                         }
-                        setLocalPort(port)
                     }
                 })
                 .catch(() => {
                     getRandomLocalEnginePort((p) => {
+                        localPort.current = p
                         if (isInit) {
-                            onFetchLocalAndLatsVersion()
+                            handlePreCheckForLinkEngine()
                         } else {
-                            handleFetchYakitAndYaklangLocalVersion(() => {}, false)
+                            handleFetchYakLocalVersionToLink()
                         }
-                        setLocalPort(p)
                     })
                 })
         })
 
-        const onFetchLocalAndLatsVersion = useMemoizedFn(() => {
-            setTimeout(() => {
-                // 开发环境不做版本检测和 hash 检测
-                handleFetchYakitAndYaklangLocalVersion(
-                    isDevRef.current ? undefined : handleFetchYakitAndYaklangLatestVersion,
-                    !isDevRef.current
-                )
-            }, 500)
+        /**
+         * @name 初始化启动-连接引擎的前置版本检查
+         * - 开发环境直接连接引擎，不检查版本
+         * - 先进行 yakit 检查，在进行引擎检查
+         */
+        const handlePreCheckForLinkEngine = useMemoizedFn(() => {
+            if (!isEnpriTraceAgent()) setLog(["检查软件是否有更新..."])
+            else setLog([])
+
+            if (SystemInfo.isDev) {
+                setLog((old) => old.concat(["开发环境，直接连接引擎"]))
+                setTimeout(() => {
+                    handleLinkLocalEnging()
+                }, 500)
+            } else {
+                handleCheckYakitLatestVersion()
+            }
         })
 
-        /** 是否阻止更新弹窗出现 */
-        const preventUpdateHint = useRef<boolean>(false)
-        /** 是否已弹出更新框 */
-        const isShowedUpdateHint = useRef<boolean>(false)
-        /** 校验引擎来源 主要作用是是否直接连引擎（校验弹窗的出现和这个变量的值不一定是一致的） */
-        const checkEngineSourcePreventLinkLocalEnging = useRef<boolean>(false)
+        /**
+         * @name 检查yakit是否有版本更新
+         * - SE 版本不进行 yakit 更新检查，直接检查引擎和内置的版本
+         * - 未开启 yakit 更新检查，不进行 yakit 更新检查，直接检查引擎和内置的版本
+         */
+        const handleCheckYakitLatestVersion = useMemoizedFn(() => {
+            if (isEnpriTraceAgent()) {
+                handleCheckEngineVersion()
+                return
+            }
 
-        // 2秒判断是否有更新 - 校验弹窗出现，没有则进入连接引擎
-        const timingLinkLocalEnging = () => {
-            setTimeout(() => {
-                if (checkEngineSourcePreventLinkLocalEnging.current) return
-                if (isShowedUpdateHint.current) return
-                preventUpdateHint.current = true
-                handleLinkLocalEnging()
-            }, 2000)
-        }
+            let showUpdateYakit = false
+            getLocalValue(LocalGVS.NoAutobootLatestVersionCheck)
+                .then(async (val: boolean) => {
+                    if (!val) {
+                        try {
+                            const [res1, res2] = await Promise.allSettled([
+                                grpcFetchLocalYakitVersion(true),
+                                grpcFetchLatestYakitVersion({timeout: 2000}, true)
+                            ])
+                            if (res1.status === "fulfilled") {
+                                currentYakit.current = res1.value || ""
+                            }
+                            if (res2.status === "fulfilled") {
+                                let latest = res2.value || ""
+                                latestYakit.current = latest.startsWith("v") ? latest.substring(1) : latest
+                            }
+                            // 只要与线上的不一样就算需要更新，不需要进行版本号比较
+                            showUpdateYakit =
+                                !!currentYakit.current &&
+                                !!latestYakit.current &&
+                                currentYakit.current !== latestYakit.current
+                        } catch (error) {}
+                    } else {
+                        setLog((old) => old.concat(["跳过检查(可在软件更新处设置启动)，开始检查引擎是否有更新..."]))
+                    }
+                })
+                .catch(() => {})
+                .finally(() => {
+                    if (showUpdateYakit) {
+                        setLog((old) => old.concat(["软件存在新版本, 启动更新弹框..."]))
+                        setShowYakit(true)
+                    } else {
+                        setLog((old) => old.concat(["软件无更新"]))
+                        setTimeout(() => {
+                            handleCheckEngineVersion()
+                        }, 500)
+                    }
+                })
+        })
 
-        const handleFetchYakitAndYaklangLocalVersion = useMemoizedFn(
-            async (callback?: () => any, checkEngine?: boolean) => {
-                try {
-                    let localYakit = (await grpcFetchLocalYakitVersion(true)) || ""
-                    setCurrentYakit(localYakit)
-                } catch (error) {}
+        /**
+         * @name 检查引擎本地版本和内置版本
+         * - 无内置版本则直接连接引擎
+         * - 内置比本地版本高提示是否更新
+         */
+        const handleCheckEngineVersion = useMemoizedFn(async () => {
+            setLog(["获取引擎版本号并检查更新..."])
+            try {
+                const [res1, res2] = await Promise.allSettled([
+                    // 本地
+                    grpcFetchLocalYakVersion(true),
+                    // 内置
+                    grpcFetchBuildInYakVersion(true)
+                ])
+                if (res2.status === "fulfilled") {
+                    let buildIn = res2.value || ""
+                    buildInYak.current = buildIn.startsWith("v") ? buildIn.substring(1) : buildIn
+                }
+                if (res1.status === "fulfilled") {
+                    currentYak.current = res1.value || ""
+                    setLog((old) =>
+                        old.concat([
+                            currentYak.current ? `本地引擎版本——${currentYak.current}` : "未获取到本地引擎版本号"
+                        ])
+                    )
 
-                try {
-                    setLog(["获取引擎版本号..."])
-                    let localYaklang = (await grpcFetchLocalYakVersion(true)) || ""
-                    localYaklang = localYaklang.startsWith("v") ? localYaklang.slice(1) : localYaklang
-                    setLog(["获取引擎版本号...", `引擎版本号——${localYaklang}`, "准备开始本地连接中"])
-                    setCurrentYaklang(localYaklang)
-                    if (checkEngine) {
-                        await checkEngineSource(localYaklang)
+                    if (!!currentYak.current && !!buildInYak.current && buildInYak.current > currentYak.current) {
+                        setLog((old) => old.concat(["检测到引擎有更新，打开更新弹框"]))
+                        setShowYak(true)
                     } else {
-                        if (callback) callback()
+                        setLog((old) => old.concat(["引擎无更新"]))
+                        handleCheckEngineSource(currentYak.current)
                     }
-                    timingLinkLocalEnging()
-                } catch (error) {
-                    setLog(["获取引擎版本号...", `错误: ${error}`])
+                } else {
+                    setLog((old) => old.concat([`错误: ${res1.reason}`]))
                     setYakitStatus("checkError")
-                    if (callback) callback()
                 }
+            } catch (error) {
+                setLog((old) => old.concat([`错误: ${error}`]))
+                setYakitStatus("checkError")
             }
-        )
+        })
 
-        // 校验引擎是否来源正确
-        const [versionAbnormalVisible, setVersionAbnormalVisible] = useState<boolean>(false)
-        const [versionAbnormalLoading, setVersionAbnormalLoading] = useState<boolean>(false)
-        const timeout = (ms: number) =>
-            new Promise((_, reject) => setTimeout(() => reject(new Error("Check engine source request timed out")), ms))
-        const checkEngineSource = async (localYaklang: string) => {
+        /**
+         * @name 校验引擎是否来源正确
+         * - 通过相同版本的线上hash和本地hash对比，判断是否一样
+         */
+        const handleCheckEngineSource = useMemoizedFn(async (version: string) => {
+            setLog(["开始校验引擎来源..."])
             try {
-                setLog([`本地引擎版本${localYaklang}，校验引擎正确性中`])
                 const [res1, res2] = await Promise.all([
-                    Promise.race([ipcRenderer.invoke("fetch-check-yaklang-source", localYaklang), timeout(3000)]),
+                    // 远端
+                    grpcFetchSpecifiedYakVersionHash({version: version, config: {timeout: 2000}}, true),
+                    // 本地
                     ipcRenderer.invoke("CalcEngineSha265")
                 ])
-                // 校验结果值判断比较
+
                 if (res1 === res2) {
-                    setLog(["引擎来源正确"])
-                    handleFetchYakitAndYaklangLatestVersion()
+                    setLog((old) => old.concat(["引擎来源正确，准备连接引擎"]))
+                    handleLinkLocalEnging()
                 } else {
-                    checkEngineSourcePreventLinkLocalEnging.current = true
+                    setLog((old) => old.concat(["引擎非官方来源，启动提示框"]))
                     setVersionAbnormalVisible(true)
                 }
             } catch (error) {
-                setLog(["引擎校验已结束"])
-                handleFetchYakitAndYaklangLatestVersion()
+                setLog((old) => old.concat(["异常情况，无法检测来源，准备连接引擎"]))
+                handleLinkLocalEnging()
             }
-        }
-
-        const onUseCurrentEngine = () => {
-            setLog(["引擎校验已结束"])
-            setVersionAbnormalVisible(false)
-            checkEngineSourcePreventLinkLocalEnging.current = false
-            handleFetchYakitAndYaklangLatestVersion()
-            timingLinkLocalEnging()
-        }
+        })
 
-        const onUseOfficialEngine = async () => {
+        /**
+         * @name 获取本地引擎版本，并连接引擎
+         */
+        const handleFetchYakLocalVersionToLink = useMemoizedFn(async () => {
             try {
-                const res = await ipcRenderer.invoke("GetBuildInEngineVersion")
-                if (res !== "") {
-                    initBuildInEngine()
-                } else {
-                    installEngine()
-                }
+                setLog(["获取引擎版本号..."])
+                let localYaklang = (await grpcFetchLocalYakVersion(true)) || ""
+                localYaklang = localYaklang.startsWith("v") ? localYaklang.slice(1) : localYaklang
+                setLog((old) => old.concat([`引擎版本号——${localYaklang}`, "准备开始本地连接中"]))
+                currentYak.current = localYaklang
+                setTimeout(() => {
+                    handleLinkLocalEnging()
+                }, 1000)
             } catch (error) {
-                installEngine()
+                setLog((old) => old.concat([`错误: ${error}`]))
+                setYakitStatus("checkError")
             }
-        }
-
-        const initBuildInEngine = () => {
-            setVersionAbnormalLoading(true)
-            ipcRenderer
-                .invoke("InitBuildInEngine", {})
-                .then(() => {
-                    yakitNotify("info", "解压内置引擎成功")
-                    setVersionAbnormalVisible(false)
-                    showYakitModal({
-                        closable: false,
-                        maskClosable: false,
-                        keyboard: false,
-                        type: "white",
-                        title: "引擎解压成功，需要重启",
-                        content: (
-                            <div style={{height: 80, padding: 24, display: "flex", alignItems: "center"}}>
-                                <YakitButton
-                                    onClick={() => {
-                                        ipcRenderer
-                                            .invoke("relaunch")
-                                            .then(() => {})
-                                            .catch((e) => {
-                                                failed(`重启失败: ${e}`)
-                                            })
-                                    }}
-                                >
-                                    点此立即重启
-                                </YakitButton>
-                            </div>
-                        ),
-                        footer: null
-                    })
-                })
-                .catch((e) => {
-                    yakitNotify("error", `初始化内置引擎失败：${e}`)
-                })
-                .finally(() => setTimeout(() => setVersionAbnormalLoading(false), 300))
-        }
+        })
 
-        useEffect(() => {
-            emiter.on("execLocalEngineInitBuildInEngine", initBuildInEngine)
-            return () => {
-                emiter.off("execLocalEngineInitBuildInEngine", initBuildInEngine)
-            }
-        }, [])
+        /** 开始进行本地引擎连接 */
+        const handleLinkLocalEnging = useMemoizedFn(() => {
+            // 开始连接本地引擎
+            onLinkEngine(localPort.current)
+            // 启动本地连接后，重置所有检查状态，并后续不会在进行检查
+            handleResetAllStatus()
+        })
 
-        // 下载最新引擎并安装
-        const installEngine = () => {
+        /** 初始化所有引擎连接前检查状态 */
+        const handleResetAllStatus = useMemoizedFn(() => {
+            // 数据库权限
+            setDatabaseErrorLoading(false)
+            setDatabaseErrorVisible(false)
+            // yakit更新
+            currentYakit.current = ""
+            latestYakit.current = ""
+            setShowYakit(false)
+            // yak更新
+            currentYak.current = ""
+            buildInYak.current = ""
+            setShowYak(false)
+            // 引擎来源验证
+            setVersionAbnormalLoading(false)
             setVersionAbnormalVisible(false)
-            checkEngineDownloadLatestVersion()
-        }
-
-        const checkEngineDownloadLatestVersionCancel = () => {
-            checkEngineSourcePreventLinkLocalEnging.current = true
-            setVersionAbnormalVisible(true)
-        }
-        useEffect(() => {
-            emiter.on("checkEngineDownloadLatestVersionCancel", checkEngineDownloadLatestVersionCancel)
-            return () => {
-                emiter.off("checkEngineDownloadLatestVersionCancel", checkEngineDownloadLatestVersionCancel)
-            }
-        }, [])
-
-        const handleFetchYakitAndYaklangLatestVersion = useMemoizedFn(() => {
-            if (isEnpriTraceAgent()) {
-                // SE版本不检查更新
-                preventUpdateHint.current = true
-                return
-            }
-            getLocalValue(LocalGVS.NoAutobootLatestVersionCheck).then((val: boolean) => {
-                if (val) preventUpdateHint.current = true
-
-                if (!val) {
-                    grpcFetchLatestYakitVersion(true)
-                        .then((data) => {
-                            if (preventUpdateHint.current) return
-                            setLatestYakit(data || "")
-                        })
-                        .catch((err) => {})
-                    grpcFetchLatestYakVersion(true)
-                        .then((data: string) => {
-                            if (preventUpdateHint.current) return
-                            setLatestYaklang(data)
-                        })
-                        .catch((err) => {})
-
-                    ipcRenderer
-                        .invoke("fetch-yaklang-version-list")
-                        .then((data: string) => {
-                            if (preventUpdateHint.current) return
-                            const arr = data.split("\n").filter((v) => v)
-                            let devPrefix: string[] = []
-                            let noPrefix: string[] = []
-                            arr.forEach((item) => {
-                                if (item.startsWith("dev")) {
-                                    devPrefix.push(item)
-                                } else {
-                                    noPrefix.push(item)
-                                }
-                            })
-                            setMoreYaklangVersionList(noPrefix.concat(devPrefix))
-                        })
-                        .catch((err) => {})
-                }
-            })
         })
 
-        // 初始化后的本地连接-前置项检查
+        /** ---------- 暴露的外部调用方法 Start ---------- */
+        // 启动 yakit 后的连接引擎
         const initLink = useMemoizedFn(() => {
-            isShowedUpdateHint.current = false
-            preventUpdateHint.current = !isEnpriTraceAgent() ? false : true
-            checkEngineSourcePreventLinkLocalEnging.current = false
             handleCheckDataBase()
         })
-        // 检查版本后直接连接
+        // 切换引擎后的连接引擎
         const toLink = useMemoizedFn(() => {
-            isShowedUpdateHint.current = false
-            preventUpdateHint.current = true
-            checkEngineSourcePreventLinkLocalEnging.current = false
             handleLinkEnginePort(false)
         })
 
@@ -331,51 +289,18 @@ export const LocalEngine: React.FC<LocalEngineProps> = memo(
             }),
             []
         )
+        /** ---------- 暴露的外部调用方法 End ---------- */
 
-        // 开始进行本地引擎连接
-        const handleLinkLocalEnging = useMemoizedFn(() => {
-            // 开始连接本地引擎
-            onLinkEngine(localPort)
-            // 一旦启动本地连接了，后续就不用再检查更新情况了
-            setLatestYakit("")
-            setLatestYaklang("")
-            setMoreYaklangVersionList([])
-        })
-
-        /** ---------- 软件自启的更新检测弹框 Start ---------- */
-        const isShowUpdate = useMemo(() => {
-            if (isEnpriTraceAgent()) return false
-            if (!!currentYakit && !!latestYakit && `v${currentYakit}` !== latestYakit) {
-                isShowedUpdateHint.current = true
-                return true
-            }
-
-            const lowerYaklangLastVersion =
-                moreYaklangVersionList.indexOf(currentYaklang) === -1 ||
-                moreYaklangVersionList.indexOf(currentYaklang) > moreYaklangVersionList.indexOf(latestYaklang)
-            if (!!currentYaklang && !!latestYaklang && moreYaklangVersionList.length && lowerYaklangLastVersion) {
-                isShowedUpdateHint.current = true
-                return true
-            }
-
-            return false
-        }, [currentYakit, latestYakit, currentYaklang, moreYaklangVersionList, latestYaklang])
-
-        const onCancelUpdateHint = useMemoizedFn(() => {
-            preventUpdateHint.current = true
-            handleLinkLocalEnging()
-        })
-        /** ---------- 软件自启的更新检测弹框 End ---------- */
-
-        /** ---------- 数据库权限逻辑 Start ---------- */
+        /** ---------- 数据库权限修复逻辑 Start ---------- */
         const [databaseErrorVisible, setDatabaseErrorVisible] = useState<boolean>(false)
         const [databaseErrorLoading, setDatabaseErrorLoading] = useState<boolean>(false)
         const onFixDatabaseError = useMemoizedFn(() => {
+            if (databaseErrorLoading) return
             setDatabaseErrorLoading(true)
             ipcRenderer
                 .invoke("fix-local-database")
                 .then((e) => {
-                    info("修复成功")
+                    info("修复数据库权限成功")
                 })
                 .catch((e) => {
                     failed(`修复数据库权限错误：${e}`)
@@ -388,22 +313,86 @@ export const LocalEngine: React.FC<LocalEngineProps> = memo(
                     }, 300)
                 })
         })
-        /** ---------- 数据库权限逻辑 End ---------- */
+        /** ---------- 数据库权限修复逻辑 End ---------- */
+
+        /** ---------- Yakit更新弹框 Start ---------- */
+        // 本地 yakit 版本
+        const currentYakit = useRef<string>("")
+        // 最新 yakit 版本
+        const latestYakit = useRef<string>("")
+        const [showYakit, setShowYakit] = useState<boolean>(false)
+        const onCancelUpdateYakit = useMemoizedFn(() => {
+            setShowYakit(false)
+            handleCheckEngineVersion()
+        })
+        /** ---------- Yakit更新弹框 End ---------- */
+
+        /** ---------- 引擎更新弹框 Start ---------- */
+        // 本地引擎版本
+        const currentYak = useRef<string>("")
+        // 内置引擎版本
+        const buildInYak = useRef<string>("")
+        const [showYak, setShowYak] = useState<boolean>(false)
+        const onCancelUpdateYak = useMemoizedFn((result: boolean) => {
+            setShowYak(false)
+            if (currentYak.current) {
+                handleCheckEngineSource(result ? buildInYak.current : currentYak.current)
+            } else {
+                setLog((old) => old.concat(["未获取到引擎版本号，请重试!"]))
+                setYakitStatus("checkError")
+            }
+        })
+        /** ---------- 引擎更新弹框 End ---------- */
+
+        /** ---------- 引擎非官方版本提示 Start ---------- */
+        const [versionAbnormalVisible, setVersionAbnormalVisible] = useState<boolean>(false)
+        const [versionAbnormalLoading, setVersionAbnormalLoading] = useState<boolean>(false)
+
+        const handleCancelVersionAbnormal = useMemoizedFn(() => {
+            setVersionAbnormalVisible(false)
+            setVersionAbnormalLoading(false)
+            setLog((old) => old.concat(["主动跳过，准备连接引擎"]))
+            handleLinkLocalEnging()
+        })
+        const handleOKVersionAbnormal = useMemoizedFn(() => {
+            if (versionAbnormalLoading) return
+
+            setVersionAbnormalLoading(true)
+            if (buildInYak.current) {
+                ipcRenderer
+                    .invoke("InitBuildInEngine", {})
+                    .then(() => {
+                        info(`解压内置引擎成功`)
+                        setVersionAbnormalVisible(false)
+                        setLog((old) => old.concat(["解压完成, 准备连接引擎"]))
+                        handleLinkLocalEnging()
+                    })
+                    .catch((e) => {
+                        failed(`初始化内置引擎失败：${e}`)
+                    })
+                    .finally(() => setTimeout(() => setVersionAbnormalLoading(false), 300))
+            } else {
+                setLog(["无内置引擎包，开始寻找本地引擎包源..."])
+                setVersionAbnormalVisible(false)
+                setVersionAbnormalLoading(false)
+                checkEngineDownloadLatestVersion()
+            }
+        })
+
+        const handleDownloadErrorOffceEngine = useMemoizedFn(() => {
+            setVersionAbnormalVisible(true)
+        })
+        useEffect(() => {
+            emiter.on("checkEngineDownloadLatestVersionCancel", handleDownloadErrorOffceEngine)
+            return () => {
+                emiter.off("checkEngineDownloadLatestVersionCancel", handleDownloadErrorOffceEngine)
+            }
+        }, [])
+        /** ---------- 引擎非官方版本提示 End ---------- */
 
         return (
             <>
-                {!isEnpriTraceAgent() && isShowUpdate && (
-                    <UpdateYakitAndYaklang
-                        currentYakit={currentYakit}
-                        latestYakit={latestYakit}
-                        setLatestYakit={setLatestYakit}
-                        currentYaklang={currentYaklang}
-                        latestYaklang={latestYaklang}
-                        setLatestYaklang={setLatestYaklang}
-                        isShow={isShowUpdate}
-                        onCancel={onCancelUpdateHint}
-                    />
-                )}
+                {/* MAC 系统下数据库权限问题修复弹框 */}
                 {databaseErrorVisible && (
                     <YakitHint
                         getContainer={document.getElementById("yakit-uilayout-body") || undefined}
@@ -418,6 +407,26 @@ export const LocalEngine: React.FC<LocalEngineProps> = memo(
                         onOk={onFixDatabaseError}
                     />
                 )}
+
+                {/* Yakit 更新弹窗 */}
+                {!isEnpriTraceAgent() && (
+                    <UpdateYakitHint
+                        current={currentYakit.current}
+                        latest={latestYakit.current}
+                        visible={showYakit}
+                        onCallback={onCancelUpdateYakit}
+                    />
+                )}
+
+                {/* 引擎更新为内置版本 */}
+                <UpdateYakHint
+                    current={currentYak.current}
+                    buildIn={buildInYak.current}
+                    visible={showYak}
+                    onCallback={onCancelUpdateYak}
+                />
+
+                {/* 引擎非官方版本提示 */}
                 {versionAbnormalVisible && (
                     <YakitHint
                         getContainer={document.getElementById("yakit-uilayout-body") || undefined}
@@ -430,8 +439,8 @@ export const LocalEngine: React.FC<LocalEngineProps> = memo(
                         cancelButtonText='使用当前引擎'
                         okButtonProps={{loading: versionAbnormalLoading}}
                         cancelButtonProps={{loading: versionAbnormalLoading}}
-                        onOk={onUseOfficialEngine}
-                        onCancel={onUseCurrentEngine}
+                        onOk={handleOKVersionAbnormal}
+                        onCancel={handleCancelVersionAbnormal}
                     />
                 )}
             </>
diff --git a/app/renderer/src/main/src/components/layout/LocalEngine/LocalEngineType.d.ts b/app/renderer/src/main/src/components/layout/LocalEngine/LocalEngineType.d.ts
index f33a3d106f..32b2ada63f 100644
--- a/app/renderer/src/main/src/components/layout/LocalEngine/LocalEngineType.d.ts
+++ b/app/renderer/src/main/src/components/layout/LocalEngine/LocalEngineType.d.ts
@@ -1,10 +1,10 @@
-import React from "react"
+import React, {Dispatch, SetStateAction} from "react"
 import {YakitSystem} from "@/yakitGVDefine"
 
 export interface LocalEngineProps {
     ref?: React.ForwardedRef<LocalEngineLinkFuncProps>
     system: YakitSystem
-    setLog: (log: string[]) => any
+    setLog: Dispatch<SetStateAction<string[]>>
     onLinkEngine: (port: number) => any
     setYakitStatus: (v: YakitStatusType) => any
     checkEngineDownloadLatestVersion: () => any
diff --git a/app/renderer/src/main/src/components/layout/UILayout.tsx b/app/renderer/src/main/src/components/layout/UILayout.tsx
index e2ed9b318e..1304d73242 100644
--- a/app/renderer/src/main/src/components/layout/UILayout.tsx
+++ b/app/renderer/src/main/src/components/layout/UILayout.tsx
@@ -61,9 +61,6 @@ import {ChatCSGV} from "@/enums/chatCS"
 import {CheckEngineVersion} from "./CheckEngineVersion/CheckEngineVersion"
 import {EngineRemoteGV} from "@/enums/engine"
 import {outputToPrintLog} from "./WelcomeConsoleUtil"
-
-import classNames from "classnames"
-import styles from "./uiLayout.module.scss"
 import {setNowProjectDescription} from "@/pages/globalVariable"
 import {apiGetGlobalNetworkConfig, apiSetGlobalNetworkConfig} from "@/pages/spaceEngine/utils"
 import {GlobalNetworkConfig} from "../configNetwork/ConfigNetworkPage"
@@ -78,11 +75,16 @@ import {CopyComponents} from "../yakitUI/YakitTag/YakitTag"
 import {Tooltip} from "antd"
 import {openABSFileLocated} from "@/utils/openWebsite"
 import {clearTerminalMap, getMapAllTerminalKey} from "@/pages/yakRunner/BottomEditorDetails/TerminalBox/TerminalMap"
-import {grpcFetchLatestYakVersion, grpcFetchYakInstallResult} from "@/apiUtils/grpc"
+import {grpcFetchBuildInYakVersion, grpcFetchLatestYakVersion, grpcFetchYakInstallResult} from "@/apiUtils/grpc"
 import {NetWorkApi} from "@/services/fetch"
 import {API} from "@/services/swagger/resposeType"
 import {visitorsStatisticsFun} from "@/utils/visitorsStatistics"
 import {setYakitEngineMode} from "@/constants/software"
+import useGetSetState from "@/pages/pluginHub/hooks/useGetSetState"
+import {handleFetchArchitecture, handleFetchIsDev, SystemInfo} from "@/constants/hardware"
+
+import classNames from "classnames"
+import styles from "./uiLayout.module.scss"
 
 const {ipcRenderer} = window.require("electron")
 
@@ -122,8 +124,6 @@ const UILayout: React.FC<UILayoutProp> = (props) => {
 
     /** ---------- 软件状态相关属性 Start ---------- */
     const [system, setSystem] = useState<YakitSystem>("Darwin")
-    const [arch, setArch] = useState<string>("x64")
-    const isDev = useRef<boolean>(false)
 
     /** 本地引擎自检输出日志 */
     const [checkLog, setCheckLog] = useState<string[]>(["软件启动中，开始前置检查..."])
@@ -132,12 +132,10 @@ const UILayout: React.FC<UILayoutProp> = (props) => {
     const isEngineInstalled = useRef<boolean>(false)
 
     /** 当前引擎模式 */
-    const [engineMode, setEngineMode] = useState<YaklangEngineMode>()
-    const cacheEngineMode = useRef<YaklangEngineMode>()
+    const [engineMode, setEngineMode, getEngineMode] = useGetSetState<YaklangEngineMode>()
     const onSetEngineMode = useMemoizedFn((v?: YaklangEngineMode) => {
         setYakitEngineMode(v)
         setEngineMode(v)
-        cacheEngineMode.current = v
     })
     /** 是否为远程模式 */
     const isRemoteEngine = useMemo(() => engineMode === "remote", [engineMode])
@@ -146,20 +144,10 @@ const UILayout: React.FC<UILayoutProp> = (props) => {
     const [credential, setCredential] = useState<YaklangEngineWatchDogCredential>({...DefaultCredential})
 
     /** yakit使用状态 */
-    const [yakitStatus, setYakitStatus] = useState<YakitStatusType>("")
-    const cacheYakitStatus = useRef<YakitStatusType>("")
-    const onSetYakitStatus = useMemoizedFn((v: YakitStatusType) => {
-        setYakitStatus(v)
-        cacheYakitStatus.current = v
-    })
+    const [yakitStatus, setYakitStatus, getYakitStatus] = useGetSetState<YakitStatusType>("")
 
     /** 当前引擎连接状态 */
-    const [engineLink, setEngineLink] = useState<boolean>(false)
-    const cacheEngineLink = useRef<boolean>(false)
-    const onSetEngineLink = useMemoizedFn((v: boolean) => {
-        setEngineLink(v)
-        cacheEngineLink.current = v
-    })
+    const [engineLink, setEngineLink, getEngineLink] = useGetSetState<boolean>(false)
 
     /** 是否为初次启动本地连接 */
     const isInitLocalLink = useRef<boolean>(true)
@@ -234,15 +222,14 @@ const UILayout: React.FC<UILayoutProp> = (props) => {
      */
     const handleFetchBaseInfo = useMemoizedFn(async (nextFunc?: () => any) => {
         try {
-            isDev.current = !!(await ipcRenderer.invoke("is-dev"))
+            if (SystemInfo.isDev === undefined) await handleFetchIsDev()
         } catch (error) {}
         try {
             const systemName: YakitSystem = await ipcRenderer.invoke("fetch-system-name")
             setSystem(systemName)
         } catch (error) {}
         try {
-            const cpuArch: string = await ipcRenderer.invoke("fetch-cpu-arch")
-            setArch(cpuArch)
+            if (SystemInfo.architecture === undefined) await handleFetchArchitecture()
         } catch (error) {}
         try {
             const isInstalled = await grpcFetchYakInstallResult(true)
@@ -283,13 +270,13 @@ const UILayout: React.FC<UILayoutProp> = (props) => {
     // 切换远程模式
     const handleLinkRemoteMode = useMemoizedFn(() => {
         onDisconnect()
-        onSetYakitStatus("")
+        setYakitStatus("")
         onSetEngineMode("remote")
     })
     // 本地连接的状态设置
     const setLinkLocalEngine = useMemoizedFn(() => {
         onDisconnect()
-        onSetYakitStatus("")
+        setYakitStatus("")
         onSetEngineMode("local")
         handleStartLocalLink(isInitLocalLink.current)
         isInitLocalLink.current = false
@@ -310,7 +297,7 @@ const UILayout: React.FC<UILayoutProp> = (props) => {
             setCheckLog(["检查本地是否已安装引擎..."])
             setCheckLog((arr) => arr.concat(["本地未安装引擎，准备启动安装引擎弹窗"]))
             setTimeout(() => {
-                onSetYakitStatus("install")
+                setYakitStatus("install")
                 onSetEngineMode(undefined)
             }, 1000)
         }
@@ -340,8 +327,8 @@ const UILayout: React.FC<UILayoutProp> = (props) => {
             /**
              * dev环境下，如果已连接本地引擎，则不需要再次连接
              */
-            if (isDev.current) {
-                if (cacheEngineLink.current && cacheEngineMode.current === "local") return
+            if (SystemInfo.isDev) {
+                if (getEngineLink() && getEngineMode() === "local") return
             }
 
             handleBuiltInCheck()
@@ -365,13 +352,13 @@ const UILayout: React.FC<UILayoutProp> = (props) => {
                     emiter.emit("checkEngineDownloadLatestVersionCancel")
                 } else {
                     // 引擎文件已经被删除了
-                    onSetYakitStatus("install")
+                    setYakitStatus("install")
                 }
             },
             () => {
                 // 走下载安装逻辑
                 setOnlyInstallLatestEngine(true)
-                onSetYakitStatus("install")
+                setYakitStatus("install")
             }
         )
     }
@@ -390,11 +377,11 @@ const UILayout: React.FC<UILayoutProp> = (props) => {
             if (props.linkSuccess) {
                 props.linkSuccess()
                 // 下面的三行为以前的老逻辑
-                onSetYakitStatus("link")
+                setYakitStatus("link")
                 setShowEngineLog(false)
             }
 
-            setLocalValue(LocalGV.YaklangEngineMode, cacheEngineMode.current)
+            setLocalValue(LocalGV.YaklangEngineMode, getEngineMode())
 
             const waitTime: number = 20000
             const id = setInterval(() => {
@@ -423,7 +410,7 @@ const UILayout: React.FC<UILayoutProp> = (props) => {
     const onDisconnect = useMemoizedFn(() => {
         setCredential({...DefaultCredential})
         setKeepalive(false)
-        onSetEngineLink(false)
+        setEngineLink(false)
     })
     // 开始连接引擎
     const onStartLinkEngine = useMemoizedFn((isDynamicControl?: boolean) => {
@@ -458,7 +445,7 @@ const UILayout: React.FC<UILayoutProp> = (props) => {
             Port: port,
             Mode: "local"
         })
-        onSetYakitStatus("ready")
+        setYakitStatus("ready")
         onStartLinkEngine()
         outputToPrintLog("local-start-test-engine-link-status")
     })
@@ -573,8 +560,8 @@ const UILayout: React.FC<UILayoutProp> = (props) => {
     const handleOperations = useMemoizedFn((type: YakitSettingCallbackType | YaklangEngineMode) => {
         switch (type) {
             case "break":
-                if (cacheYakitStatus.current === "link") {
-                    onSetYakitStatus("break")
+                if (getYakitStatus() === "link") {
+                    setYakitStatus("break")
                     setTimeout(() => {
                         setCheckLog(["已主动断开, 请点击手动连接引擎"])
                         onDisconnect()
@@ -680,7 +667,7 @@ const UILayout: React.FC<UILayoutProp> = (props) => {
     const killedEngineToUpdate = useMemoizedFn(() => {
         setYaklangKillPss(false)
         if (!yaklangDownload) {
-            onSetEngineLink(false)
+            setEngineLink(false)
             setKeepalive(false)
             if (!yaklangSpecifyVersion) {
                 setYaklangKillPssText({
@@ -702,7 +689,7 @@ const UILayout: React.FC<UILayoutProp> = (props) => {
                         setLinkLocalEngine()
                     } else {
                         // 引擎文件已经被删除了
-                        onSetYakitStatus("install")
+                        setYakitStatus("install")
                     }
                 },
                 () => {
@@ -744,13 +731,49 @@ const UILayout: React.FC<UILayoutProp> = (props) => {
             errCallback && errCallback()
         }
     }
+
+    const initBuildInEngine = () => {
+        ipcRenderer
+            .invoke("InitBuildInEngine", {})
+            .then(() => {
+                yakitNotify("info", "解压内置引擎成功")
+                showYakitModal({
+                    closable: false,
+                    maskClosable: false,
+                    keyboard: false,
+                    type: "white",
+                    title: "引擎解压成功，需要重启",
+                    content: (
+                        <div style={{height: 80, padding: 24, display: "flex", alignItems: "center"}}>
+                            <YakitButton
+                                onClick={() => {
+                                    ipcRenderer
+                                        .invoke("relaunch")
+                                        .then(() => {})
+                                        .catch((e) => {
+                                            failed(`重启失败: ${e}`)
+                                        })
+                                }}
+                            >
+                                点此立即重启
+                            </YakitButton>
+                        </div>
+                    ),
+                    footer: null
+                })
+            })
+            .catch((e) => {
+                yakitNotify("error", `初始化内置引擎失败：${e}`)
+            })
+    }
+
     // kill完引擎进程后解压内置引擎
     const killedEngineToBuildInEngine = useMemoizedFn(() => {
         setYaklangKillBuildInEngine(false)
         setYaklangKillPss(false)
-        onSetEngineLink(false)
+        setEngineLink(false)
         setKeepalive(false)
-        emiter.emit("execLocalEngineInitBuildInEngine")
+        initBuildInEngine()
     })
 
     // kill完引擎进程后开始更新指定Yaklang版本引擎
@@ -805,7 +828,7 @@ const UILayout: React.FC<UILayoutProp> = (props) => {
         let port: number = 0
         let pid: number = 0
 
-        if (cacheEngineLink.current) {
+        if (getEngineLink()) {
             setKillLoading(true)
 
             ipcRenderer
@@ -916,7 +939,7 @@ const UILayout: React.FC<UILayoutProp> = (props) => {
     }
 
     const showCheckVersion = useMemo(() => {
-        if (isDev.current) return false
+        if (SystemInfo.isDev) return false
         if (!builtInVersion) return false
         if (!currentVersion) return false
         return compareVersions(currentVersion, builtInVersion) === -1
@@ -941,11 +964,10 @@ const UILayout: React.FC<UILayoutProp> = (props) => {
                     if (!v || v === "false") {
                         if (builtInVersion === "") {
                             // 获取软件对应的内置版本
-                            ipcRenderer
-                                .invoke("fetch-built-in-engine-version")
+                            grpcFetchBuildInYakVersion(true)
                                 .then((v: string) => {
-                                    let version = v.replace(/\r?\n/g, "")
-                                    if (version.startsWith("v")) version = version.slice(1)
+                                    let version = v || ""
+                                    if (version.startsWith("v")) version = version.substring(1)
                                     setBuiltInVersion(version)
                                 })
                                 .catch(() => {})
@@ -1010,7 +1032,7 @@ const UILayout: React.FC<UILayoutProp> = (props) => {
             ipcRenderer
                 .invoke("Codec", {Type: "base64-decode", Text: resultObj.pubpem, Params: [], ScriptName: ""})
                 .then((res) => {
-                    onSetYakitStatus("control-remote")
+                    setYakitStatus("control-remote")
                     setCheckLog(["远程控制连接中..."])
                     onDisconnect()
 
@@ -1450,7 +1472,7 @@ const UILayout: React.FC<UILayoutProp> = (props) => {
     }, [screenRecorderInfo])
     /** ---------- 软件顶部展示录屏中状态 End ---------- */
     const SELinkedEngine = useMemoizedFn(() => {
-        onSetEngineLink(true)
+        setEngineLink(true)
     })
     const onLinkedEngine = useMemoizedFn(async () => {
         // EE & CE
@@ -1460,7 +1482,7 @@ const UILayout: React.FC<UILayoutProp> = (props) => {
                 setTemporaryProjectNoPromptFlag(flag === "true")
             }
             // INFO 开发环境默认每次进入项目都是默认项目 避免每次都进项目管理页面去选项目
-            if (isDev.current) {
+            if (SystemInfo.isDev) {
                 const res = await ipcRenderer.invoke("GetDefaultProject")
                 if (res) {
                     ipcRenderer.invoke("SetCurrentProject", {Id: +res.Id})
@@ -1477,7 +1499,7 @@ const UILayout: React.FC<UILayoutProp> = (props) => {
             yakitFailed(error + "")
         }
 
-        setTimeout(() => onSetEngineLink(true), 100)
+        setTimeout(() => setEngineLink(true), 100)
     })
 
     /**
@@ -1493,16 +1515,16 @@ const UILayout: React.FC<UILayoutProp> = (props) => {
     }, [])
 
     const onReady = useMemoizedFn(() => {
-        outputToPrintLog(`连接成功-start-engineLink:${cacheEngineLink.current}`)
-        if (!cacheEngineLink.current) {
+        outputToPrintLog(`连接成功-start-engineLink:${getEngineLink()}`)
+        if (!getEngineLink()) {
             isEnpriTraceAgent() ? SELinkedEngine() : onLinkedEngine()
         }
 
         setCheckLog([])
-        onSetYakitStatus("link")
+        setYakitStatus("link")
 
         // 连接成功，保存一下端口缓存
-        switch (cacheEngineMode.current) {
+        switch (getEngineMode()) {
             case "local":
                 if (dynamicStatus.isDynamicStatus) return
                 setLocalValue(LocalGV.YaklangEnginePort, credential.Port)
@@ -1517,27 +1539,27 @@ const UILayout: React.FC<UILayoutProp> = (props) => {
         }
         outputToPrintLog(`连接失败: ${count}次`)
 
-        onSetEngineLink(false)
+        setEngineLink(false)
 
-        if (dynamicStatus.isDynamicStatus && cacheYakitStatus.current !== "control-remote") {
+        if (dynamicStatus.isDynamicStatus && getYakitStatus() !== "control-remote") {
             setCheckLog(["远程控制重连中..."])
-            onSetYakitStatus("control-remote")
+            setYakitStatus("control-remote")
             return
         } else {
-            if (cacheYakitStatus.current === "control-remote") {
+            if (getYakitStatus() === "control-remote") {
                 if (count === 5) {
                     setCheckLog(["远程控制异常退出, 无法连接"])
                     failed("远程控制异常退出, 无法连接。")
                     setDynamicStatus({...dynamicStatus, isDynamicStatus: false})
                     remoteOperation(false, dynamicStatus, userInfo)
-                    onSetYakitStatus("control-remote-timeout")
+                    setYakitStatus("control-remote-timeout")
                     onDisconnect()
                 }
                 return
             }
         }
 
-        if (cacheYakitStatus.current === "error" && count === 20) {
+        if (getYakitStatus() === "error" && count === 20) {
             // 连接断开后的20次尝试过后，不在进行尝试
             setCheckLog((arr) => {
                 return arr.slice(1).concat(["连接超时, 请手动启动引擎"])
@@ -1545,17 +1567,17 @@ const UILayout: React.FC<UILayoutProp> = (props) => {
             return
         }
 
-        if (cacheYakitStatus.current === "link" || cacheYakitStatus.current === "ready") {
+        if (getYakitStatus() === "link" || getYakitStatus() === "ready") {
             // 连接中或正在连接中触发
-            if (cacheEngineMode.current === "remote") {
+            if (getEngineMode() === "remote") {
                 failed("远程连接已断开")
                 onDisconnect()
-                onSetYakitStatus("")
+                setYakitStatus("")
             }
-            if (cacheEngineMode.current === "local") {
-                if (cacheYakitStatus.current === "link") setCheckLog(["引擎连接超时, 正在尝试重连"])
+            if (getEngineMode() === "local") {
+                if (getYakitStatus() === "link") setCheckLog(["引擎连接超时, 正在尝试重连"])
                 if (count > 4) {
-                    onSetYakitStatus("error")
+                    setYakitStatus("error")
                 }
             }
         }
@@ -1565,7 +1587,7 @@ const UILayout: React.FC<UILayoutProp> = (props) => {
         switch (type) {
             case "control-remote-connect-failed":
                 setCheckLog(["远程控制异常退出, 无法连接"])
-                onSetYakitStatus("control-remote-timeout")
+                setYakitStatus("control-remote-timeout")
                 return
             case "remote-connect-failed":
                 setTimeout(() => {
@@ -1635,7 +1657,11 @@ const UILayout: React.FC<UILayoutProp> = (props) => {
                                     </div>
 
                                     <div className={styles["left-cpu"]}>
-                                        <PerformanceDisplay engineMode={engineMode} typeCallback={handleOperations} engineLink={engineLink} />
+                                        <PerformanceDisplay
+                                            engineMode={engineMode}
+                                            typeCallback={handleOperations}
+                                            engineLink={engineLink}
+                                        />
                                     </div>
                                 </div>
                                 <div
@@ -1649,7 +1675,7 @@ const UILayout: React.FC<UILayoutProp> = (props) => {
 
                                     {stopScreen}
 
-                                    <HelpDoc system={system} arch={arch} engineLink={engineLink} />
+                                    <HelpDoc system={system} engineLink={engineLink} />
 
                                     {engineLink && (
                                         <>
@@ -1725,7 +1751,7 @@ const UILayout: React.FC<UILayoutProp> = (props) => {
                                         </>
                                     )}
 
-                                    <HelpDoc system={system} arch={arch} engineLink={engineLink} />
+                                    <HelpDoc system={system} engineLink={engineLink} />
 
                                     {stopScreen}
 
@@ -1741,7 +1767,11 @@ const UILayout: React.FC<UILayoutProp> = (props) => {
 
                                 <div className={styles["header-right"]}>
                                     <div className={styles["left-cpu"]}>
-                                        <PerformanceDisplay engineMode={engineMode} typeCallback={handleOperations} engineLink={engineLink} />
+                                        <PerformanceDisplay
+                                            engineMode={engineMode}
+                                            typeCallback={handleOperations}
+                                            engineLink={engineLink}
+                                        />
                                     </div>
                                     <div className={styles["short-divider-wrapper"]}>
                                         <div className={styles["divider-style"]}></div>
@@ -1773,7 +1803,7 @@ const UILayout: React.FC<UILayoutProp> = (props) => {
                                     handleLinkRemoteMode()
                                 }}
                                 onlyInstallLatestEngine={onlyInstallLatestEngine}
-                                setYakitStatus={onSetYakitStatus}
+                                setYakitStatus={setYakitStatus}
                             />
                         )}
 
@@ -1792,7 +1822,7 @@ const UILayout: React.FC<UILayoutProp> = (props) => {
                             system={system}
                             setLog={setCheckLog}
                             onLinkEngine={handleLinkLocalEngine}
-                            setYakitStatus={onSetYakitStatus}
+                            setYakitStatus={setYakitStatus}
                             checkEngineDownloadLatestVersion={checkEngineDownloadLatestVersion}
                         />
                         {!engineLink && isRemoteEngine && yakitStatus !== "control-remote" && (
diff --git a/app/renderer/src/main/src/components/layout/update/InstallEngine.tsx b/app/renderer/src/main/src/components/layout/update/InstallEngine.tsx
index 04d8a1dc8a..5e90894739 100644
--- a/app/renderer/src/main/src/components/layout/update/InstallEngine.tsx
+++ b/app/renderer/src/main/src/components/layout/update/InstallEngine.tsx
@@ -15,9 +15,8 @@ import {CopyComponents} from "@/components/yakitUI/YakitTag/YakitTag"
 import {YakitPopconfirm} from "@/components/yakitUI/YakitPopconfirm/YakitPopconfirm"
 import {safeFormatDownloadProcessState} from "../utils"
 import {OutlineQuestionmarkcircleIcon} from "@/assets/icon/outline"
-import {grpcFetchLatestOSSDomain, grpcFetchLatestYakVersion} from "@/apiUtils/grpc"
+import {grpcFetchBuildInYakVersion, grpcFetchLatestOSSDomain, grpcFetchLatestYakVersion} from "@/apiUtils/grpc"
 import emiter from "@/utils/eventBus/eventBus"
-import {WebsiteGV} from "@/enums/website"
 import {setClipboardText} from "@/utils/clipboard"
 import classNames from "classnames"
 import styles from "./InstallEngine.module.scss"
@@ -46,8 +45,7 @@ export const InstallEngine: React.FC<InstallEngineProps> = React.memo((props) =>
 
     useEffect(() => {
         ipcRenderer.invoke("fetch-system-and-arch").then((e: string) => setPlatformArch(e))
-        ipcRenderer
-            .invoke("GetBuildInEngineVersion")
+        grpcFetchBuildInYakVersion(true)
             .then((ver) => setBuildInEngineVersion(ver))
             .catch(() => {})
     }, [])
@@ -638,7 +636,7 @@ export const QuestionModal: React.FC<AgrAndQSModalProps> = React.memo((props) =>
     const [bounds, setBounds] = useState({left: 0, top: 0, bottom: 0, right: 0})
     const draggleRef = useRef<HTMLDivElement>(null)
 
-    const [ossDomain, setOSSDomain] = useState<string>("");
+    const [ossDomain, setOSSDomain] = useState<string>("")
 
     useEffect(() => {
         grpcFetchLatestOSSDomain().then(setOSSDomain)
diff --git a/app/renderer/src/main/src/components/layout/update/UpdateYakitAndYaklang.module.scss b/app/renderer/src/main/src/components/layout/update/UpdateYakitAndYaklang.module.scss
index 8346c37a21..4eb15bcbf3 100644
--- a/app/renderer/src/main/src/components/layout/update/UpdateYakitAndYaklang.module.scss
+++ b/app/renderer/src/main/src/components/layout/update/UpdateYakitAndYaklang.module.scss
@@ -1,137 +1,66 @@
-.update-mask {
-    position: absolute;
-    top: 0;
-    left: 0;
-    width: 100%;
-    height: 100%;
-    overflow: hidden;
-    background: #31343f4d;
-    z-index: 1001;
-}
-.hidden-update-mask {
-    display: none;
-}
-
-// 弹窗隐藏
-.modal-hidden-wrapper {
-    display: none;
-}
-.yaklang-update-modal {
-    width: 449px;
-    z-index: 1002;
-}
-.engine-hint-modal-wrapper {
-    position: absolute;
-    top: 35%;
-    left: calc(50% - 224px);
-}
-
-.modal-yaklang-engine-hint {
-    box-sizing: border-box;
-    width: 100%;
-    background: var(--yakit-card-background-color);
-    border-radius: 4px;
-
-    .yaklang-engine-hint-wrapper {
-        width: 100%;
-        padding: 24px;
-        display: flex;
-        gap: 16px;
-        position: relative;
-
-        .hint-left-wrapper {
-            display: flex;
-            flex-direction: column;
-            justify-content: space-between;
-            .hint-icon {
-                width: 32px;
-                height: 32px;
+// ---------- UpdateYakitHint ----------
+.update-yakit-hint {
+    .content {
+        .download-progress {
+            :global {
+                .ant-progress-text {
+                    display: block;
+                    margin-left: 0;
+                    margin-top: 2px;
+                }
             }
         }
-
-        .hint-right-wrapper {
-            flex: 1;
-            .hint-right-title {
-                height: 24px;
-                font-weight: 600;
-                font-size: 16px;
-                line-height: 24px;
-                color: var(--yakit-header-color);
+        .download-info-wrapper {
+            margin-top: 16px;
+            display: flex;
+            align-items: center;
+            height: 16px;
+            font-size: 12px;
+            color: var(--yakit-helper-text-color);
+            .divider-wrapper {
+                margin: 0 8px;
+                width: 1px;
+                height: 12px;
+                border-left: 1px solid var(--yakit-border-color);
             }
+        }
 
-            .hint-right-download {
-                .download-progress {
-                    :global {
-                        .ant-progress-text {
-                            display: block;
-                            margin-left: 0;
-                            margin-top: 2px;
-                        }
-                    }
-                }
-                .download-info-wrapper {
-                    margin-top: 16px;
-                    display: flex;
-                    height: 16px;
-                    font-size: 12px;
-                    line-height: 16px;
-                    color: var(--yakit-helper-text-color);
-                    .divider-wrapper {
-                        margin: 0 8px;
-                        width: 1px;
-                        height: 16px;
-                        display: flex;
-                        align-items: center;
-                        .divider-style {
-                            width: 100%;
-                            height: 12px;
-                            border: 1px solid var(--yakit-border-color);
-                        }
-                    }
-                }
-                .download-btn {
-                    margin-top: 24px;
-                    display: flex;
-                    justify-content: right;
-                }
-            }
+        .hint-right-content {
+            margin-top: 8px;
+            font-size: 14px;
+            line-height: 20px;
+            color: var(--yakit-body-text-color);
+        }
+        .hint-right-update-content {
+            box-sizing: border-box;
+            margin-top: 8px;
+            max-height: 108px;
+            overflow: hidden auto;
 
-            .hint-right-content {
-                margin-top: 8px;
-                font-size: 14px;
-                line-height: 20px;
-                color: var(--yakit-body-text-color);
-            }
-            .hint-right-update-content {
-                box-sizing: border-box;
-                margin-top: 8px;
-                max-height: 108px;
-                overflow: hidden auto;
+            display: flex;
+            flex-direction: column;
+            align-items: flex-start;
+            padding: 12px;
+            gap: 6px;
 
-                display: flex;
-                flex-direction: column;
-                align-items: flex-start;
-                padding: 12px;
-                gap: 6px;
+            background: var(--yakit-neutral10-color);
+            border: 1px solid var(--yakit-border-color);
+            border-radius: 4px;
 
-                background: var(--yakit-neutral10-color);
-                border: 1px solid var(--yakit-border-color);
-                border-radius: 4px;
+            font-size: 12px;
+            line-height: 18px;
+            color: var(--yakit-header-color);
+        }
+    }
 
-                font-size: 12px;
-                line-height: 18px;
-                color: var(--yakit-header-color);
-            }
-            .hint-right-btn {
-                margin-top: 24px;
-                display: flex;
-                justify-content: space-between;
+    .footer {
+        margin-top: 24px;
+        display: flex;
+        justify-content: space-between;
 
-                .btn-group-wrapper {
-                    display: flex;
-                    gap: 8px;
-                }
-            }
+        .btn-group {
+            display: flex;
+            gap: 8px;
         }
     }
 }
diff --git a/app/renderer/src/main/src/components/layout/update/UpdateYakitAndYaklang.tsx b/app/renderer/src/main/src/components/layout/update/UpdateYakitAndYaklang.tsx
index 89bc516cfa..04249608b4 100644
--- a/app/renderer/src/main/src/components/layout/update/UpdateYakitAndYaklang.tsx
+++ b/app/renderer/src/main/src/components/layout/update/UpdateYakitAndYaklang.tsx
@@ -1,87 +1,63 @@
-import React, {useEffect, useMemo, useRef, useState} from "react"
-import {useGetState, useMemoizedFn} from "ahooks"
-import {YaklangInstallHintSvgIcon} from "../icons"
+import React, {useEffect, useMemo, useState} from "react"
+import {useMemoizedFn} from "ahooks"
 import {Progress} from "antd"
 import {DownloadingState} from "@/yakitGVDefine"
 import {YakitButton} from "@/components/yakitUI/YakitButton/YakitButton"
 import {setLocalValue} from "@/utils/kv"
-import {failed, success} from "@/utils/notification"
+import {failed, info, success} from "@/utils/notification"
 import {getReleaseEditionName, isEnterpriseEdition} from "@/utils/envfile"
 import {UpdateContentProp} from "../FuncDomain"
 import {NetWorkApi} from "@/services/fetch"
 import {LocalGVS} from "@/enums/localGlobal"
 import {safeFormatDownloadProcessState} from "../utils"
 import {API} from "@/services/swagger/resposeType"
-import classNames from "classnames"
+import {YakitHint} from "@/components/yakitUI/YakitHint/YakitHint"
+
 import styles from "./UpdateYakitAndYaklang.module.scss"
 
 const {ipcRenderer} = window.require("electron")
 
-export interface UpdateYakitAndYaklangProps {
-    currentYakit: string
-    latestYakit: string
-    setLatestYakit: (val: string) => any
-    currentYaklang: string
-    latestYaklang: string
-    setLatestYaklang: (val: string) => any
-    isShow: boolean
-    onCancel: () => any
+// 去除版本号里的v字符
+const removePrefixV = (version: string) => {
+    return version.startsWith("v") ? version.substring(1) : version
+}
+
+interface UpdateYakitHintProps {
+    current: string
+    latest: string
+    visible: boolean
+    onCallback: () => void
 }
+/** yakit 更新弹框-包括更新内容 */
+export const UpdateYakitHint: React.FC<UpdateYakitHintProps> = React.memo((props) => {
+    const {latest, visible, onCallback} = props
 
-export const UpdateYakitAndYaklang: React.FC<UpdateYakitAndYaklangProps> = React.memo((props) => {
-    const {
-        currentYakit,
-        latestYakit,
-        setLatestYakit,
-        currentYaklang,
-        latestYaklang,
-        setLatestYaklang,
-        isShow,
-        onCancel
-    } = props
+    useEffect(() => {
+        if (visible) {
+            fetchYakitUpdateContent()
+            return () => {
+                setStatus("ready")
+                setYakitProgress(undefined)
+                setBreakLoading(false)
+                setYakitUpdateContent({version: "", content: ""})
+            }
+        }
+    }, [visible])
 
-    const [yakitProgress, setYakitProgress, getYakitProgress] = useGetState<DownloadingState>()
-    const isYakitBreak = useRef<boolean>(false)
-    const [yaklangProgress, setYaklangProgress, getYaklangProgress] = useGetState<DownloadingState>()
-    const isYaklangBreak = useRef<boolean>(false)
+    const handleCancel = useMemoizedFn(() => {
+        onCallback()
+    })
 
-    const [installYakit, setInstallYakit] = useState<boolean>(false)
-    const [installedYakit, setInstalledYakit] = useState<boolean>(false)
-    const [yakitLoading, setYakitLoading] = useState<boolean>(false)
-    const [installYaklang, setInstallYaklang] = useState<boolean>(false)
-    const [yaklangLoading, setYaklangLoading] = useState<boolean>(false)
+    const [status, setStatus] = useState<"ready" | "install" | "installed">("ready")
+    const [yakitProgress, setYakitProgress] = useState<DownloadingState>()
+    const [breakLoading, setBreakLoading] = useState<boolean>(false)
 
     const [yakitUpdateContent, setYakitUpdateContent] = useState<UpdateContentProp>({
         version: "",
         content: ""
     })
-    const [yaklangUpdateContent, setYaklangUpdateContent] = useState<UpdateContentProp>({
-        version: "",
-        content: ""
-    })
 
-    const removePrefixV = (version: string) => {
-        return version.startsWith("v") ? version.slice(1) : version
-    }
-
-    const yakitContent: string[] = useMemo(() => {
-        if (!yakitUpdateContent.content) return []
-        if (removePrefixV(yakitUpdateContent.version) !== removePrefixV(latestYakit)) return []
-        if (yakitUpdateContent.content) {
-            return yakitUpdateContent.content.split("\n")
-        }
-        return []
-    }, [yakitUpdateContent])
-    const yaklangContent: string[] = useMemo(() => {
-        if (!yaklangUpdateContent.content) return []
-        if (removePrefixV(yaklangUpdateContent.version) !== removePrefixV(latestYaklang)) return []
-        if (yaklangUpdateContent.content) {
-            return yaklangUpdateContent.content.split("\n")
-        }
-        return []
-    }, [yaklangUpdateContent])
-
-    const fetchYakitAndYaklangVersionInfo = useMemoizedFn(() => {
+    const fetchYakitUpdateContent = useMemoizedFn(() => {
         NetWorkApi<any, API.YakVersionsInfoResponse>({
             method: "get",
             url: "yak/versions/info"
@@ -93,14 +69,9 @@ export const UpdateYakitAndYaklang: React.FC<UpdateYakitAndYaklangProps> = React
                     data.forEach((item) => {
                         if (item.type === "yakit") {
                             const content: UpdateContentProp = JSON.parse(item.content)
-                            if (removePrefixV(content.version) === removePrefixV(latestYakit)) {
+                            if (removePrefixV(content.version) === removePrefixV(latest)) {
                                 setYakitUpdateContent({...content})
                             }
-                        } else if (item.type === "yaklang") {
-                            const content: UpdateContentProp = JSON.parse(item.content)
-                            if (removePrefixV(content.version) === removePrefixV(latestYaklang)) {
-                                setYaklangUpdateContent({...content})
-                            }
                         }
                     })
                 } catch (error) {}
@@ -108,98 +79,62 @@ export const UpdateYakitAndYaklang: React.FC<UpdateYakitAndYaklangProps> = React
             .catch((err) => {})
     })
 
-    useEffect(() => {
-        if (latestYakit || latestYaklang) fetchYakitAndYaklangVersionInfo()
-    }, [latestYakit, latestYaklang])
+    const yakitContent: string[] = useMemo(() => {
+        if (!yakitUpdateContent.content) return []
+        return yakitUpdateContent.content.split("\n")
+    }, [yakitUpdateContent])
 
     useEffect(() => {
         ipcRenderer.on("download-yakit-engine-progress", (e: any, state: DownloadingState) => {
-            if (isYakitBreak.current) return
             setYakitProgress(safeFormatDownloadProcessState(state))
         })
 
-        ipcRenderer.on("download-yak-engine-progress", (e: any, state: DownloadingState) => {
-            if (isYaklangBreak.current) return
-            setYaklangProgress(safeFormatDownloadProcessState(state))
-        })
-
         return () => {
             ipcRenderer.removeAllListeners("download-yakit-engine-progress")
-            ipcRenderer.removeAllListeners("download-yak-engine-progress")
         }
     }, [])
 
-    const isShowYakit = useMemo(() => {
-        if (!isShow) return false
-        if (!currentYakit || !latestYakit) return false
-        if (removePrefixV(currentYakit) !== removePrefixV(latestYakit)) return true
-        return false
-    }, [currentYakit, latestYakit, isShow])
-    const isShowYaklang = useMemo(() => {
-        if (!isShow) return false
-        if (!currentYaklang || !latestYaklang) return false
-        if (removePrefixV(currentYaklang) !== removePrefixV(latestYaklang)) return true
-        return false
-    }, [currentYaklang, latestYaklang, isShow])
-
-    /** 不再提示 */
-    const noHint = () => {
-        setLocalValue(LocalGVS.NoAutobootLatestVersionCheck, true)
-        setLatestYakit("")
-        setLatestYaklang("")
-        onCancel()
-    }
-
-    const yakitLater = useMemoizedFn(() => {
-        setLatestYakit("")
-        if (!isShowYaklang) onCancel()
-    })
-    const yaklangLater = useMemoizedFn(() => {
-        setLatestYaklang("")
-        onCancel()
-    })
-
-    const yakitDownload = () => {
-        let version = latestYakit
-        if (version.startsWith("v")) version = version.slice(1)
-        isYakitBreak.current = false
-        setInstallYakit(true)
+    /** 下载 */
+    const handleDownload = useMemoizedFn(() => {
+        let version = latest.startsWith("v") ? latest.substring(1) : latest
+        setStatus("install")
         ipcRenderer
             .invoke("download-latest-yakit", version, isEnterpriseEdition())
             .then(() => {
-                if (isYakitBreak.current) return
                 success("下载完毕")
-                if (!getYakitProgress()?.size) return
-                setYakitProgress({
-                    time: {
-                        elapsed: getYakitProgress()?.time.elapsed || 0,
-                        remaining: 0
-                    },
-                    speed: 0,
-                    percent: 100,
-                    // @ts-ignore
-                    size: getYakitProgress().size
+                setYakitProgress((old) => {
+                    if (!old) return undefined
+                    return {
+                        time: {
+                            elapsed: old?.time.elapsed || 0,
+                            remaining: 0
+                        },
+                        speed: 0,
+                        percent: 100,
+                        size: old.size
+                    }
                 })
-                setInstallYakit(false)
-                setInstalledYakit(true)
+                setStatus("installed")
             })
             .catch((e: any) => {
-                if (isYakitBreak.current) return
                 failed(`下载失败: ${e}`)
                 setYakitProgress(undefined)
-                setInstallYakit(false)
+                setStatus("ready")
             })
-    }
+    })
+
+    /** 停止下载 */
     const yakitBreak = useMemoizedFn(() => {
-        setYakitLoading(true)
-        isYakitBreak.current = true
-        setInstallYakit(false)
+        ipcRenderer.invoke("cancel-download-yakit-version")
+        setBreakLoading(true)
+        setStatus("ready")
         setYakitProgress(undefined)
-        yakitLater()
         setTimeout(() => {
-            setYakitLoading(false)
+            setBreakLoading(false)
         }, 300)
     })
+
+    /** 立即更新-已下载完成 */
     const yakitUpdate = useMemoizedFn(() => {
         ipcRenderer.invoke("open-yakit-path")
         setTimeout(() => {
@@ -207,284 +142,186 @@ export const UpdateYakitAndYaklang: React.FC<UpdateYakitAndYaklangProps> = React
         }, 100)
     })
 
-    const yaklangDownload = useMemoizedFn(async () => {
-        isYaklangBreak.current = false
-        let version = latestYaklang
-        if (version.startsWith("v")) version = version.slice(1)
-        try {
-            const res = await ipcRenderer.invoke("yak-engine-version-exists-and-correctness", version)
-            if (res === true) {
-                yaklangUpdate()
-            } else {
-                realDownloadYaklang(version)
-            }
-        } catch (error) {
-            realDownloadYaklang(version)
-        }
-    })
-    const realDownloadYaklang = (version: string) => {
-        setInstallYaklang(true)
-        ipcRenderer
-            .invoke("download-latest-yak", version)
-            .then(() => {
-                if (isYaklangBreak.current) return
-
-                success("下载完毕")
-                if (!getYaklangProgress()?.size) return
-                setYaklangProgress({
-                    time: {
-                        elapsed: getYaklangProgress()?.time.elapsed || 0,
-                        remaining: 0
-                    },
-                    speed: 0,
-                    percent: 100,
-                    // @ts-ignore
-                    size: getYaklangProgress().size
-                })
-                yaklangUpdate()
-            })
-            .catch((e: any) => {
-                if (isYaklangBreak.current) return
-                failed(`引擎下载失败: ${e}`)
-                setInstallYaklang(false)
-                setYaklangProgress(undefined)
-            })
+    /** 不再提示 */
+    const noHint = () => {
+        setLocalValue(LocalGVS.NoAutobootLatestVersionCheck, true)
+        handleCancel()
     }
-    const yaklangBreak = useMemoizedFn(() => {
-        let version = latestYaklang
-        if (version.startsWith("v")) version = version.slice(1)
-        ipcRenderer.invoke("cancel-download-yak-engine-version", version)
 
-        setYaklangLoading(true)
-        isYaklangBreak.current = true
-        setInstallYaklang(false)
-        setYaklangProgress(undefined)
-        yaklangLater()
-        setTimeout(() => {
-            setYaklangLoading(false)
-        }, 300)
-    })
-    const yaklangUpdate = useMemoizedFn(() => {
-        // 清空主进程yaklang版本缓存
-        ipcRenderer.invoke("clear-local-yaklang-version-cache")
-        let version = latestYaklang
-        if (version.startsWith("v")) version = version.slice(1)
-        ipcRenderer
-            .invoke("install-yak-engine", version)
-            .then(() => {
-                success(`安装成功，如未生效，重启 ${getReleaseEditionName()} 即可`)
-            })
-            .catch((err: any) => {
-                failed(
-                    `安装失败: ${
-                        err.message.indexOf("operation not permitted") > -1 ? "请关闭引擎后重启软件尝试" : err
-                    }`
-                )
-            })
-            .finally(() => {
-                setTimeout(() => {
-                    yaklangLater()
-                }, 50)
-            })
-    })
+    const title = useMemo(() => {
+        if (status === "ready") return `检测到 ${getReleaseEditionName()} 版本升级`
+        if (status === "install") return `${getReleaseEditionName()} 下载中...`
+        if (status === "installed") return `${getReleaseEditionName()} 下载成功`
+        return "异常错误，请关闭!"
+    }, [status])
+
+    const extraBtn = useMemo(() => {
+        if (status === "ready") {
+            return (
+                <YakitButton size='max' type='outline2' onClick={noHint}>
+                    不再提示
+                </YakitButton>
+            )
+        }
+        return null
+    }, [status])
+
+    const footerBtn = useMemo(() => {
+        if (status === "ready") {
+            return (
+                <>
+                    <YakitButton size='max' type='outline2' onClick={handleCancel}>
+                        稍后再说
+                    </YakitButton>
+                    <YakitButton size='max' onClick={handleDownload}>
+                        立即更新
+                    </YakitButton>
+                </>
+            )
+        }
+        if (status === "install") {
+            return (
+                <YakitButton loading={breakLoading} size='max' type='outline2' onClick={yakitBreak}>
+                    取消
+                </YakitButton>
+            )
+        }
+        if (status === "installed") {
+            return (
+                <>
+                    <YakitButton size='max' type='outline2' onClick={handleCancel}>
+                        取消
+                    </YakitButton>
+                    <YakitButton size='max' onClick={yakitUpdate}>
+                        确定
+                    </YakitButton>
+                </>
+            )
+        }
+        return null
+    }, [status, breakLoading])
 
     return (
-        <div className={isShow ? styles["update-mask"] : styles["hidden-update-mask"]}>
-            <div
-                className={classNames(
-                    styles["yaklang-update-modal"],
-                    isShowYakit ? styles["engine-hint-modal-wrapper"] : styles["modal-hidden-wrapper"]
-                )}
-            >
-                <div className={styles["modal-yaklang-engine-hint"]}>
-                    <div className={styles["yaklang-engine-hint-wrapper"]}>
-                        <div className={styles["hint-left-wrapper"]}>
-                            <div className={styles["hint-icon"]}>
-                                <YaklangInstallHintSvgIcon />
-                            </div>
+        <YakitHint
+            getContainer={document.getElementById("yakit-uilayout-body") || undefined}
+            footer={null}
+            visible={visible}
+            title={title}
+        >
+            <div className={styles["update-yakit-hint"]}>
+                {status === "ready" && (
+                    <div className={styles["content"]}>
+                        <div
+                            className={styles["hint-right-content"]}
+                        >{`${getReleaseEditionName()} ${latest} 更新说明 :`}</div>
+                        <div className={styles["hint-right-update-content"]}>
+                            {yakitContent.length === 0
+                                ? "管理员未编辑更新通知"
+                                : yakitContent.map((item, index) => {
+                                      return <div key={`${item}-${index}`}>{item}</div>
+                                  })}
                         </div>
+                    </div>
+                )}
 
-                        <div className={styles["hint-right-wrapper"]}>
-                            {installedYakit ? (
-                                <>
-                                    <div className={styles["hint-right-title"]}>{getReleaseEditionName()} 下载成功</div>
-                                    <div className={styles["hint-right-content"]}>
-                                        安装需关闭软件，双击安装包即可安装完成，是否立即安装？
-                                    </div>
-
-                                    <div className={styles["hint-right-btn"]}>
-                                        <div></div>
-                                        <div className={styles["btn-group-wrapper"]}>
-                                            <YakitButton size='max' type='outline2' onClick={yakitLater}>
-                                                取消
-                                            </YakitButton>
-                                            <YakitButton size='max' onClick={yakitUpdate}>
-                                                确定
-                                            </YakitButton>
-                                        </div>
-                                    </div>
-                                </>
-                            ) : installYakit ? (
-                                <div className={styles["hint-right-download"]}>
-                                    <div className={styles["hint-right-title"]}>{getReleaseEditionName()} 下载中...</div>
-                                    <div className={styles["download-progress"]}>
-                                        <Progress
-                                            strokeColor='#F28B44'
-                                            trailColor='#F0F2F5'
-                                            percent={Math.floor((yakitProgress?.percent || 0) * 100)}
-                                        />
-                                    </div>
-                                    <div className={styles["download-info-wrapper"]}>
-                                        <div>剩余时间 : {(yakitProgress?.time.remaining || 0).toFixed(2)}s</div>
-                                        <div className={styles["divider-wrapper"]}>
-                                            <div className={styles["divider-style"]}></div>
-                                        </div>
-                                        <div>耗时 : {(yakitProgress?.time.elapsed || 0).toFixed(2)}s</div>
-                                        <div className={styles["divider-wrapper"]}>
-                                            <div className={styles["divider-style"]}></div>
-                                        </div>
-                                        <div>
-                                            下载速度 : {((yakitProgress?.speed || 0) / 1000000).toFixed(2)}
-                                            M/s
-                                        </div>
-                                    </div>
-                                    <div className={styles["download-btn"]}>
-                                        <YakitButton
-                                            loading={yakitLoading}
-                                            size='max'
-                                            type='outline2'
-                                            onClick={yakitBreak}
-                                        >
-                                            取消
-                                        </YakitButton>
-                                    </div>
-                                </div>
-                            ) : (
-                                <>
-                                    <div className={styles["hint-right-title"]}>
-                                        检测到 {getReleaseEditionName()} 版本升级
-                                    </div>
-                                    <div className={styles["hint-right-content"]}>
-                                        {`${getReleaseEditionName()} ${latestYakit} 更新说明 :`}
-                                    </div>
-                                    <div className={styles["hint-right-update-content"]}>
-                                        {yakitContent.length === 0
-                                            ? "管理员未编辑更新通知"
-                                            : yakitContent.map((item, index) => {
-                                                  return <div key={`${item}-${index}`}>{item}</div>
-                                              })}
-                                    </div>
+                {status === "installed" && (
+                    <div className={styles["content"]}>
+                        <div className={styles["hint-right-content"]}>
+                            安装需关闭软件，双击安装包即可安装完成，是否立即安装？
+                        </div>
+                    </div>
+                )}
 
-                                    <div className={styles["hint-right-btn"]}>
-                                        <div>
-                                            <YakitButton size='max' type='outline2' onClick={noHint}>
-                                                不再提示
-                                            </YakitButton>
-                                        </div>
-                                        <div className={styles["btn-group-wrapper"]}>
-                                            <YakitButton size='max' type='outline2' onClick={yakitLater}>
-                                                稍后再说
-                                            </YakitButton>
-                                            <YakitButton size='max' onClick={yakitDownload}>
-                                                立即更新
-                                            </YakitButton>
-                                        </div>
-                                    </div>
-                                </>
-                            )}
+                {status === "install" && (
+                    <div className={styles["content"]}>
+                        <div className={styles["download-progress"]}>
+                            <Progress
+                                strokeColor='#F28B44'
+                                trailColor='#F0F2F5'
+                                percent={Math.floor((yakitProgress?.percent || 0) * 100)}
+                            />
+                        </div>
+                        <div className={styles["download-info-wrapper"]}>
+                            <div>剩余时间 : {(yakitProgress?.time.remaining || 0).toFixed(2)}s</div>
+                            <div className={styles["divider-wrapper"]}></div>
+                            <div>耗时 : {(yakitProgress?.time.elapsed || 0).toFixed(2)}s</div>
+                            <div className={styles["divider-wrapper"]}></div>
+                            <div>
+                                下载速度 : {((yakitProgress?.speed || 0) / 1000000).toFixed(2)}
+                                M/s
+                            </div>
                         </div>
                     </div>
+                )}
+
+                <div className={styles["footer"]}>
+                    <div>{extraBtn}</div>
+                    <div className={styles["btn-group"]}>{footerBtn}</div>
                 </div>
             </div>
+        </YakitHint>
+    )
+})
 
-            <div
-                className={classNames(
-                    styles["yaklang-update-modal"],
-                    isShowYaklang && !isShowYakit ? styles["engine-hint-modal-wrapper"] : styles["modal-hidden-wrapper"]
-                )}
-            >
-                <div className={styles["modal-yaklang-engine-hint"]}>
-                    <div className={styles["yaklang-engine-hint-wrapper"]}>
-                        <div className={styles["hint-left-wrapper"]}>
-                            <div className={styles["hint-icon"]}>
-                                <YaklangInstallHintSvgIcon />
-                            </div>
-                        </div>
+interface UpdateYakHintProps {
+    current: string
+    buildIn: string
+    visible: boolean
+    onCallback: (result: boolean) => void
+}
+/** 引擎更新弹框-更新为内置版本引擎 */
+export const UpdateYakHint: React.FC<UpdateYakHintProps> = React.memo((props) => {
+    const {current, buildIn, visible, onCallback} = props
 
-                        <div className={styles["hint-right-wrapper"]}>
-                            {installYaklang ? (
-                                <div className={styles["hint-right-download"]}>
-                                    <div className={styles["hint-right-title"]}>引擎下载中...</div>
-                                    <div className={styles["download-progress"]}>
-                                        <Progress
-                                            strokeColor='#F28B44'
-                                            trailColor='#F0F2F5'
-                                            percent={Math.floor((yaklangProgress?.percent || 0) * 100)}
-                                        />
-                                    </div>
-                                    <div className={styles["download-info-wrapper"]}>
-                                        <div>剩余时间 : {(yaklangProgress?.time.remaining || 0).toFixed(2)}s</div>
-                                        <div className={styles["divider-wrapper"]}>
-                                            <div className={styles["divider-style"]}></div>
-                                        </div>
-                                        <div>耗时 : {(yaklangProgress?.time.elapsed || 0).toFixed(2)}s</div>
-                                        <div className={styles["divider-wrapper"]}>
-                                            <div className={styles["divider-style"]}></div>
-                                        </div>
-                                        <div>
-                                            下载速度 : {((yaklangProgress?.speed || 0) / 1000000).toFixed(2)}
-                                            M/s
-                                        </div>
-                                    </div>
-                                    <div className={styles["download-btn"]}>
-                                        <YakitButton
-                                            loading={yaklangLoading}
-                                            size='max'
-                                            type='outline2'
-                                            onClick={yaklangBreak}
-                                        >
-                                            取消
-                                        </YakitButton>
-                                    </div>
-                                </div>
-                            ) : (
-                                <>
-                                    <div className={styles["hint-right-title"]}>检测到引擎版本升级</div>
-                                    <div className={styles["hint-right-content"]}>
-                                        {/* {`当前版本：${currentYaklang}`}
-                                        <br />
-                                        {`最新版本：${latestYaklang}`} */}
-                                        {`Yaklang ${latestYaklang} 更新说明 :`}
-                                    </div>
-                                    <div className={styles["hint-right-update-content"]}>
-                                        {yaklangContent.length === 0
-                                            ? "管理员未编辑更新通知"
-                                            : yaklangContent.map((item, index) => {
-                                                  return <div key={`${item}-${index}`}>{item}</div>
-                                              })}
-                                    </div>
+    useEffect(() => {
+        if (visible) {
+            return () => {
+                setUpdateLoading(false)
+            }
+        }
+    }, [visible])
 
-                                    <div className={styles["hint-right-btn"]}>
-                                        <div>
-                                            <YakitButton size='max' type='outline2' onClick={noHint}>
-                                                不再提示
-                                            </YakitButton>
-                                        </div>
-                                        <div className={styles["btn-group-wrapper"]}>
-                                            <YakitButton size='max' type='outline2' onClick={yaklangLater}>
-                                                稍后再说
-                                            </YakitButton>
-                                            <YakitButton size='max' onClick={yaklangDownload}>
-                                                立即更新
-                                            </YakitButton>
-                                        </div>
-                                    </div>
-                                </>
-                            )}
-                        </div>
-                    </div>
+    const handleCancel = useMemoizedFn(() => {
+        onCallback(false)
+    })
+
+    const [updateLoading, setUpdateLoading] = useState<boolean>(false)
+
+    /** 立即更新成内置引擎 */
+    const yakitUpdate = useMemoizedFn(() => {
+        if (updateLoading) return
+
+        setUpdateLoading(true)
+        ipcRenderer
+            .invoke("InitBuildInEngine", {})
+            .then(() => {
+                info(`解压内置引擎成功`)
+                onCallback(true)
+            })
+            .catch((e) => {
+                failed(`初始化内置引擎失败：${e}`)
+            })
+            .finally(() => setTimeout(() => setUpdateLoading(false), 300))
+    })
+
+    return (
+        <YakitHint
+            getContainer={document.getElementById("yakit-uilayout-body") || undefined}
+            title={"检测到引擎版本低于内置版本"}
+            content={
+                <div>
+                    当前引擎低于建议版本将会导致软件部分功能使用出现异常!!!
+                    <div>当前版本 : {current}</div>
+                    <div>建议版本 : {buildIn}</div>
                 </div>
-            </div>
-        </div>
+            }
+            visible={visible}
+            okButtonText='立即更新'
+            okButtonProps={{loading: updateLoading}}
+            cancelButtonText='忽略'
+            cancelButtonProps={{style: {display: updateLoading ? "none" : ""}}}
+            onOk={yakitUpdate}
+            onCancel={handleCancel}
+        />
     )
 })
diff --git a/app/renderer/src/main/src/constants/hardware.ts b/app/renderer/src/main/src/constants/hardware.ts
index 74acbf0f01..8aed739079 100644
--- a/app/renderer/src/main/src/constants/hardware.ts
+++ b/app/renderer/src/main/src/constants/hardware.ts
@@ -17,8 +17,11 @@ export type Architecture =
     | "x64"
 
 interface SystemInfoProps {
+    /** 操作系统 */
     system?: System
+    /** 系统架构 */
     architecture?: Architecture
+    /** 是否为开发环境 */
     isDev?: boolean
 }
 
diff --git a/app/renderer/src/main/src/pages/pluginHub/hooks/useGetSetState.ts b/app/renderer/src/main/src/pages/pluginHub/hooks/useGetSetState.ts
index 7d5b19ef40..80494756a8 100644
--- a/app/renderer/src/main/src/pages/pluginHub/hooks/useGetSetState.ts
+++ b/app/renderer/src/main/src/pages/pluginHub/hooks/useGetSetState.ts
@@ -1,14 +1,23 @@
-import {SetStateAction, useRef, useState} from "react"
+import {Dispatch, SetStateAction, useRef, useState} from "react"
 import {useMemoizedFn} from "ahooks"
 
+type GetStateAction<S> = () => S
+
+function useGetSetState<S>(initialState: S | (() => S)): [S, Dispatch<SetStateAction<S>>, GetStateAction<S>]
+function useGetSetState<S = undefined>(): [
+    S | undefined,
+    Dispatch<SetStateAction<S | undefined>>,
+    GetStateAction<S | undefined>
+]
+
 /**
  * @description 在设置值时，注意对象类型使用的是引用
  */
-function useGetSetState<T>(target: T): [T, (initState: SetStateAction<T>) => void, () => T] {
-    const [value, setValue] = useState<T>(target)
-    const valueRef = useRef<T>(target)
+function useGetSetState<S>(target?: S) {
+    const [value, setValue] = useState(target)
+    const valueRef = useRef(target)
 
-    const onSetValue = useMemoizedFn((initState: SetStateAction<T>) => {
+    const onSetValue = useMemoizedFn((initState: SetStateAction<S>) => {
         try {
             if (typeof initState === "function") {
                 setValue((old) => {
diff --git a/app/renderer/src/main/src/utils/eventBus/events/updateYakitYaklang.ts b/app/renderer/src/main/src/utils/eventBus/events/updateYakitYaklang.ts
index edf35ccff1..73fd6e2317 100644
--- a/app/renderer/src/main/src/utils/eventBus/events/updateYakitYaklang.ts
+++ b/app/renderer/src/main/src/utils/eventBus/events/updateYakitYaklang.ts
@@ -13,6 +13,4 @@ export type UpdateYakitYaklangEventProps = {
     useOfficialEngineByDownload?: string
     /** 系统检测校验引擎是否是官方发布 使用内置引擎 */
     useOfficialEngineByDownloadByBuiltIn?: string
-    /** 执行localEngine文件中的内置引擎 */
-    execLocalEngineInitBuildInEngine?: string
 }

From 60f2753f4a7447107a722cc0655d9b2555d2918a Mon Sep 17 00:00:00 2001
From: nonight <378099757@qq.com>
Date: Fri, 7 Feb 2025 20:56:35 +0800
Subject: [PATCH 2/2] =?UTF-8?q?=E7=A7=BB=E9=99=A4=E4=B8=BB=E7=95=8C?=
 =?UTF-8?q?=E9=9D=A2=E5=86=85=E7=9A=84=E5=86=85=E7=BD=AE=E5=BC=95=E6=93=8E?=
 =?UTF-8?q?=E7=89=88=E6=9C=AC=E6=A3=80=E6=B5=8B=E5=BC=B9=E6=A1=86?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../CheckEngineVersion.module.scss            |   5 -
 .../CheckEngineVersion/CheckEngineVersion.tsx |  65 -----------
 .../main/src/components/layout/FuncDomain.tsx |  15 +--
 .../main/src/components/layout/UILayout.tsx   | 110 +-----------------
 app/renderer/src/main/src/enums/engine.ts     |   1 +
 5 files changed, 8 insertions(+), 188 deletions(-)
 delete mode 100644 app/renderer/src/main/src/components/layout/CheckEngineVersion/CheckEngineVersion.module.scss
 delete mode 100644 app/renderer/src/main/src/components/layout/CheckEngineVersion/CheckEngineVersion.tsx

diff --git a/app/renderer/src/main/src/components/layout/CheckEngineVersion/CheckEngineVersion.module.scss b/app/renderer/src/main/src/components/layout/CheckEngineVersion/CheckEngineVersion.module.scss
deleted file mode 100644
index a30045f18c..0000000000
--- a/app/renderer/src/main/src/components/layout/CheckEngineVersion/CheckEngineVersion.module.scss
+++ /dev/null
@@ -1,5 +0,0 @@
-.check-engine-version-checkbox {
-  height: 100%;
-  display: flex;
-  align-items: center;
-}
\ No newline at end of file
diff --git a/app/renderer/src/main/src/components/layout/CheckEngineVersion/CheckEngineVersion.tsx b/app/renderer/src/main/src/components/layout/CheckEngineVersion/CheckEngineVersion.tsx
deleted file mode 100644
index 5bc3391653..0000000000
--- a/app/renderer/src/main/src/components/layout/CheckEngineVersion/CheckEngineVersion.tsx
+++ /dev/null
@@ -1,65 +0,0 @@
-import React, {useState} from "react"
-import {YakitHint} from "@/components/yakitUI/YakitHint/YakitHint"
-import {useMemoizedFn} from "ahooks"
-import {YakitCheckbox} from "@/components/yakitUI/YakitCheckbox/YakitCheckbox"
-import {setRemoteValue} from "@/utils/kv"
-import {EngineRemoteGV} from "@/enums/engine"
-import {YaklangEngineMode} from "@/yakitGVDefine"
-
-import styles from "./CheckEngineVersion.module.scss"
-
-interface CheckEngineVersionProps {
-    engineMode: YaklangEngineMode
-    currentVersion: string
-    builtInVersion: string
-    visible: boolean
-    onCancel: (flag: boolean) => any
-}
-
-/** @name Yakit软件更新下载弹窗 */
-export const CheckEngineVersion: React.FC<CheckEngineVersionProps> = React.memo((props) => {
-    const {engineMode, visible, currentVersion, builtInVersion, onCancel} = props
-
-    const [loading, setLoading] = useState<boolean>(false)
-
-    const [noPrompt, setNoPrompt] = useState<boolean>(false)
-
-    const onSubmit = useMemoizedFn(() => {
-        if (loading) return
-        setRemoteValue(EngineRemoteGV.RemoteCheckEngineVersion, `${noPrompt}`)
-        onCancel(true)
-        setTimeout(() => {
-            setLoading(false)
-        }, 500)
-    })
-    const onClose = useMemoizedFn(() => {
-        setRemoteValue(EngineRemoteGV.RemoteCheckEngineVersion, `${noPrompt}`)
-        onCancel(false)
-    })
-
-    return (
-        <YakitHint
-            visible={visible}
-            title='引擎版本过低'
-            content={
-                <div>
-                    检测到当前使用的引擎版本过低，可能会影响部分功能的使用，建议立即更新引擎版本。
-                    <div>当前版本 : {currentVersion}</div>
-                    <div>建议版本 : {builtInVersion}</div>
-                </div>
-            }
-            footerExtra={
-                <div className={styles["check-engine-version-checkbox"]}>
-                    <YakitCheckbox value={noPrompt} onChange={(e) => setNoPrompt(e.target.checked)}>
-                        不再提醒
-                    </YakitCheckbox>
-                </div>
-            }
-            okButtonText='立即更新'
-            okButtonProps={{loading: loading, style: {display: engineMode === "remote" ? "none" : ""}}}
-            onOk={onSubmit}
-            cancelButtonText={engineMode === "remote" ? "知道了" : "忽略"}
-            onCancel={onClose}
-        />
-    )
-})
diff --git a/app/renderer/src/main/src/components/layout/FuncDomain.tsx b/app/renderer/src/main/src/components/layout/FuncDomain.tsx
index 1a31d7eb87..5127937dc3 100644
--- a/app/renderer/src/main/src/components/layout/FuncDomain.tsx
+++ b/app/renderer/src/main/src/components/layout/FuncDomain.tsx
@@ -184,7 +184,6 @@ export interface FuncDomainProp {
     showProjectManage?: boolean
     /** @name 操作系统类型 */
     system: YakitSystem
-    onYakEngineVersionList: (versionList: string[]) => void
 }
 
 export const FuncDomain: React.FC<FuncDomainProp> = React.memo((props) => {
@@ -198,8 +197,7 @@ export const FuncDomain: React.FC<FuncDomainProp> = React.memo((props) => {
         typeCallback,
         showProjectManage = false,
         system,
-        isJudgeLicense,
-        onYakEngineVersionList
+        isJudgeLicense
     } = props
 
     /** 登录用户信息 */
@@ -482,7 +480,6 @@ export const FuncDomain: React.FC<FuncDomainProp> = React.memo((props) => {
                         <UIOpNotice
                             isEngineLink={isEngineLink}
                             isRemoteMode={isRemoteMode}
-                            onYakEngineVersionList={onYakEngineVersionList}
                             onLogin={() => setLoginShow(true)}
                         />
                     )}
@@ -1562,7 +1559,6 @@ const MoreYaklangVersion: React.FC<MoreYaklangVersionProps> = React.memo((props)
 interface UIOpNoticeProp {
     isEngineLink: boolean
     isRemoteMode: boolean
-    onYakEngineVersionList: (versionList: string[]) => void
     onLogin: () => void
 }
 
@@ -1588,7 +1584,7 @@ interface SetUpdateContentProp extends FetchUpdateContentProp {
 }
 
 const UIOpNotice: React.FC<UIOpNoticeProp> = React.memo((props) => {
-    const {isEngineLink, isRemoteMode, onYakEngineVersionList, onLogin} = props
+    const {isEngineLink, isRemoteMode, onLogin} = props
 
     const {userInfo} = useStore()
 
@@ -1621,9 +1617,7 @@ const UIOpNotice: React.FC<UIOpNoticeProp> = React.memo((props) => {
         if (index2 > index1) return true
         return false
     }, [isRemoteMode, moreYaklangVersionList, yaklangLastVersion, yaklangVersion])
-    useEffect(() => {
-        onYakEngineVersionList(moreYaklangVersionList)
-    }, [moreYaklangVersionList])
+
     const versionsInfoTime = useRef<any>(null)
     const [communityYakitContent, setCommunityYakitContent] = useState<UpdateContentProp>({version: "", content: ""})
     const [communityYaklangContent, setCommunityYaklangContent] = useState<UpdateContentProp>({
@@ -1729,6 +1723,9 @@ const UIOpNotice: React.FC<UIOpNoticeProp> = React.memo((props) => {
             ipcRenderer.on("fetch-yak-version-callback", async (e: any, data: string) => {
                 setYaklangVersion(data || "dev")
             })
+            return () => {
+                ipcRenderer.removeAllListeners("fetch-yak-version-callback")
+            }
         }
     }, [isEngineLink])
 
diff --git a/app/renderer/src/main/src/components/layout/UILayout.tsx b/app/renderer/src/main/src/components/layout/UILayout.tsx
index 1304d73242..c1823b4997 100644
--- a/app/renderer/src/main/src/components/layout/UILayout.tsx
+++ b/app/renderer/src/main/src/components/layout/UILayout.tsx
@@ -58,8 +58,6 @@ import {DownloadYaklang} from "./update/DownloadYaklang"
 import {HelpDoc} from "./HelpDoc/HelpDoc"
 import {SolidCheckCircleIcon, SolidHomeIcon} from "@/assets/icon/solid"
 import {ChatCSGV} from "@/enums/chatCS"
-import {CheckEngineVersion} from "./CheckEngineVersion/CheckEngineVersion"
-import {EngineRemoteGV} from "@/enums/engine"
 import {outputToPrintLog} from "./WelcomeConsoleUtil"
 import {setNowProjectDescription} from "@/pages/globalVariable"
 import {apiGetGlobalNetworkConfig, apiSetGlobalNetworkConfig} from "@/pages/spaceEngine/utils"
@@ -75,7 +73,7 @@ import {CopyComponents} from "../yakitUI/YakitTag/YakitTag"
 import {Tooltip} from "antd"
 import {openABSFileLocated} from "@/utils/openWebsite"
 import {clearTerminalMap, getMapAllTerminalKey} from "@/pages/yakRunner/BottomEditorDetails/TerminalBox/TerminalMap"
-import {grpcFetchBuildInYakVersion, grpcFetchLatestYakVersion, grpcFetchYakInstallResult} from "@/apiUtils/grpc"
+import {grpcFetchLatestYakVersion, grpcFetchYakInstallResult} from "@/apiUtils/grpc"
 import {NetWorkApi} from "@/services/fetch"
 import {API} from "@/services/swagger/resposeType"
 import {visitorsStatisticsFun} from "@/utils/visitorsStatistics"
@@ -905,100 +903,6 @@ const UILayout: React.FC<UILayoutProp> = (props) => {
     }, [])
     /** ---------- yakit和yaklang的更新(以连接引擎的状态下) & kill引擎进程 End ---------- */
 
-    /** ---------- 软件绑定引擎版本检测提示 Start ---------- */
-    const [yakEngineVersionList, setYakEngineVersionList] = useState<string[]>([])
-    const [builtInVersion, setBuiltInVersion] = useState<string>("")
-    const [currentVersion, setCurrentVersion] = useState<string>("")
-
-    const compareVersions = (version1: string, version2: string) => {
-        // 用正则表达式将版本号分解成数字部分和beta后面的部分
-        const parseVersion = (version) => {
-            const parts = version.split("-") // 分割 beta 部分
-            const versionNumbers = parts[0].split(".").map((num) => parseInt(num)) // 获取数字部分
-            const betaPart = parts[1] ? parseInt(parts[1].replace("beta", "")) : null // 如果有beta，提取beta后的数字
-            return {versionNumbers, betaPart}
-        }
-
-        const v1 = parseVersion(version1)
-        const v2 = parseVersion(version2)
-
-        // 比较数字部分
-        for (let i = 0; i < Math.min(v1.versionNumbers.length, v2.versionNumbers.length); i++) {
-            if (v1.versionNumbers[i] > v2.versionNumbers[i]) return 1
-            if (v1.versionNumbers[i] < v2.versionNumbers[i]) return -1
-        }
-
-        // 如果数字部分相同，比较beta部分
-        if (v1.betaPart !== null && v2.betaPart !== null) {
-            if (v1.betaPart > v2.betaPart) return 1
-            if (v1.betaPart < v2.betaPart) return -1
-        }
-
-        // 如果没有beta部分，或者beta部分相同，则返回0
-        return 0
-    }
-
-    const showCheckVersion = useMemo(() => {
-        if (SystemInfo.isDev) return false
-        if (!builtInVersion) return false
-        if (!currentVersion) return false
-        return compareVersions(currentVersion, builtInVersion) === -1
-    }, [builtInVersion, currentVersion, yakEngineVersionList])
-
-    useEffect(() => {
-        // 监听事件-获取当前连接引擎的版本
-        ipcRenderer.on("fetch-yak-version-callback", async (e: any, v: string) => {
-            let version = v.replace(/\r?\n/g, "")
-            if (version.startsWith("v")) version = version.slice(1)
-            setCurrentVersion(version)
-        })
-        return () => {
-            ipcRenderer.removeAllListeners("fetch-yak-version-callback")
-        }
-    }, [])
-
-    useEffect(() => {
-        if (engineLink) {
-            getRemoteValue(EngineRemoteGV.RemoteCheckEngineVersion)
-                .then((v?: string) => {
-                    if (!v || v === "false") {
-                        if (builtInVersion === "") {
-                            // 获取软件对应的内置版本
-                            grpcFetchBuildInYakVersion(true)
-                                .then((v: string) => {
-                                    let version = v || ""
-                                    if (version.startsWith("v")) version = version.substring(1)
-                                    setBuiltInVersion(version)
-                                })
-                                .catch(() => {})
-                        }
-                        // 获取当前连接引擎的版本
-                        ipcRenderer.invoke("fetch-yak-version")
-                    }
-                })
-                .catch(() => {})
-        }
-    }, [engineLink])
-
-    const onCheckVersionCancel = useMemoizedFn((flag: boolean) => {
-        if (flag) {
-            if (yaklangKillPss) return
-            killOldProcess(() => {
-                ipcRenderer
-                    .invoke("InitBuildInEngine", {})
-                    .then(() => {
-                        yakitNotify("info", "解压内置引擎成功，即将重启软件")
-                        ipcRenderer.invoke("relaunch")
-                    })
-                    .catch((e) => {
-                        yakitNotify("error", `解压内置引擎失败：${e}`)
-                    })
-            })
-        }
-        setCurrentVersion("")
-    })
-    /** ---------- 软件绑定引擎版本检测提示 End ---------- */
-
     /** ---------- 远程控制(控制端) Start ---------- */
     const {dynamicStatus, setDynamicStatus} = yakitDynamicStatus()
     const {userInfo} = useStore()
@@ -1689,7 +1593,6 @@ const UILayout: React.FC<UILayoutProp> = (props) => {
                                                 showProjectManage={showProjectManage}
                                                 system={system}
                                                 isJudgeLicense={isJudgeLicense}
-                                                onYakEngineVersionList={setYakEngineVersionList}
                                             />
                                             {!showProjectManage && (
                                                 <>
@@ -1745,7 +1648,6 @@ const UILayout: React.FC<UILayoutProp> = (props) => {
                                                     showProjectManage={showProjectManage}
                                                     system={system}
                                                     isJudgeLicense={isJudgeLicense}
-                                                    onYakEngineVersionList={setYakEngineVersionList}
                                                 />
                                             </div>
                                         </>
@@ -1888,16 +1790,6 @@ const UILayout: React.FC<UILayoutProp> = (props) => {
                             </div>
                         )}
 
-                        {engineLink && (
-                            <CheckEngineVersion
-                                engineMode={engineMode || "local"}
-                                visible={showCheckVersion}
-                                builtInVersion={builtInVersion}
-                                currentVersion={currentVersion}
-                                onCancel={onCheckVersionCancel}
-                            />
-                        )}
-
                         <YakitHint
                             getContainer={document.getElementById("yakit-uilayout-body") || undefined}
                             mask={false}
diff --git a/app/renderer/src/main/src/enums/engine.ts b/app/renderer/src/main/src/enums/engine.ts
index 7719755c49..0bfc4104c1 100644
--- a/app/renderer/src/main/src/enums/engine.ts
+++ b/app/renderer/src/main/src/enums/engine.ts
@@ -2,6 +2,7 @@ export enum EngineRemoteGV {
     /**
      * @name 是否启动引擎版本检查
      * 引擎插件：判断当前版本是否比软件适配版本高，如果低于适配版本则弹出引擎版本检查弹窗
+     * @deprecated 该功能已废弃, 后续别的地方使用请注意是否有老数据影响，下个版本删除
      */
     RemoteCheckEngineVersion = "remote-check-engine-version"
 }