@ttmg/cli 0.3.1-login.2 → 0.3.1-unity.10

package/dist/index.js

@@ -16,15 +16,19 @@ var axios = require('axios');
 var handlebars = require('handlebars');
 var esbuild = require('esbuild');
 var archiver = require('archiver');
-var http = require('http');
-var ttmgPack = require('ttmg-pack');
-var expressStaticGzip = require('express-static-gzip');
-var fileUpload = require('express-fileupload');
 var chokidar = require('chokidar');
 var WebSocket = require('ws');
 var glob = require('glob');
 var got = require('got');
 var FormData$1 = require('form-data');
+var http = require('http');
+var ttmgPack = require('ttmg-pack');
+var fs$1 = require('node:fs');
+var path$1 = require('node:path');
+var zlib = require('zlib');
+var promises = require('fs/promises');
+var expressStaticGzip = require('express-static-gzip');
+var fileUpload = require('express-fileupload');
 
 function _interopNamespaceDefault(e) {
   var n = Object.create(null);
@@ -43,6 +47,7 @@ function _interopNamespaceDefault(e) {
   return Object.freeze(n);
 }
 
+var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
 var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
 var os__namespace = /*#__PURE__*/_interopNamespaceDefault(os);
 var glob__namespace = /*#__PURE__*/_interopNamespaceDefault(glob);
@@ -271,7 +276,7 @@ const LOGIN_TT4D = 'https://developers.tiktok.com/passport/web/email/login';
 const params = {
     aid: '2471',
     account_sdk_source: 'web',
-    sdk_version: '2.1.6-tiktok',
+    sdk_version: '2.1.1',
 };
 const prompt = inquirer.createPromptModule();
 async function login() {
@@ -313,6 +318,7 @@ async function login() {
     const url = LOGIN_TT4D + '?' + new URLSearchParams(params);
     const headers = {
         'Content-Type': 'application/x-www-form-urlencoded',
+        'User-Agent': 'curl/8.5.0',
         Accept: '*/*',
     };
     const ora = await import('ora');
@@ -325,11 +331,9 @@ async function login() {
         const response = await axios.post(url, {
             email,
             password,
-            mix_mode: '1',
-            fixed_mix_mode: '1',
-        }, { headers, maxRedirects: 20, timeout: 20000 });
+        }, { headers, maxRedirects: 20, timeout: 30000 });
         if (response?.data?.data?.error_code) {
-            spinner$1.fail(chalk.red(`login failed: ${response.data?.data?.description}, error_code: ${response.data?.data?.error_code}`));
+            spinner$1.fail(chalk.red(`login failed: ${response.data?.data?.description || response.data?.data?.error_code}`));
             spinner$1.stop();
             process.exit(1);
         }
@@ -345,9 +349,7 @@ async function login() {
         }
     }
     catch (error) {
-        if (error?.code === 'ECONNABORTED') {
-            console.log(chalk.red('login timeout, please check your netowrk proxy setting'));
-        }
+        spinner$1.fail(chalk.red(`❌：${error.message}, please check your network, make sure your Shell can access TikTok Developer Platform， you can try by run command 'curl https://developers.tiktok.com' to check if it's accessible;\n`));
         console.log(chalk.yellow('🔔 You can follow this doc to modify your terminal network settings:'), chalk.underline.yellow('https://bytedance.larkoffice.com/wiki/ZblJwT0ZNil9jJkS8EgcFlcQnFc'));
         process.exit(1);
     }
@@ -372,16 +374,80 @@ async function request({ url, method, data, headers, params, }) {
         return {
             data: res.data,
             error: null,
+            ctx: {
+                logid: res?.headers['x-tt-logid'],
+                httpStatusCode: res?.status,
+            },
         };
     }
     catch (err) {
         // @ts-ignore
         return {
             data: null,
+            ctx: {
+                logid: err.response?.headers['x-tt-logid'],
+                httpStatusCode: err.response?.status,
+            },
             error: err.response?.data,
         };
     }
 }
+async function download(url, filePath) {
+    // 清理旧文件
+    if (fs.existsSync(filePath)) {
+        try {
+            fs.unlinkSync(filePath);
+        }
+        catch { }
+    }
+    try {
+        const res = await axios.get(url, {
+            responseType: 'stream',
+            // 让非 2xx 进入 catch
+            validateStatus: s => s >= 200 && s < 300,
+        });
+        // 关键：把“流事件”封装为 Promise，并 await 它
+        await new Promise((resolve, reject) => {
+            const writer = fs.createWriteStream(filePath);
+            const onError = (e) => {
+                cleanup();
+                try {
+                    if (fs.existsSync(filePath))
+                        fs.unlinkSync(filePath);
+                }
+                catch { }
+                reject(e);
+            };
+            const onClose = () => {
+                cleanup();
+                resolve();
+            };
+            const cleanup = () => {
+                writer.off('error', onError);
+                writer.off('close', onClose);
+                res.data.off('error', onError);
+            };
+            res.data.on('error', onError);
+            writer.on('error', onError);
+            writer.on('close', onClose);
+            res.data.pipe(writer);
+        });
+        // 成功
+        return { ok: true };
+    }
+    catch (err) {
+        // 403 等受控处理
+        if (isAxiosError(err) && err.response?.status === 403) {
+            // 不抛出，让上层自行决定
+            throw new Error('下载链接已过期，请重新进行分包后重试');
+        }
+        // 其他错误抛出或返回
+        throw err;
+    }
+}
+function isAxiosError(e) {
+    return !!e?.isAxiosError;
+}
 
 async function fetchGameInfo(clientKey) {
     if (clientKey?.startsWith('sb')) {
@@ -398,7 +464,7 @@ async function fetchGameInfo(clientKey) {
             params: {
                 client_key: clientKey,
                 // version_type: 1,
-            }
+            },
         });
         const gameInfo = response?.data?.mini_game;
         if (!gameInfo) {
@@ -567,6 +633,12 @@ function getCurrentUser() {
     }
 }
 
+function ensureDirSync(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
+}
+
 function buildOpenContext(sourcePath) {
     const result = esbuild.buildSync({
         entryPoints: [sourcePath],
@@ -843,14 +915,80 @@ function getDesktopPath() {
     return defaultPath;
 }
 
-function getDevToolVersion() {
-    try {
-        return JSON.parse(fs.readFileSync(path.join(__dirname, 'package.json'), 'utf8')).version;
+/**
+ * 一个类型安全的、通用的事件发射器类。
+ * 它允许你注册、注销和触发具有严格类型检查的事件。
+ */
+class TypedEventEmitter {
+    constructor() {
+        // 使用 Map 存储事件监听器。
+        // Key 是事件名，Value 是一个 Set，其中包含该事件的所有监听器函数。
+        // 使用 Set 可以自动防止同一个监听器被重复注册。
+        this.listeners = new Map();
     }
-    catch (error) {
-        return 'unknown';
+    /**
+     * 注册一个事件监听器。
+     * @param eventName 要监听的事件名称。
+     * @param listener 事件触发时执行的回调函数。
+     * @returns 返回一个函数，调用该函数即可注销此监听器，方便使用。
+     */
+    on(eventName, listener) {
+        if (!this.listeners.has(eventName)) {
+            this.listeners.set(eventName, new Set());
+        }
+        this.listeners.get(eventName).add(listener);
+        // 返回一个便捷的取消订阅函数
+        return () => this.off(eventName, listener);
+    }
+    /**
+     * 注销一个事件监听器。
+     * @param eventName 要注销的事件名称。
+     * @param listener 之前通过 on() 方法注册的回调函数实例。
+     */
+    off(eventName, listener) {
+        const eventListeners = this.listeners.get(eventName);
+        if (eventListeners) {
+            eventListeners.delete(listener);
+            if (eventListeners.size === 0) {
+                this.listeners.delete(eventName);
+            }
+        }
+    }
+    /**
+     * 触发一个事件，并同步调用所有相关的监听器。
+     * @param eventName 要触发的事件名称。
+     * @param payload 传递给所有监听器的数据。类型必须与事件定义匹配。
+     */
+    emit(eventName, payload) {
+        const eventListeners = this.listeners.get(eventName);
+        if (eventListeners) {
+            // 遍历 Set 并执行每一个监听器
+            eventListeners.forEach(listener => {
+                try {
+                    // 在独立的 try...catch 中调用，防止一个监听器的错误影响其他监听器
+                    listener(payload);
+                }
+                catch (error) {
+                    console.error(`Error in listener for event "${String(eventName)}":`, error);
+                }
+            });
+        }
+    }
+    /**
+     * 注销指定事件的所有监听器。
+     * @param eventName 要清除监听器的事件名称。
+     */
+    removeAllListeners(eventName) {
+        this.listeners.delete(eventName);
+    }
+    /**
+     * 清空所有事件的所有监听器。
+     */
+    clearAll() {
+        this.listeners.clear();
     }
 }
+const eventEmitter = new TypedEventEmitter();
 
 const DEV_PORT = 3000;
 const DEV_WS_PORT = 4000;
@@ -865,20 +1003,8 @@ const NATIVE_GAME_ENTRY_FILES = [
     'game.json',
     'project.config.json',
 ];
-
-/**
- * 获取 Client Key（选择或输入）
- */
-function getClientKey() {
-    return {
-        clientKey: getTTMGRC()?.clientKey || '',
-    };
-}
-
-function getOutputDir() {
-    const { clientKey } = getClientKey();
-    return path.join(os.homedir(), '__TTMG__', clientKey);
-}
+const SUBAPCKAGE_FILED_NAMES = ['subpackages', 'subPackages'];
+const SUBPACKAGE_CONFIG_FILE_NAME = 'game.json';
 
 // store.ts
 class Store {
@@ -939,967 +1065,2148 @@ const store = Store.getInstance({
     checkResults: [],
 });
 
-function showTips(context) {
-    console.log(chalk.gray('─────────────────────────────────────────────'));
-    console.log(chalk.yellow.bold('1.') +
-        ' The QR code page will be opened automatically in Chrome.');
-    console.log('   If it fails, please open the following link manually:');
-    console.log('   ' + chalk.cyan.underline(context.server));
-    console.log('');
-    console.log(chalk.yellow.bold('2.') +
-        ' The debugging service will automatically compile your game assets.');
-    console.log('   Any changes in your game directory will trigger recompilation.');
-    console.log('   You can debug the updated content when upload is completed.');
-    console.log('');
-    console.log(chalk.yellow.bold('3.') +
-        ' After scanning the QR code with your phone for Test User authentication,');
-    console.log('   the compiled code package will be uploaded to the client automatically.');
-    console.log('   Game debugging will start right away.');
-    console.log(chalk.gray('─────────────────────────────────────────────'));
-}
-
-function getLocalIPs() {
-    // 有线网卡关键词（Windows/macOS 常见 + 一些 Linux 命名）
-    const WIRED_KEYWORDS = [
-        'ethernet',
-        '以太网',
-        '本地连接',
-        'en',
-        'lan',
-        'enp',
-        'eno', // en0/en1, enp0s3...
-    ];
-    // 无线网卡关键词（Windows/macOS 常见 + 一些 Linux 命名）
-    const WIRELESS_KEYWORDS = [
-        'wi-fi',
-        'wifi',
-        '无线',
-        '无线网络连接',
-        'wlan',
-        'wlp',
-        'wl',
-        'airport', // 老旧 macOS/工具里偶见
-    ];
-    // 虚拟/隧道/容器/桥接等常见关键词
-    const VIRTUAL_INTERFACE_KEYWORDS = [
-        'vmware',
-        'virtual',
-        'docker',
-        'vbox',
-        'br-',
-        'bridge',
-        'tun',
-        'tap',
-        'hamachi',
-        'vEthernet',
-        'vnic',
-        'utun',
-        'hyper-v',
-        'loopback',
-        'lo',
-        'ppp',
-        'tailscale',
-        'zerotier',
-        'npcap',
-        'npf',
-        'wg',
-        'wireguard',
-        'anyconnect',
-        'teleport',
-    ];
-    // 判断是否为物理网卡（基于名称的启发式）
-    function isPhysicalInterface(name) {
-        const lower = name.toLowerCase();
-        return (WIRED_KEYWORDS.some(k => lower.includes(k)) ||
-            WIRELESS_KEYWORDS.some(k => lower.includes(k)));
-    }
-    // 判断是否为虚拟/隧道接口
-    function isVirtualInterface(name) {
-        const lower = name.toLowerCase();
-        return VIRTUAL_INTERFACE_KEYWORDS.some(k => lower.includes(k));
-    }
-    // 判断局域网私有 IPv4
-    function isPrivateIPv4(ip) {
-        return (ip.startsWith('10.') ||
-            ip.startsWith('192.168.') ||
-            /^172\.(1[6-9]|2\d|3[01])\./.test(ip));
-    }
-    // 兼容不同 Node 版本中 family 的类型（'IPv4' | 4）
-    function isIPv4Family(f) {
-        return f === 4 || f === 'IPv4';
+class WsServer {
+    constructor() {
+        this.startWsServer(store.getState().nodeWsPort);
     }
-    const nets = os.networkInterfaces();
-    const results = [];
-    for (const name of Object.keys(nets)) {
-        const addrs = nets[name] || [];
-        // 先粗略排除明显虚拟接口
-        if (isVirtualInterface(name))
-            continue;
-        // 需要看地址再判断是否物理
-        // 有些系统的命名不标准，允许在地址层面兜底
-        let matchedPhysicalName = isPhysicalInterface(name);
-        for (const net of addrs) {
-            if (!isIPv4Family(net.family))
-                continue;
-            if (net.internal)
-                continue;
-            if (!net.address || !isPrivateIPv4(net.address))
-                continue;
-            // 若名称判断不通过，但地址是私有网段、且非回环/非内网，考虑接纳
-            // 但排除明显虚拟（已经在上面过滤 name）
-            if (matchedPhysicalName || shouldAcceptByHeuristic(name, net.address)) {
-                results.push({ name, address: net.address });
+    startWsServer(port) {
+        this.ws = new WebSocket.Server({ port });
+        this.ws.on('connection', ws => {
+            const { clientHttpPort, clientHost, clientWsPort } = store.getState();
+            if (clientHost) {
+                this.send({
+                    method: 'clientDebugInfo',
+                    payload: {
+                        clientHttpPort,
+                        clientHost,
+                        clientWsPort,
+                    },
+                });
             }
-        }
-    }
-    // 去重（同名+同地址）
-    const unique = dedupe(results);
-    // 稳定排序：无线优先 or 有线优先按需定。这里有线优先，再无线，再其他。
-    unique.sort((a, b) => {
-        const rank = (n) => {
-            const lower = n.toLowerCase();
-            if (WIRED_KEYWORDS.some(k => lower.includes(k)))
-                return 0;
-            if (WIRELESS_KEYWORDS.some(k => lower.includes(k)))
-                return 1;
-            return 2;
-        };
-        const ra = rank(a.name);
-        const rb = rank(b.name);
-        if (ra !== rb)
-            return ra - rb;
-        // 同级按名称自然排序
-        return a.name.localeCompare(b.name, undefined, { numeric: true });
+            ws.on('message', message => {
+                /** 客户端发送的消息 */
+                const clientMessage = JSON.parse(message.toString());
+                const from = clientMessage.from;
+                if (from === 'browser') {
+                    // console.log(chalk.yellow.bold('Browser message'), clientMessage);
+                    const method = clientMessage.method;
+                    switch (method) {
+                        case 'manualConnect': {
+                            const { clientHttpPort, clientHost, clientWsPort } = clientMessage.payload;
+                            store.setState({
+                                clientHttpPort,
+                                clientHost,
+                                clientWsPort,
+                                clientWsHost: clientHost,
+                            });
+                            break;
+                        }
+                        case 'startUpload':
+                            eventEmitter.emit('startUpload', {});
+                            break;
+                        case 'closeLocalDebug':
+                            console.log('closeLocalDebug');
+                            /**
+                             * 关闭调试服务
+                             */
+                            this.ws.close();
+                            break;
+                    }
+                }
+                else {
+                    const method = clientMessage.method;
+                    switch (method) {
+                        /**
+                         * 客户端完成扫码成功，返回客户端的 host 和 port
+                         */
+                        case 'startScanQRcode': {
+                            const payload = clientMessage.payload;
+                            console.log('startQRcode', payload);
+                            this.send({
+                                method: 'startScanQRcode',
+                            });
+                            break;
+                        }
+                        case 'scanQRCodeResult': {
+                            const payload = clientMessage.payload || {};
+                            const { host, port, wsPort, errMsg, isSuccess } = payload;
+                            console.log('scanQRCodeResult', payload);
+                            if (isSuccess) {
+                                store.setState({
+                                    clientHttpPort: port,
+                                    clientHost: host,
+                                    clientWsPort: wsPort,
+                                });
+                                this.send({
+                                    method: 'scanQRCodeSuccess',
+                                    payload: {
+                                        clientHttpPort: port,
+                                        clientHost: host,
+                                        clientWsPort: wsPort,
+                                    },
+                                });
+                                console.log('scanQRcodeSuccess');
+                            }
+                            else {
+                                this.send({
+                                    method: 'scanQRCodeFailed',
+                                    payload: {
+                                        errMsg,
+                                    },
+                                });
+                            }
+                            break;
+                        }
+                        // 手动绑定客户端调试服务
+                        // 待废弃
+                        case 'shareDevParams':
+                            const payload = clientMessage.payload;
+                            const { host, port, wsPort } = payload;
+                            store.setState({
+                                clientHttpPort: port,
+                                clientHost: host,
+                                clientWsPort: wsPort,
+                                clientWsHost: host,
+                            });
+                            this.send({
+                                method: 'scanQRCodeSuccess',
+                                payload: {
+                                    clientHttpPort: port,
+                                    clientHost: host,
+                                    clientWsPort: wsPort,
+                                },
+                            });
+                            break;
+                    }
+                }
+            });
+        });
+        this.ws.on('error', err => {
+            if (err.code === 'EADDRINUSE') {
+                store.setState({
+                    nodeWsPort: store.getState().nodeWsPort + 1,
+                });
+                this.startWsServer(store.getState().nodeWsPort);
+            }
+            else {
+                console.log(chalk.red.bold(err.message));
+                process.exit(1);
+            }
+        });
+    }
+    send(params) {
+        this.ws.clients.forEach(client => {
+            if (client.readyState === WebSocket.OPEN) {
+                const data = {
+                    ...params,
+                    from: 'nodeServer',
+                };
+                client.send(JSON.stringify(data));
+            }
+        });
+    }
+    sendResourceChange() {
+        this.send({
+            method: 'resourceChange',
+        });
+    }
+    sendCompilationStatus(status, payload) {
+        this.send({
+            method: 'compilationStatus',
+            payload: {
+                status,
+                ...payload,
+            },
+        });
+    }
+    close() {
+        this.ws.close();
+    }
+    sendUnitySplitStatus(payload) {
+        this.send({
+            method: 'unitySplitStatus',
+            payload,
+        });
+    }
+    sendUploadStatus(status, payload) {
+        this.send({
+            method: 'uploadStatus',
+            status,
+            payload,
+        });
+    }
+}
+const wsServer = new WsServer();
+
+/**
+ * 获取 Client Key（选择或输入）
+ */
+function getClientKey() {
+    return {
+        clientKey: getTTMGRC()?.clientKey || '',
+    };
+}
+
+function getOutputDir() {
+    const { clientKey } = getClientKey();
+    return path.join(os.homedir(), '__TTMG__', clientKey);
+}
+
+async function compile(context) {
+    // const { openDataContext } = getOpenContextConfig();
+    // if (!!openDataContext) {
+    //   buildOpenContextToFile(openDataContext);
+    // }
+    const entryDir = process.cwd();
+    const outputDir = getOutputDir();
+    const { clientKey, msg } = getClientKey();
+    if (!clientKey) {
+        if (context?.mode !== 'watch') {
+            console.log(chalk.red.bold(msg));
+            process.exit(1);
+        }
+        console.log(chalk.red.bold(msg));
+    }
+    const startTip = context?.mode === 'watch'
+        ? '🔔 Watching game assets for local debugging...'
+        : '🚀 Compiling game assets for local debugging...';
+    console.log(chalk.bold.cyan(startTip));
+    wsServer.sendCompilationStatus('start');
+    store.setState({
+        isUnderCompiling: true,
     });
-    return unique.map(item => item.address);
-    // 兜底启发式：如果名字不明显，但常见物理命名模式且 IP 为私网，接受
-    function shouldAcceptByHeuristic(name, ip) {
-        name.toLowerCase();
-        // macOS: en0/en1
-        if (/^en\d+$/i.test(name))
-            return true;
-        // Linux: enpXsY / enoX / wlpXsY
-        if (/^(enp|eno|wlp)\w+$/i.test(name))
-            return true;
-        // Windows: 以太网 / Wi-Fi（非虚拟已过滤）
-        if (/(以太网|本地连接|wi-?fi|无线)/.test(name))
-            return true;
-        return false;
+    return new Promise((resolve, reject) => {
+        const worker = new worker_threads.Worker(path.resolve(__dirname, './scripts/worker.js'));
+        worker.on('message', msg => {
+            if (msg.type === 'status' && msg.status === 'end') {
+                const { isSuccess, errorMsg, packages } = msg;
+                if (!isSuccess) {
+                    store.setState({
+                        isUnderCompiling: false,
+                    });
+                    wsServer.sendCompilationStatus('end', {
+                        errorMsg,
+                        isSuccess: false,
+                    });
+                    console.log(chalk.red.bold(errorMsg));
+                }
+                else {
+                    store.setState({
+                        isUnderCompiling: false,
+                        packages,
+                    });
+                    /**
+                     * 编译成功后，需要触发上传
+                     */
+                    eventEmitter.emit('compileSuccess', {});
+                    wsServer.sendCompilationStatus('end', {
+                        isSuccess: true,
+                    });
+                    console.log(chalk.green.bold('✔ Game resources compiled successfully!'));
+                    resolve(msg); // 编译结束，返回结果
+                }
+                worker.terminate();
+            }
+            else if (msg.type === 'error') {
+                reject(msg.error);
+                worker.terminate();
+            }
+        });
+        worker.on('error', err => {
+            console.log(chalk.red.bold(err.message));
+            reject(err);
+            worker.terminate();
+        });
+        worker.postMessage({
+            type: 'compile',
+            context: {
+                clientKey,
+                outputDir,
+                devPort: store.getState().nodeServerPort,
+                entryDir,
+            },
+        });
+    });
+}
+
+// import { uploadGame } from './uploadGame';
+async function watch() {
+    let debounceTimer = null;
+    // 监听当前工作目录，排除 node_modules 和 .git
+    const watcher = chokidar.watch(process.cwd(), {
+        /**
+         * 忽略 wasmcode/cache 目录
+         */
+        ignored: /(^|[\/\\])(\.git|node_modules|__TTMG_TEMP__)/, // 忽略 .git 和 node_modules
+        ignoreInitial: true, // 忽略初始添加事件
+        persistent: true,
+        awaitWriteFinish: {
+            stabilityThreshold: 1000,
+        },
+    });
+    // 任意文件变化都触发
+    watcher.on('all', (event, path) => {
+        // 清除之前的定时器
+        if (debounceTimer)
+            clearTimeout(debounceTimer);
+        // 重新设置定时器
+        debounceTimer = setTimeout(async () => {
+            (await compile({
+                mode: 'watch',
+            }),
+                wsServer.sendResourceChange());
+            debounceTimer = null;
+        }, 2000);
+    });
+    watcher.on('error', error => {
+        // console.error(chalk.red('[watch] 监听发生错误:'), error);
+    });
+}
+
+let spinner;
+async function uploadGame(callback) {
+    const ora = await import('ora');
+    spinner = ora.default({
+        text: chalk.cyan.bold('Uploading game assets to client...'),
+        spinner: 'dots',
+    });
+    spinner.start();
+    const outputDir = getOutputDir();
+    callback({
+        status: 'start',
+        percent: 0,
+    });
+    const zipPath = path.join(os.homedir(), '__TTMG__', 'upload.zip');
+    await zipDirectory(outputDir, zipPath);
+    await uploadZip(zipPath, callback);
+}
+/**
+ * 复制源目录内容到临时目录，然后根据 glob 模式过滤并压缩文件。
+ * 原始目录保持不变。
+ *
+ * @param sourceDir - 要压缩的源文件夹路径。
+ * @param outPath - 输出的 zip 文件路径。
+ */
+async function zipDirectory(sourceDir, outPath) {
+    const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'zip-temp-'));
+    try {
+        // 2. 将源目录的所有内容复制到临时目录
+        await fs.promises.cp(sourceDir, tempDir, { recursive: true });
+        // 3. 对临时目录进行压缩
+        const output = fs.createWriteStream(outPath);
+        const archive = archiver('zip', { zlib: { level: 9 } });
+        // 使用 Promise 包装流操作
+        const archivePromise = new Promise((resolve, reject) => {
+            output.on('close', () => {
+                resolve();
+            });
+            archive.on('warning', err => console.warn('Archiver warning:', err));
+            output.on('error', err => reject(err));
+            archive.on('error', err => reject(err));
+        });
+        archive.pipe(output);
+        // 4. 使用 glob 在临时目录中查找文件，并应用过滤规则
+        const files = await glob__namespace.glob('**/*', {
+            cwd: tempDir,
+            nodir: true,
+            ignore: ['**/*.js.map', '**/*.d.ts', '__TTMG_TEMP__/**'],
+        });
+        // 5. 将过滤后的文件逐个添加到压缩包
+        for (const file of files) {
+            const filePath = path.join(tempDir, file);
+            archive.file(filePath, { name: file });
+        }
+        // 6. 完成压缩
+        await archive.finalize();
+        // 等待文件流关闭
+        await archivePromise;
+    }
+    catch (err) {
+        console.error('压缩过程中发生错误:', err);
+        throw err;
+    }
+    finally {
+        // 7. 无论成功还是失败，都清理临时目录
+        await fs.promises.rm(tempDir, { recursive: true, force: true });
+    }
+}
+async function uploadZip(zipPath, callback) {
+    const startTime = Date.now();
+    const form = new FormData$1();
+    form.append('file', fs.createReadStream(zipPath), {
+        filename: 'upload.zip',
+        contentType: 'application/zip',
+    });
+    // 帮我计算下文件大小，变成 MB 为单位
+    const fileSize = fs.statSync(zipPath).size / 1024 / 1024;
+    spinner.text = chalk.cyan.bold(`Start upload Game assets to client, size: ${fileSize.toFixed(2)} MB`);
+    const { clientHttpPort, clientHost } = store.getState();
+    const url = `http://${clientHost}:${clientHttpPort}/game/upload`;
+    try {
+        // 1. 创建请求流
+        const stream = got.stream.post(url, {
+            body: form,
+        });
+        const handleProgress = progress => {
+            const percent = progress.percent;
+            // const transferred = progress.transferred;
+            // const total = progress.total;
+            spinner.text = chalk.cyan.bold(`Uploading game assets to client... ${(percent * 100).toFixed(0)}%`);
+            callback({
+                status: 'process',
+                percent,
+            });
+        };
+        stream.on('uploadProgress', handleProgress);
+        const chunks = [];
+        // 当流传输数据时，收集数据块
+        stream.on('data', chunk => {
+            chunks.push(chunk);
+        });
+        // 当流成功结束时
+        stream.on('end', () => {
+            spinner.succeed(chalk.green.bold(`Upload game assets to client success! Cost: ${Date.now() - startTime}ms`));
+            callback({
+                status: 'success',
+                percent: 1,
+            });
+        });
+        // 当流发生错误时
+        stream.on('error', err => {
+            stream.off('uploadProgress', handleProgress);
+            spinner.fail(chalk.red.bold(`Upload failed with error: ${err.message}, please check current debug env and try to scan qrcode to reupload again.`));
+            callback({
+                status: 'error',
+                percent: 0,
+                msg: err.message,
+            });
+        });
     }
-    function dedupe(arr) {
-        const seen = new Set();
-        const out = [];
-        for (const item of arr) {
-            const key = `${item.name}|${item.address}`;
-            if (!seen.has(key)) {
-                seen.add(key);
-                out.push(item);
-            }
-        }
-        return out;
+    catch (err) {
+        callback({
+            status: 'error',
+            percent: 0,
+            msg: err?.message,
+        });
+        process.stdout.write('\n');
+        console.log('\n');
+        console.error(chalk.red.bold('✖ Upload failed with server error, please scan qrcode to reupload'));
     }
 }
 
-const successCode = 0;
-const errorCode = -1;
-const outputDir = getOutputDir();
-const publicPath = path.join(__dirname, 'public');
-const devToolVersion = getDevToolVersion();
-async function start() {
-    const startTime = Date.now();
-    const app = express();
-    app.use(fileUpload()); // 启用 express-fileupload 中间件
-    // --- 中间件和路由设置 ---
-    app.use(expressStaticGzip(publicPath, {
-        enableBrotli: true,
-        orderPreference: ['br'],
-    }));
-    app.use((req, res, next) => {
-        res.header('Access-Control-Allow-Origin', '*');
-        res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
-        res.header('Cache-Control', 'no-cache, no-store, must-revalidate');
-        res.header('Pragma', 'no-cache');
-        res.header('Expires', '0');
-        res.header('Access-Control-Allow-Headers', 'Content-Type, Authorization');
-        next();
-    });
-    app.use(express.json());
-    app.use(express.urlencoded({ extended: true }));
-    app.use('/game/files', express.static(outputDir));
-    app.get('/game/config', async (req, res) => {
-        const basic = await ttmgPack.getPkgs({ entryDir: process.cwd() });
-        const user = getCurrentUser();
-        const { clientKey } = getClientKey();
-        res.send({
-            error: null,
-            data: {
-                user,
-                code: successCode,
-                nodeWsPort: store.getState().nodeWsPort,
-                clientKey: clientKey,
-                schema: `https://www.tiktok.com/ttmg/dev/${clientKey}?host=${getLocalIP()}&port=${store.getState().nodeWsPort}&host_list=${encodeURIComponent(JSON.stringify(getLocalIPs()))}`,
-                ...basic,
-                devToolVersion,
-            },
-        });
-    });
-    app.get('/game/detail', async (req, res) => {
-        const basic = await ttmgPack.getPkgs({ entryDir: process.cwd() });
-        const { clientKey } = getClientKey();
-        const { error, data: gameInfo } = await fetchGameInfo(clientKey);
-        store.setState({
-            appId: gameInfo?.app_id,
-            sandboxId: gameInfo?.sandbox_info?.sandbox_id,
-        });
-        if (error) {
-            res.send({ error, data: null });
+function listen() {
+    eventEmitter.on('startUpload', () => {
+        /**
+         * 如果还在编译中，需要等到编译结束再上传
+         */
+        if (store.getState().isUnderCompiling) {
+            store.setState({
+                isWaitingForUpload: true,
+            });
             return;
         }
-        else {
-            res.send({ error: null, data: { ...basic, ...gameInfo } });
-        }
-    });
-    app.get('/game/check', async (req, res) => {
-        const checkResult = await ttmgPack.checkPkgs({
-            entryDir: process.cwd(),
-            config: {
-                entry: process.cwd(),
-                output: outputDir,
-                dev: {
-                    enable: true,
-                    port: store.getState().nodeServerPort,
-                    host: 'localhost',
-                    enableSourcemap: false,
-                    enableLog: false,
-                },
-                build: {
-                    enableOdr: false,
-                    enableAPICheck: true,
-                    ...PKG_SIZE_LIMIT,
-                },
-            },
+        wsServer.sendUploadStatus('start');
+        uploadGame(({ status, percent, msg }) => {
+            if (status === 'process') {
+                wsServer.sendUploadStatus('process', {
+                    status: 'process',
+                    progress: percent,
+                });
+            }
+            else if (status === 'error') {
+                wsServer.sendUploadStatus('error', {
+                    status: 'error',
+                    errMsg: msg,
+                    isSuccess: false,
+                });
+            }
+            else if (status === 'success') {
+                wsServer.sendUploadStatus('success', {
+                    status: 'success',
+                    packages: store.getState().packages,
+                    clientKey: getClientKey().clientKey,
+                    isSuccess: true,
+                });
+            }
         });
-        res.send({ code: successCode, data: checkResult });
     });
-    /**
-     * @description 上传游戏代码到服务器
-     */
-    app.post('/game/upload', async (req, res) => {
-        const fileKeys = Object.keys(req.files);
-        const uploadedFile = req.files[fileKeys[0]];
-        if (!uploadedFile) {
-            res.status(400).send({ code: errorCode, data: 'No file uploaded' }); // 使用正确的 HTTP 状态码
-            return;
-        }
-        try {
-            // 通过 header 获取 desc
-            const desc = req.headers['ttmg-game-desc'];
-            // 需要做 decodeURIComponent 处理
-            const decodedDesc = decodeURIComponent(desc || '--');
-            // 直接传递需要的信息
-            const { data, error } = await uploadGameToPlatform({
-                data: uploadedFile.data, // 这是 Buffer
-                name: uploadedFile.name, // 这是文件名
-                clientKey: getClientKey().clientKey,
-                note: decodedDesc,
-                appId: store.getState().appId,
-                sandboxId: store.getState().sandboxId,
+    eventEmitter.on('compileSuccess', () => {
+        /**
+         * 如果有等待上传的任务，需要触发上传
+         */
+        if (store.getState().isWaitingForUpload) {
+            eventEmitter.emit('startUpload', {});
+            store.setState({
+                isWaitingForUpload: false,
             });
-            if (error) {
-                res.send({ code: errorCode, error });
-            }
-            else {
-                res.send({ code: successCode, data });
+        }
+    });
+}
+
+function getLocalIPs() {
+    // 有线网卡关键词（Windows/macOS 常见 + 一些 Linux 命名）
+    const WIRED_KEYWORDS = [
+        'ethernet',
+        '以太网',
+        '本地连接',
+        'en',
+        'lan',
+        'enp',
+        'eno', // en0/en1, enp0s3...
+    ];
+    // 无线网卡关键词（Windows/macOS 常见 + 一些 Linux 命名）
+    const WIRELESS_KEYWORDS = [
+        'wi-fi',
+        'wifi',
+        '无线',
+        '无线网络连接',
+        'wlan',
+        'wlp',
+        'wl',
+        'airport', // 老旧 macOS/工具里偶见
+    ];
+    // 虚拟/隧道/容器/桥接等常见关键词
+    const VIRTUAL_INTERFACE_KEYWORDS = [
+        'vmware',
+        'virtual',
+        'docker',
+        'vbox',
+        'br-',
+        'bridge',
+        'tun',
+        'tap',
+        'hamachi',
+        'vEthernet',
+        'vnic',
+        'utun',
+        'hyper-v',
+        'loopback',
+        'lo',
+        'ppp',
+        'tailscale',
+        'zerotier',
+        'npcap',
+        'npf',
+        'wg',
+        'wireguard',
+        'anyconnect',
+        'teleport',
+    ];
+    // 判断是否为物理网卡（基于名称的启发式）
+    function isPhysicalInterface(name) {
+        const lower = name.toLowerCase();
+        return (WIRED_KEYWORDS.some(k => lower.includes(k)) ||
+            WIRELESS_KEYWORDS.some(k => lower.includes(k)));
+    }
+    // 判断是否为虚拟/隧道接口
+    function isVirtualInterface(name) {
+        const lower = name.toLowerCase();
+        return VIRTUAL_INTERFACE_KEYWORDS.some(k => lower.includes(k));
+    }
+    // 判断局域网私有 IPv4
+    function isPrivateIPv4(ip) {
+        return (ip.startsWith('10.') ||
+            ip.startsWith('192.168.') ||
+            /^172\.(1[6-9]|2\d|3[01])\./.test(ip));
+    }
+    // 兼容不同 Node 版本中 family 的类型（'IPv4' | 4）
+    function isIPv4Family(f) {
+        return f === 4 || f === 'IPv4';
+    }
+    const nets = os.networkInterfaces();
+    const results = [];
+    for (const name of Object.keys(nets)) {
+        const addrs = nets[name] || [];
+        // 先粗略排除明显虚拟接口
+        if (isVirtualInterface(name))
+            continue;
+        // 需要看地址再判断是否物理
+        // 有些系统的命名不标准，允许在地址层面兜底
+        let matchedPhysicalName = isPhysicalInterface(name);
+        for (const net of addrs) {
+            if (!isIPv4Family(net.family))
+                continue;
+            if (net.internal)
+                continue;
+            if (!net.address || !isPrivateIPv4(net.address))
+                continue;
+            // 若名称判断不通过，但地址是私有网段、且非回环/非内网，考虑接纳
+            // 但排除明显虚拟（已经在上面过滤 name）
+            if (matchedPhysicalName || shouldAcceptByHeuristic(name, net.address)) {
+                results.push({ name, address: net.address });
             }
         }
-        catch (error) {
-            // 错误处理可以更具体
-            let errorMessage = 'An unknown error occurred.';
-            if (error instanceof Error) {
-                errorMessage = error.message;
+    }
+    // 去重（同名+同地址）
+    const unique = dedupe(results);
+    // 稳定排序：无线优先 or 有线优先按需定。这里有线优先，再无线，再其他。
+    unique.sort((a, b) => {
+        const rank = (n) => {
+            const lower = n.toLowerCase();
+            if (WIRED_KEYWORDS.some(k => lower.includes(k)))
+                return 0;
+            if (WIRELESS_KEYWORDS.some(k => lower.includes(k)))
+                return 1;
+            return 2;
+        };
+        const ra = rank(a.name);
+        const rb = rank(b.name);
+        if (ra !== rb)
+            return ra - rb;
+        // 同级按名称自然排序
+        return a.name.localeCompare(b.name, undefined, { numeric: true });
+    });
+    return unique.map(item => item.address);
+    // 兜底启发式：如果名字不明显，但常见物理命名模式且 IP 为私网，接受
+    function shouldAcceptByHeuristic(name, ip) {
+        name.toLowerCase();
+        // macOS: en0/en1
+        if (/^en\d+$/i.test(name))
+            return true;
+        // Linux: enpXsY / enoX / wlpXsY
+        if (/^(enp|eno|wlp)\w+$/i.test(name))
+            return true;
+        // Windows: 以太网 / Wi-Fi（非虚拟已过滤）
+        if (/(以太网|本地连接|wi-?fi|无线)/.test(name))
+            return true;
+        return false;
+    }
+    function dedupe(arr) {
+        const seen = new Set();
+        const out = [];
+        for (const item of arr) {
+            const key = `${item.name}|${item.address}`;
+            if (!seen.has(key)) {
+                seen.add(key);
+                out.push(item);
             }
-            // 打印详细错误到服务器日志，方便排查
-            res.status(500).send({ code: errorCode, data: errorMessage }); // 使用正确的 HTTP 状态码
         }
-    });
-    app.get('*', (req, res) => {
-        res.sendFile(path.join(publicPath, `index.html`));
-    });
-    // --- 中间件和路由设置结束 ---
-    // 步骤 2: 用配置好的 app 实例创建一个 http.Server。我们只创建这一次！
-    const server = http.createServer(app);
-    /**
-     * @description 尝试在指定端口启动服务。这是个纯粹的辅助函数。
-     * @param {number} port - 要尝试的端口号。
-     * @returns {Promise<boolean>} 成功返回 true，因端口占用失败则返回 false。
-     */
-    function tryListen(port) {
-        return new Promise(resolve => {
-            // 定义错误处理函数
-            const onError = err => {
-                // 清理掉另一个事件的监听器，防止内存泄漏
-                server.removeListener('listening', onListening);
-                if (err.code === 'EADDRINUSE') {
-                    console.log(chalk(`Port ${port} is already in use, trying ${port + 1}...`));
-                    resolve(false); // 明确表示因端口占用而失败
-                }
-                else {
-                    // 对于其他致命错误，直接退出进程
-                    console.log(chalk.red.bold(err.message));
-                    process.exit(1);
-                }
-            };
-            // 定义成功处理函数
-            const onListening = () => {
-                // 清理掉另一个事件的监听器
-                server.removeListener('error', onError);
-                resolve(true); // 明确表示成功
-            };
-            // 使用 .once() 来确保监听器只执行一次然后自动移除
-            server.once('error', onError);
-            server.once('listening', onListening);
-            // 执行监听动作
-            server.listen(port);
-        });
+        return out;
     }
-    // 步骤 3: 使用循环来线性、串行地尝试启动服务
-    let isListening = false;
-    const maxRetries = 20; // 设置一个最大重试次数，以防万一
-    for (let i = 0; i < maxRetries; i++) {
-        const currentPort = store.getState().nodeServerPort;
-        isListening = await tryListen(currentPort);
-        if (isListening) {
-            break; // 成功，跳出循环
+}
+
+async function init() {
+    const promptModule = inquirer.createPromptModule();
+    const { clientKey: lastUsedClientKey } = getTTMGRC() || {};
+    if (lastUsedClientKey) {
+        const { selectedClientKey } = await promptModule([
+            {
+                type: 'list',
+                name: 'selectedClientKey',
+                message: 'Select game client key for debugging:',
+                choices: [{
+                        name: `${lastUsedClientKey} (last used)`,
+                        value: lastUsedClientKey,
+                    }, {
+                        name: 'Add a new client key',
+                        value: 'new',
+                    }],
+            },
+        ]);
+        if (selectedClientKey === 'new') {
+            /**
+             * 输入新的 clientKey
+             */
+            const { clientKey } = await promptModule([
+                {
+                    type: 'input',
+                    name: 'clientKey',
+                    message: 'Input new client key:',
+                    validate: input => {
+                        if (!input) {
+                            return 'Client key is required, please input client key';
+                        }
+                        return true;
+                    },
+                },
+            ]);
+            setTTMGRC({
+                clientKey,
+            });
         }
         else {
-            // 失败（端口占用），更新端口号，准备下一次循环
-            store.setState({ nodeServerPort: currentPort + 1 });
+            // 并将 selectedClientKey 放到最前面
+            setTTMGRC({
+                clientKey: selectedClientKey,
+            });
         }
     }
-    // 步骤 4: 检查最终结果，如果所有尝试都失败了，则退出
-    if (!isListening) {
-        console.log(chalk.red.bold(`Failed to start server after trying ${maxRetries} ports.`));
-        process.exit(1);
+    else {
+        // 没有历史 clientKey，直接输入新的 clientKey
+        const { clientKey } = await promptModule([
+            {
+                type: 'input',
+                name: 'clientKey',
+                message: 'Input your Client Key:',
+                validate: input => {
+                    if (!input) {
+                        return 'Client key is required, please input client key';
+                    }
+                    return true;
+                },
+            },
+        ]);
+        setTTMGRC({
+            clientKey,
+        });
     }
-    // --- 服务启动成功后的逻辑 ---
-    // @ts-ignore
-    const finalPort = server.address().port; // 从成功的 server 实例安全地获取最终端口
-    console.log(chalk.green.bold(`TTMG`), chalk.green(`v${devToolVersion}`), chalk.gray(`ready in`), chalk.bold(`${Date.now() - startTime}ms`));
-    const baseUrl = `http://localhost:${finalPort}?v=${devToolVersion}`;
-    showTips({ server: baseUrl });
-    openUrl(baseUrl);
 }
 
 /**
- * 一个类型安全的、通用的事件发射器类。
- * 它允许你注册、注销和触发具有严格类型检查的事件。
+ * 检查当前目录是否为 Mini Game 项目的入口目录
  */
-class TypedEventEmitter {
-    constructor() {
-        // 使用 Map 存储事件监听器。
-        // Key 是事件名，Value 是一个 Set，其中包含该事件的所有监听器函数。
-        // 使用 Set 可以自动防止同一个监听器被重复注册。
-        this.listeners = new Map();
+function checkEntry() {
+    const entryFiles = NATIVE_GAME_ENTRY_FILES.map(file => path.join(process.cwd(), file));
+    const foundEntryFile = entryFiles.find(file => fs.existsSync(file));
+    if (!foundEntryFile) {
+        /**
+         * 如果当前目录下没有任何一个入口文件，提示用户检查当前目录是否为 Mini Game 项目的入口目录，需要提醒开发者进入到游戏项目根目录进行调试
+         */
+        console.error(chalk.red.bold(`Current directory is not a Mini Game project entry directory, please enter the game project root directory for debugging`));
+        process.exit(1);
     }
-    /**
-     * 注册一个事件监听器。
-     * @param eventName 要监听的事件名称。
-     * @param listener 事件触发时执行的回调函数。
-     * @returns 返回一个函数，调用该函数即可注销此监听器，方便使用。
-     */
-    on(eventName, listener) {
-        if (!this.listeners.has(eventName)) {
-            this.listeners.set(eventName, new Set());
+}
+
+function getDevToolVersion() {
+    try {
+        return JSON.parse(fs.readFileSync(path.join(__dirname, 'package.json'), 'utf8')).version;
+    }
+    catch (error) {
+        return 'unknown';
+    }
+}
+
+function showTips(context) {
+    console.log(chalk.gray('─────────────────────────────────────────────'));
+    console.log(chalk.yellow.bold('1.') +
+        ' The QR code page will be opened automatically in Chrome.');
+    console.log('   If it fails, please open the following link manually:');
+    console.log('   ' + chalk.cyan.underline(context.server));
+    console.log('');
+    console.log(chalk.yellow.bold('2.') +
+        ' The debugging service will automatically compile your game assets.');
+    console.log('   Any changes in your game directory will trigger recompilation.');
+    console.log('   You can debug the updated content when upload is completed.');
+    console.log('');
+    console.log(chalk.yellow.bold('3.') +
+        ' After scanning the QR code with your phone for Test User authentication,');
+    console.log('   the compiled code package will be uploaded to the client automatically.');
+    console.log('   Game debugging will start right away.');
+    console.log(chalk.gray('─────────────────────────────────────────────'));
+}
+
+const UNITY_PPE_ENV = 'ppe_op_unity';
+const BASE_URL = 'https://developers.tiktok.com';
+const DEV_HEADERS = {
+    'x-use-ppe': '1',
+    'x-tt-env': UNITY_PPE_ENV,
+    // 'x-tt-target-idc': 'sg',
+};
+const WASM_SPLIT_CACHE_DIR = '__TTMG_TEMP__/wasmcode/';
+const WASM_SYMBOL_FILE_NAME = 'webgl.symbols.json';
+const UNITY_WASM_SPLIT_CONFIG_FIELD_SCHEME = {
+    ENABLEWASMCOLLECT: `"$ENABLEWASMCOLLECT"`,
+    enableWasmSplit: `"$ENABLEWASMSPLIT"`,
+    ORIGINALWASMMD5: `$ORIGINALWASMMD5`,
+    GLOBALVARLIST: `["$GLOBALVARLIST"]`,
+    SUBJSURL: `$SUBJSURL`,
+    WASMTABLESIZE: `"$WASMTABLESIZE"`,
+    USINGWASMH5: `"$USINGWASMH5"`,
+    IOS_CODE_FILE_MD5: `$IOS_CODE_FILE_MD5`,
+    ANDROID_CODE_FILE_MD5: `$ANDROID_CODE_FILE_MD5`,
+    ANDROID_SUB_CODE_FILE_MD5: `$SUB_CODE_FILE_MD5`,
+    WASMSPLITVERSION: `"$WASMSPLITVERSION"`,
+    ENABLEWASMSPLIT: `"$ENABLEWASMSPLIT"`,
+    IOS_SUB_JS_FILE_CONFIG: `"$IOS_SUB_JS_FILE_CONFIG"`,
+};
+
+const DIR_SPLIT = 'split';
+const WASM_SPLIT_SUBPACKAGE_CONFIG = {
+    origin: {
+        name: 'wasmcode',
+        root: 'wasmcode/',
+    },
+    androidMain: {
+        name: 'wasmcode-android',
+        root: 'wasmcode-android/',
+    },
+    androidSub: {
+        name: 'wasmcode1-android',
+        root: 'wasmcode1-android/',
+    },
+    ios: {
+        root: 'wasmcode-ios/',
+    },
+    iosMain: {
+        name: 'wasmcode-ios',
+        root: 'wasmcode-ios/',
+    },
+    iosSub: {
+        name: 'wasmcode1-ios',
+        root: 'wasmcode1-ios/',
+    },
+};
+const WASM_FILENAME_SUFFIX = '.webgl.wasm.code.unityweb.wasm';
+const BR_SUFFIX = '.br';
+// 输出 JSON 格式
+const JSON_INDENT = 2;
+const JSON_EOL = '\n';
+// 并发与重试
+const CONCURRENCY_LIMIT = 2;
+const DOWNLOAD_RETRY = 3;
+const WASM_SPLIT_CONFIG_FILE_NAME = 'webgl-wasm-split.js';
+
+// prepare.ts
+// 若你的 request 是 axios：你可以添加 maxBodyLength/ maxContentLength 等参数
+// 若是 got：可直接传 form 实例
+async function startPrepare(params) {
+    const form = new FormData$1();
+    form.append('desc', params.desc);
+    form.append('wasm_md5', params.wasm_md5);
+    form.append('with_ios', 'true');
+    // 二进制字段：用 ReadStream（推荐）或 Buffer
+    form.append('wasm_file', fs$1.createReadStream(path$1.join(process.cwd(), params.wasm_file_path)), {
+        filename: path$1.basename(params.wasm_file_path),
+        // 部分后端会依赖 content-type；如果不确定就用 application/octet-stream
+        contentType: 'application/wasm',
+    });
+    form.append('wasm_symbol_file', fs$1.createReadStream(path$1.join(process.cwd(), WASM_SYMBOL_FILE_NAME)), {
+        filename: WASM_SYMBOL_FILE_NAME,
+        contentType: 'application/octet-stream',
+    });
+    // 关键：用 form.getHeaders() 获取带 boundary 的 Content-Type
+    const formHeaders = form.getHeaders();
+    return request({
+        url: `${BASE_URL}/api/stark_wasm/v4/post/prepare`,
+        method: 'POST',
+        headers: {
+            ...DEV_HEADERS,
+            ...formHeaders, // 包含正确的 multipart/form-data; boundary=...
+        },
+        params: {
+            client_key: params.client_key,
+            with_ios: true,
+        },
+        data: form,
+        // 若 request 基于 axios，建议加上以下两项以支持大文件：
+    });
+}
+
+async function withRetry(fn, retries = 3) {
+    let lastErr;
+    for (let i = 0; i < retries; i++) {
+        try {
+            return await fn();
         }
-        this.listeners.get(eventName).add(listener);
-        // 返回一个便捷的取消订阅函数
-        return () => this.off(eventName, listener);
-    }
-    /**
-     * 注销一个事件监听器。
-     * @param eventName 要注销的事件名称。
-     * @param listener 之前通过 on() 方法注册的回调函数实例。
-     */
-    off(eventName, listener) {
-        const eventListeners = this.listeners.get(eventName);
-        if (eventListeners) {
-            eventListeners.delete(listener);
-            if (eventListeners.size === 0) {
-                this.listeners.delete(eventName);
-            }
+        catch (e) {
+            lastErr = e;
+            const delay = 2 ** i * 300;
+            await new Promise(r => setTimeout(r, delay));
         }
     }
-    /**
-     * 触发一个事件，并同步调用所有相关的监听器。
-     * @param eventName 要触发的事件名称。
-     * @param payload 传递给所有监听器的数据。类型必须与事件定义匹配。
-     */
-    emit(eventName, payload) {
-        const eventListeners = this.listeners.get(eventName);
-        if (eventListeners) {
-            // 遍历 Set 并执行每一个监听器
-            eventListeners.forEach(listener => {
-                try {
-                    // 在独立的 try...catch 中调用，防止一个监听器的错误影响其他监听器
-                    listener(payload);
-                }
-                catch (error) {
-                    console.error(`Error in listener for event "${String(eventName)}":`, error);
-                }
-            });
-        }
+    throw lastErr;
+}
+
+function updateWasmSplitConfig(fields) {
+    for (const field in fields) {
+        const value = fields[field];
+        const isString = typeof value === 'string';
+        const valueStr = isString ? value : String(value);
+        const configFilePath = path.join(process.cwd(), WASM_SPLIT_CONFIG_FILE_NAME);
+        const placeholder = UNITY_WASM_SPLIT_CONFIG_FIELD_SCHEME[field];
+        const config = fs.readFileSync(configFilePath, 'utf-8');
+        // 将占位符替换为 true/false 字面量
+        // 用正则？因为 placeholder 是一个字符串，可能包含特殊字符
+        const updated = config.replace(placeholder, valueStr);
+        fs.writeFileSync(configFilePath, updated, 'utf-8');
     }
-    /**
-     * 注销指定事件的所有监听器。
-     * @param eventName 要清除监听器的事件名称。
-     */
-    removeAllListeners(eventName) {
-        this.listeners.delete(eventName);
+}
+
+async function compressWasmFile(wasmFilePath, compressedFilePath) {
+    const arrayBuffer = await fs.promises.readFile(wasmFilePath);
+    const compressedArrayBuffer = (await compressArrayBuffer(arrayBuffer));
+    fs.writeFileSync(compressedFilePath, Buffer.from(compressedArrayBuffer));
+    // 删除原始文件
+    fs.unlinkSync(wasmFilePath);
+}
+function compressArrayBuffer(arrayBuffer) {
+    return new Promise((resolve, reject) => {
+        const compressStream = zlib.createBrotliCompress();
+        compressStream.write(Buffer.from(arrayBuffer));
+        compressStream.end();
+        const compressedChunks = [];
+        compressStream.on('data', chunk => compressedChunks.push(chunk));
+        compressStream.on('end', () => resolve(Buffer.concat(compressedChunks)));
+        compressStream.on('error', reject);
+    });
+}
+
+function keepCacheSync({ entryDir, originalWasmPath, originalSplitConfigPath, }) {
+    const cacheDir = path__namespace.join(entryDir, WASM_SPLIT_CACHE_DIR);
+    if (!fs__namespace.existsSync(cacheDir)) {
+        fs__namespace.mkdirSync(cacheDir, { recursive: true });
+    }
+    const wasmCachePath = path__namespace.join(cacheDir, path__namespace.basename(originalWasmPath));
+    if (!fs__namespace.existsSync(wasmCachePath)) {
+        fs__namespace.copyFileSync(path__namespace.join(entryDir, originalWasmPath), wasmCachePath);
+    }
+    const splitConfigCachePath = path__namespace.join(cacheDir, path__namespace.basename(originalSplitConfigPath));
+    if (!fs__namespace.existsSync(splitConfigCachePath)) {
+        fs__namespace.copyFileSync(path__namespace.join(entryDir, originalSplitConfigPath), splitConfigCachePath);
     }
     /**
-     * 清空所有事件的所有监听器。
+     * 保存 game.json
      */
-    clearAll() {
-        this.listeners.clear();
+    const gameJsonPath = path__namespace.join(entryDir, 'game.json');
+    const gameJsonCachePath = path__namespace.join(cacheDir, 'game.json');
+    if (!fs__namespace.existsSync(gameJsonCachePath)) {
+        fs__namespace.copyFileSync(gameJsonPath, gameJsonCachePath);
     }
+    return {
+        cacheDir,
+    };
 }
-const eventEmitter = new TypedEventEmitter();
 
-class WsServer {
-    constructor() {
-        this.startWsServer(store.getState().nodeWsPort);
-    }
-    startWsServer(port) {
-        this.ws = new WebSocket.Server({ port });
-        this.ws.on('connection', ws => {
-            const { clientHttpPort, clientHost, clientWsPort } = store.getState();
-            if (clientHost) {
-                this.send({
-                    method: 'clientDebugInfo',
-                    payload: {
-                        clientHttpPort,
-                        clientHost,
-                        clientWsPort,
-                    },
+async function downloadPrepared(data) {
+    wsServer.sendUnitySplitStatus({
+        status: 'star_fetch_prepared_wasm_url',
+    });
+    const res = await request({
+        url: `${BASE_URL}/api/stark_wasm/v4/post/download_prepared`,
+        method: 'POST',
+        headers: DEV_HEADERS,
+        data,
+    });
+    wsServer.sendUnitySplitStatus({
+        status: 'fetch_prepared_wasm_url_done',
+    });
+    try {
+        const downloadUrl = res?.data?.result?.download_url;
+        const willReplaceWasmPath = path.join(process.cwd(), data.wasm_path);
+        if (downloadUrl) {
+            const { cacheDir } = keepCacheSync({
+                entryDir: process.cwd(),
+                originalWasmPath: data.wasm_path,
+                originalSplitConfigPath: WASM_SPLIT_CONFIG_FILE_NAME,
+            });
+            if (downloadUrl.includes('.br')) {
+                const tempWasmPath = path.join(cacheDir, '__temp__.wasm.br');
+                wsServer.sendUnitySplitStatus({
+                    status: 'start_download_prepared_wasm',
+                    url: downloadUrl,
+                });
+                await download(downloadUrl, tempWasmPath);
+                /**
+                 * 下载完成后需要进行 br 并替换 codePath 对应的文件后再返回成功
+                 */
+                fs$1.copyFileSync(tempWasmPath, willReplaceWasmPath);
+                wsServer.sendUnitySplitStatus({
+                    status: 'download_prepared_wasm_done',
+                    url: downloadUrl,
                 });
             }
-            ws.on('message', message => {
-                /** 客户端发送的消息 */
-                const clientMessage = JSON.parse(message.toString());
-                const from = clientMessage.from;
-                if (from === 'browser') {
-                    // console.log(chalk.yellow.bold('Browser message'), clientMessage);
-                    const method = clientMessage.method;
-                    switch (method) {
-                        case 'manualConnect': {
-                            const { clientHttpPort, clientHost, clientWsPort } = clientMessage.payload;
-                            store.setState({
-                                clientHttpPort,
-                                clientHost,
-                                clientWsPort,
-                                clientWsHost: clientHost,
-                            });
-                            break;
-                        }
-                        case 'startUpload':
-                            eventEmitter.emit('startUpload', {});
-                            break;
-                        case 'closeLocalDebug':
-                            console.log('closeLocalDebug');
-                            /**
-                             * 关闭调试服务
-                             */
-                            this.ws.close();
-                            break;
-                    }
-                }
-                else {
-                    const method = clientMessage.method;
-                    switch (method) {
-                        /**
-                         * 客户端完成扫码成功，返回客户端的 host 和 port
-                         */
-                        case 'startScanQRcode': {
-                            const payload = clientMessage.payload;
-                            console.log('startQRcode', payload);
-                            this.send({
-                                method: 'startScanQRcode',
-                            });
-                            break;
-                        }
-                        case 'scanQRCodeResult': {
-                            const payload = clientMessage.payload || {};
-                            const { host, port, wsPort, errMsg, isSuccess } = payload;
-                            console.log('scanQRCodeResult', payload);
-                            if (isSuccess) {
-                                store.setState({
-                                    clientHttpPort: port,
-                                    clientHost: host,
-                                    clientWsPort: wsPort,
-                                });
-                                this.send({
-                                    method: 'scanQRCodeSuccess',
-                                    payload: {
-                                        clientHttpPort: port,
-                                        clientHost: host,
-                                        clientWsPort: wsPort,
-                                    },
-                                });
-                                console.log('scanQRcodeSuccess');
-                            }
-                            else {
-                                this.send({
-                                    method: 'scanQRCodeFailed',
-                                    payload: {
-                                        errMsg,
-                                    },
-                                });
-                            }
-                            break;
-                        }
-                        // 手动绑定客户端调试服务
-                        // 待废弃
-                        case 'shareDevParams':
-                            const payload = clientMessage.payload;
-                            const { host, port, wsPort } = payload;
-                            store.setState({
-                                clientHttpPort: port,
-                                clientHost: host,
-                                clientWsPort: wsPort,
-                                clientWsHost: host,
-                            });
-                            this.send({
-                                method: 'scanQRCodeSuccess',
-                                payload: {
-                                    clientHttpPort: port,
-                                    clientHost: host,
-                                    clientWsPort: wsPort,
-                                },
-                            });
-                            break;
-                    }
-                }
+            else {
+                const tempWasmPath = path.join(cacheDir, '__temp__.wasm');
+                wsServer.sendUnitySplitStatus({
+                    status: 'start_download_prepared_wasm',
+                    url: downloadUrl,
+                });
+                await download(downloadUrl, tempWasmPath);
+                wsServer.sendUnitySplitStatus({
+                    status: 'download_prepared_wasm_done',
+                    url: downloadUrl,
+                });
+                /**
+                 * 下载完成后需要进行 br 并替换 codePath 对应的文件后再返回成功
+                 */
+                wsServer.sendUnitySplitStatus({
+                    status: 'start_compress_prepared_wasm',
+                });
+                await compressWasmFile(tempWasmPath, willReplaceWasmPath);
+                wsServer.sendUnitySplitStatus({
+                    status: 'compress_prepared_wasm_done',
+                    url: downloadUrl,
+                });
+                wsServer.sendUnitySplitStatus({
+                    status: 'write_compress_prepared_wasm_done',
+                });
+            }
+            wsServer.sendUnitySplitStatus({
+                status: 'start_update_wasm_split_config',
+            });
+            /**
+             * 读取 webgl-wasm-split.js内容，将 enableWasmCollect 设为 true
+             */
+            updateWasmSplitConfig({
+                ENABLEWASMCOLLECT: true,
             });
+            wsServer.sendUnitySplitStatus({
+                status: 'update_wasm_split_config_done',
+            });
+            return {
+                isSuccess: true,
+                ctx: res?.ctx,
+            };
+        }
+        else {
+            return {
+                isSuccess: false,
+                error: {
+                    code: res.data?.code,
+                    message: res.data?.message,
+                },
+                ctx: res?.ctx,
+            };
+        }
+    }
+    catch (error) {
+        return {
+            isSuccess: false,
+            error: {
+                code: res.data?.code,
+                message: error.message,
+            },
+            ctx: res?.ctx,
+        };
+    }
+}
+
+async function getCollectedFuncIds({ client_key, wasm_md5, }) {
+    return request({
+        url: `${BASE_URL}/api/stark_wasm/v4/get/collectedfuncids`,
+        method: 'GET',
+        headers: DEV_HEADERS,
+        params: {
+            client_key,
+            wasm_md5,
+        },
+    });
+}
+
+async function setCollect({ client_key, wasm_md5, }) {
+    return request({
+        url: `${BASE_URL}/api/stark_wasm/v4/post/set_collecting`,
+        method: 'POST',
+        data: {
+            client_key,
+            wasm_md5,
+        },
+        headers: DEV_HEADERS,
+    });
+}
+
+async function getCollecttingInfo({ client_key, wasm_md5, }) {
+    return request({
+        url: `${BASE_URL}/api/stark_wasm/v4/get/funccollect`,
+        method: 'GET',
+        headers: DEV_HEADERS,
+        params: {
+            client_key,
+            wasm_md5,
+        },
+    });
+}
+
+// /api/stark_wasm/v4/post/split
+async function startSplit({ client_key, wasm_md5, }) {
+    return request({
+        url: `${BASE_URL}/api/stark_wasm/v4/post/split`,
+        method: 'POST',
+        headers: {
+            ...DEV_HEADERS,
+        },
+        data: {
+            client_key,
+            wasm_md5,
+        },
+    });
+}
+
+/*
+How it works:
+`this.#head` is an instance of `Node` which keeps track of its current value and nests another instance of `Node` that keeps the value that comes after it. When a value is provided to `.enqueue()`, the code needs to iterate through `this.#head`, going deeper and deeper to find the last value. However, iterating through every single item is slow. This problem is solved by saving a reference to the last value as `this.#tail` so that it can reference it to add a new value.
+*/
+
+class Node {
+	value;
+	next;
+
+	constructor(value) {
+		this.value = value;
+	}
+}
+
+class Queue {
+	#head;
+	#tail;
+	#size;
+
+	constructor() {
+		this.clear();
+	}
+
+	enqueue(value) {
+		const node = new Node(value);
+
+		if (this.#head) {
+			this.#tail.next = node;
+			this.#tail = node;
+		} else {
+			this.#head = node;
+			this.#tail = node;
+		}
+
+		this.#size++;
+	}
+
+	dequeue() {
+		const current = this.#head;
+		if (!current) {
+			return;
+		}
+
+		this.#head = this.#head.next;
+		this.#size--;
+
+		// Clean up tail reference when queue becomes empty
+		if (!this.#head) {
+			this.#tail = undefined;
+		}
+
+		return current.value;
+	}
+
+	peek() {
+		if (!this.#head) {
+			return;
+		}
+
+		return this.#head.value;
+
+		// TODO: Node.js 18.
+		// return this.#head?.value;
+	}
+
+	clear() {
+		this.#head = undefined;
+		this.#tail = undefined;
+		this.#size = 0;
+	}
+
+	get size() {
+		return this.#size;
+	}
+
+	* [Symbol.iterator]() {
+		let current = this.#head;
+
+		while (current) {
+			yield current.value;
+			current = current.next;
+		}
+	}
+
+	* drain() {
+		while (this.#head) {
+			yield this.dequeue();
+		}
+	}
+}
+
+const AsyncResource = {
+	bind(fn, _type, thisArg) {
+		return fn.bind(thisArg);
+	},
+};
+
+function pLimit(concurrency) {
+	if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
+		throw new TypeError('Expected `concurrency` to be a number from 1 and up');
+	}
+
+	const queue = new Queue();
+	let activeCount = 0;
+
+	const next = () => {
+		activeCount--;
+
+		if (queue.size > 0) {
+			queue.dequeue()();
+		}
+	};
+
+	const run = async (function_, resolve, arguments_) => {
+		activeCount++;
+
+		const result = (async () => function_(...arguments_))();
+
+		resolve(result);
+
+		try {
+			await result;
+		} catch {}
+
+		next();
+	};
+
+	const enqueue = (function_, resolve, arguments_) => {
+		queue.enqueue(
+			AsyncResource.bind(run.bind(undefined, function_, resolve, arguments_)),
+		);
+
+		(async () => {
+			// This function needs to wait until the next microtask before comparing
+			// `activeCount` to `concurrency`, because `activeCount` is updated asynchronously
+			// when the run function is dequeued and called. The comparison in the if-statement
+			// needs to happen asynchronously as well to get an up-to-date value for `activeCount`.
+			await Promise.resolve();
+
+			if (activeCount < concurrency && queue.size > 0) {
+				queue.dequeue()();
+			}
+		})();
+	};
+
+	const generator = (function_, ...arguments_) => new Promise(resolve => {
+		enqueue(function_, resolve, arguments_);
+	});
+
+	Object.defineProperties(generator, {
+		activeCount: {
+			get: () => activeCount,
+		},
+		pendingCount: {
+			get: () => queue.size,
+		},
+		clearQueue: {
+			value() {
+				queue.clear();
+			},
+		},
+	});
+
+	return generator;
+}
+
+function updateSubpackageConfigSync() {
+    const gameJsonPath = path__namespace.join(process.cwd(), SUBPACKAGE_CONFIG_FILE_NAME);
+    const raw = fs__namespace.readFileSync(gameJsonPath, 'utf-8');
+    const gameJson = JSON.parse(raw);
+    const fieldName = SUBAPCKAGE_FILED_NAMES.find(k => k in gameJson) ??
+        SUBAPCKAGE_FILED_NAMES[0];
+    if (!gameJson[fieldName])
+        gameJson[fieldName] = [];
+    const subpackages = gameJson[fieldName];
+    // 删除老的 'wasmcode'
+    const filtered = subpackages.filter(s => s.name !== WASM_SPLIT_SUBPACKAGE_CONFIG.origin.name);
+    /**
+     * 基于 SUBPACKAGE_CONFIG_FILE_NAME 更新 subpackages
+     */
+    filtered.push(WASM_SPLIT_SUBPACKAGE_CONFIG.androidMain);
+    filtered.push(WASM_SPLIT_SUBPACKAGE_CONFIG.androidSub);
+    filtered.push(WASM_SPLIT_SUBPACKAGE_CONFIG.iosMain);
+    filtered.push(WASM_SPLIT_SUBPACKAGE_CONFIG.iosSub);
+    // 合并去重：存在则更新 root，不存在则新增
+    const map = new Map(filtered.map(s => [s.name, s]));
+    gameJson[fieldName] = Array.from(map.values());
+    fs__namespace.writeFileSync(gameJsonPath, JSON.stringify(gameJson, null, JSON_INDENT) + JSON_EOL);
+}
+
+async function downloadAndCompress(opts) {
+    const { startDownloadStatus, downloadDoneStatus, startCompressStatus, compressDoneStatus, url, out, enableCompress = false, } = opts;
+    if (!url)
+        return;
+    const willDownloadedFileIsBr = url.includes(BR_SUFFIX);
+    const wasmBrOutName = willDownloadedFileIsBr ? out + BR_SUFFIX : out;
+    // 下载
+    wsServer.sendUnitySplitStatus({ status: startDownloadStatus });
+    console.log(`download url: ${url}`);
+    const t0 = Date.now();
+    await withRetry(() => download(url, wasmBrOutName), DOWNLOAD_RETRY);
+    try {
+        const st = await promises.stat(wasmBrOutName);
+        if (!st.size)
+            throw new Error(`Empty download: ${wasmBrOutName}`);
+        wsServer.sendUnitySplitStatus({ status: downloadDoneStatus, url });
+        console.log(`download done: ${path.basename(wasmBrOutName)} size=${st.size}B time=${Date.now() - t0}ms`);
+    }
+    catch (e) {
+        await promises.rm(wasmBrOutName);
+        throw e;
+    }
+    if (enableCompress) {
+        console.log(`compress start: ${path.basename(out)}${BR_SUFFIX}`);
+        // 压缩
+        wsServer.sendUnitySplitStatus({ status: startCompressStatus });
+        const t1 = Date.now();
+        await compressWasmFile(out, wasmBrOutName);
+        wsServer.sendUnitySplitStatus({ status: compressDoneStatus });
+        console.log(`compress done: ${path.basename(wasmBrOutName)} time=${Date.now() - t1}ms`);
+    }
+    /**
+     * 在当前文件所在目录下写入一个空的 game.js
+     */
+    fs__namespace.writeFileSync(path.join(path.dirname(out), 'game.js'), '', {
+        encoding: 'utf-8',
+    });
+}
+
+async function downloadSplited(context) {
+    const cwd = process.cwd();
+    const splitTempDir = path.join(cwd, WASM_SPLIT_CACHE_DIR, DIR_SPLIT);
+    ensureDirSync(splitTempDir);
+    const mainAndroidDir = path.join(splitTempDir, WASM_SPLIT_SUBPACKAGE_CONFIG.androidMain.root);
+    const subAndroidDir = path.join(splitTempDir, WASM_SPLIT_SUBPACKAGE_CONFIG.androidSub.root);
+    const mainIosDir = path.join(splitTempDir, WASM_SPLIT_SUBPACKAGE_CONFIG.iosMain.root);
+    const subIosDir = path.join(splitTempDir, WASM_SPLIT_SUBPACKAGE_CONFIG.iosSub.root);
+    [mainAndroidDir, subAndroidDir, mainIosDir, subIosDir].forEach(ensureDirSync);
+    const mainAndroidWasmCodeTempPath = path.join(mainAndroidDir, `${context.main_wasm_md5}${WASM_FILENAME_SUFFIX}`);
+    const subAndroidWasmCodeTempPath = path.join(subAndroidDir, `${context.sub_wasm_md5}${WASM_FILENAME_SUFFIX}`);
+    const mainIosWasmCodeTempPath = path.join(mainIosDir, `${context.main_wasm_h5_md5}${WASM_FILENAME_SUFFIX}`);
+    const limit = pLimit(CONCURRENCY_LIMIT);
+    try {
+        console.log('downloadWasmSplit', context);
+        // 原有状态文案，按你之前的写法
+        wsServer.sendUnitySplitStatus({
+            status: 'start_download_android_main_wasm',
         });
-        this.ws.on('error', err => {
-            if (err.code === 'EADDRINUSE') {
-                store.setState({
-                    nodeWsPort: store.getState().nodeWsPort + 1,
-                });
-                this.startWsServer(store.getState().nodeWsPort);
-            }
-            else {
-                console.log(chalk.red.bold(err.message));
-                process.exit(1);
-            }
+        wsServer.sendUnitySplitStatus({
+            status: 'start_download_android_sub_wasm_code',
         });
-    }
-    send(params) {
-        this.ws.clients.forEach(client => {
-            if (client.readyState === WebSocket.OPEN) {
-                const data = {
-                    ...params,
-                    from: 'nodeServer',
-                };
-                client.send(JSON.stringify(data));
+        wsServer.sendUnitySplitStatus({ status: 'start_download_ios_main_wasm' });
+        /**
+         * 需要做个保护，只有 有 URL 时才下载
+         */
+        // 并发下载 + 压缩（带重试）
+        await Promise.all([
+            limit(() => downloadAndCompress({
+                startDownloadStatus: 'start_download_android_main_wasm',
+                downloadDoneStatus: 'download_android_main_wasm_done',
+                startCompressStatus: 'start_compress_android_main_wasm',
+                compressDoneStatus: 'compress_android_main_wasm_done',
+                url: context.main_wasm_download_url,
+                out: mainAndroidWasmCodeTempPath,
+            })),
+            limit(() => downloadAndCompress({
+                startDownloadStatus: 'start_download_android_sub_wasm_code',
+                downloadDoneStatus: 'download_android_sub_wasm_code_done',
+                startCompressStatus: 'start_compress_android_sub_wasm_code',
+                compressDoneStatus: 'compress_android_sub_wasm_code_done',
+                url: context.sub_wasm_download_url,
+                out: subAndroidWasmCodeTempPath,
+            })),
+            limit(() => downloadAndCompress({
+                startDownloadStatus: 'start_download_ios_main_wasm',
+                downloadDoneStatus: 'download_ios_main_wasm_done',
+                startCompressStatus: 'start_compress_ios_main_wasm',
+                compressDoneStatus: 'compress_ios_main_wasm_done',
+                url: context.main_wasm_h5_download_url,
+                out: mainIosWasmCodeTempPath,
+            })),
+            // 下载 ios sub js range  json
+            limit(() => downloadAndCompress({
+                startDownloadStatus: 'start_download_ios_range_json',
+                downloadDoneStatus: 'download_ios_range_json_done',
+                url: context.sub_js_range_download_url,
+                out: path.join(subIosDir, 'func_bytes_range.json'),
+            })),
+            // 下载 ios sub js data br
+            limit(() => downloadAndCompress({
+                startDownloadStatus: 'start_download_ios_js_data_br',
+                downloadDoneStatus: 'download_ios_js_data_br_done',
+                url: context.sub_js_data_download_url,
+                out: path.join(subIosDir, 'subjs.data'),
+            })),
+        ]);
+        // 复制 split/* 到项目根目录（递归、覆盖）——避免 EISDIR
+        console.log('copy splitTempDir to root start');
+        wsServer.sendUnitySplitStatus({ status: 'start_write_splited_wasm_br' });
+        for (const file of fs.readdirSync(splitTempDir)) {
+            const srcPath = path.join(splitTempDir, file);
+            const destPath = path.join(cwd, file);
+            // 如果目标路径有文件或目录，先删除
+            if (fs.existsSync(destPath)) {
+                await promises.rm(destPath, { recursive: true, force: true });
             }
+            await promises.cp(srcPath, destPath, { recursive: true, force: true });
+        }
+        wsServer.sendUnitySplitStatus({ status: 'write_splited_wasm_done' });
+        console.log('copy splitTempDir to root end');
+        // 更新分包配置（幂等）
+        console.log('updateSubpackageConfigSync start');
+        updateSubpackageConfigSync();
+        console.log('updateSubpackageConfigSync end');
+        // 更新 wasm split 配置（保持原始状态文案）
+        console.log('updateWasmSplitConfig start');
+        wsServer.sendUnitySplitStatus({ status: 'start_update_wasm_split_config' });
+        updateWasmSplitConfig({
+            ENABLEWASMCOLLECT: true,
+            ORIGINALWASMMD5: `${context.original_wasm_md5}`,
+            WASMTABLESIZE: context.table_size,
+            GLOBALVARLIST: JSON.stringify(context.global_var_list ?? []),
+            SUBJSURL: `${context.sub_js_download_url}`,
+            IOS_CODE_FILE_MD5: `${context.main_wasm_h5_md5}`,
+            ANDROID_CODE_FILE_MD5: `${context.main_wasm_md5}`,
+            ANDROID_SUB_CODE_FILE_MD5: `${context.sub_wasm_md5}`,
+            WASMSPLITVERSION: `${context.version}`,
+            USINGWASMH5: Boolean(context.main_wasm_h5_md5),
+            ENABLEWASMSPLIT: true,
+            // IOS_SUB_JS_FILE_CONFIG: JSON.stringify(context.merged_js ?? {}),
         });
+        wsServer.sendUnitySplitStatus({ status: 'update_wasm_split_config_done' });
+        console.log('updateWasmSplitConfig end');
+        return {
+            data: {
+                isSuccess: true,
+            },
+            ctx: context,
+        };
     }
-    sendResourceChange() {
-        this.send({
-            method: 'resourceChange',
+    catch (err) {
+        wsServer.sendUnitySplitStatus({
+            status: 'wasm_split_failed',
+            errorMsg: err instanceof Error ? err.message : String(err),
         });
-    }
-    sendCompilationStatus(status, payload) {
-        this.send({
-            method: 'compilationStatus',
-            payload: {
-                status,
-                ...payload,
+        return {
+            data: {
+                isSuccess: false,
+            },
+            error: {
+                message: err instanceof Error ? err.message : String(err),
             },
+            ctx: context,
+        };
+    }
+    finally {
+        // 清理临时目录与旧 wasmcode 目录
+        console.log('delete splitTempDir start');
+        await promises.rm(splitTempDir, { recursive: true, force: true });
+        console.log('delete splitTempDir end');
+        console.log('delete wasmcode start');
+        await promises.rm(path.join(cwd, WASM_SPLIT_SUBPACKAGE_CONFIG.origin.root), {
+            recursive: true,
+            force: true,
         });
+        console.log('delete wasmcode end');
     }
-    close() {
-        this.ws.close();
+}
+
+async function getSplitResult({ client_key, wasm_md5, wasm_path, }) {
+    return request({
+        url: `${BASE_URL}/api/stark_wasm/v4/post/download`,
+        method: 'POST',
+        headers: { ...DEV_HEADERS },
+        data: { client_key, wasm_md5, wasm_path },
+    });
+}
+
+function cancelSplit(params) {
+    /**
+     * 把— __TTMG_TEMP__/wasmcode/ 目录下的所有文件恢复到原本的位置，进行重置
+     */
+    const { wasmCodePath } = params;
+    const cacheDir = path__namespace.join(process.cwd(), WASM_SPLIT_CACHE_DIR);
+    /**
+     * 恢复 br 文件
+     */
+    if (fs__namespace.existsSync(cacheDir)) {
+        /**
+         * 判断是否有缓存的 br 文件
+         */
+        const targetWasmBrPath = path__namespace.join(cacheDir, path__namespace.basename(wasmCodePath));
+        if (fs__namespace.existsSync(targetWasmBrPath)) {
+            const destWasmBrPath = path__namespace.join(process.cwd(), wasmCodePath);
+            // 规避没有文件夹的情况
+            ensureDirSync(path__namespace.dirname(destWasmBrPath));
+            fs__namespace.copyFileSync(targetWasmBrPath, destWasmBrPath);
+        }
     }
-    sendUploadStatus(status, payload) {
-        this.send({
-            method: 'uploadStatus',
-            status,
-            payload,
-        });
+    /**
+     * 恢复 webgl-wasm-split.js 文件
+     */
+    const splitConfigCachePath = path__namespace.join(cacheDir, WASM_SPLIT_CONFIG_FILE_NAME);
+    if (fs__namespace.existsSync(splitConfigCachePath)) {
+        fs__namespace.copyFileSync(splitConfigCachePath, path__namespace.join(process.cwd(), WASM_SPLIT_CONFIG_FILE_NAME));
+    }
+    /**
+     * 恢复 game.json 文件
+     */
+    const gameJsonCachePath = path__namespace.join(cacheDir, 'game.json');
+    if (fs__namespace.existsSync(gameJsonCachePath)) {
+        fs__namespace.copyFileSync(gameJsonCachePath, path__namespace.join(process.cwd(), 'game.json'));
     }
 }
-const wsServer = new WsServer();
 
-async function compile(context) {
-    // const { openDataContext } = getOpenContextConfig();
-    // if (!!openDataContext) {
-    //   buildOpenContextToFile(openDataContext);
-    // }
-    const entryDir = process.cwd();
-    const outputDir = getOutputDir();
-    const { clientKey, msg } = getClientKey();
-    if (!clientKey) {
-        if (context?.mode !== 'watch') {
-            console.log(chalk.red.bold(msg));
-            process.exit(1);
+async function resetWasmSplit(data) {
+    const res = await request({
+        url: `${BASE_URL}/api/stark_wasm/v4/post/reset`,
+        method: 'POST',
+        headers: {
+            ...DEV_HEADERS,
+        },
+        data: {
+            client_key: data.clientkey,
+            wasm_md5: data.wasmMd5,
+        },
+    });
+    /**
+     * 把— __TTMG_TEMP__/wasmcode/ 目录下的所有文件恢复到原本的位置，进行重置
+     */
+    const cacheDir = path.join(process.cwd(), WASM_SPLIT_CACHE_DIR);
+    /**
+     * 恢复 br 文件
+     */
+    if (fs.existsSync(cacheDir)) {
+        /**
+         * 判断是否有缓存的 br 文件
+         */
+        /**
+         * 判断 cache 文件夹下有没有 .br 文件
+         *
+         */
+        const targetWasmBrPath = fs
+            .readdirSync(cacheDir)
+            .find(item => item.endsWith('.br'));
+        if (targetWasmBrPath) {
+            const destWasmBrPath = path.join(process.cwd(), WASM_SPLIT_SUBPACKAGE_CONFIG.origin.root, path.basename(targetWasmBrPath));
+            // 规避没有文件夹的情况
+            ensureDirSync(path.dirname(destWasmBrPath));
+            fs.copyFileSync(path.join(cacheDir, targetWasmBrPath), destWasmBrPath);
         }
-        console.log(chalk.red.bold(msg));
     }
-    const startTip = context?.mode === 'watch'
-        ? '🔔 Watching game assets for local debugging...'
-        : '🚀 Compiling game assets for local debugging...';
-    console.log(chalk.bold.cyan(startTip));
-    wsServer.sendCompilationStatus('start');
-    store.setState({
-        isUnderCompiling: true,
+    /**
+     * 恢复 webgl-wasm-split.js 文件
+     */
+    const splitConfigCachePath = path.join(cacheDir, WASM_SPLIT_CONFIG_FILE_NAME);
+    if (fs.existsSync(splitConfigCachePath)) {
+        fs.copyFileSync(splitConfigCachePath, path.join(process.cwd(), WASM_SPLIT_CONFIG_FILE_NAME));
+    }
+    /**
+     * 恢复 game.json 文件
+     */
+    const gameJsonCachePath = path.join(cacheDir, 'game.json');
+    if (fs.existsSync(gameJsonCachePath)) {
+        fs.copyFileSync(gameJsonCachePath, path.join(process.cwd(), 'game.json'));
+    }
+    /**
+     * 删除历史分包产物
+     */
+    const androidSubpackageDir = path.join(process.cwd(), WASM_SPLIT_SUBPACKAGE_CONFIG.androidMain.root);
+    if (fs.existsSync(androidSubpackageDir)) {
+        fs.rmSync(androidSubpackageDir, { recursive: true });
+    }
+    const androidSubpackageSubDir = path.join(process.cwd(), WASM_SPLIT_SUBPACKAGE_CONFIG.androidSub.root);
+    if (fs.existsSync(androidSubpackageSubDir)) {
+        fs.rmSync(androidSubpackageSubDir, { recursive: true });
+    }
+    const iosSubpackageDir = path.join(process.cwd(), WASM_SPLIT_SUBPACKAGE_CONFIG.ios.root);
+    if (fs.existsSync(iosSubpackageDir)) {
+        fs.rmSync(iosSubpackageDir, { recursive: true });
+    }
+    return res;
+}
+
+function getSplitConfig() {
+    const configFilePath = path__namespace.join(process.cwd(), WASM_SPLIT_CONFIG_FILE_NAME);
+    try {
+        // 1. 检查文件是否存在
+        if (!fs__namespace.existsSync(configFilePath)) {
+            console.error(`Config file not found at: ${configFilePath}`);
+            return null;
+        }
+        // 2. 同步读取文件内容为字符串
+        const fileContent = fs__namespace.readFileSync(configFilePath, 'utf-8');
+        // 3. 构造一个函数来执行并返回 module.exports 的内容
+        // 这是一种比直接用 eval() 更安全的方式，因为它限制了代码的执行作用域
+        const evaluateModule = new Function('module', `${fileContent}; return module.exports;`);
+        // 准备一个临时的 module 对象
+        const tempModule = { exports: {} };
+        // 4. 执行函数，并将配置赋值给 config 变量
+        const config = evaluateModule(tempModule);
+        // 5. 检查是否成功获取了配置
+        if (typeof config === 'object' && config !== null) {
+            return config;
+        }
+        else {
+            console.error('Failed to extract a valid config object from the file.');
+            return null;
+        }
+    }
+    catch (error) {
+        console.error('Error reading or evaluating split config file:', error);
+        return null;
+    }
+}
+
+const getTaskStatus = (params) => {
+    return request({
+        url: `${BASE_URL}/api/stark_wasm/v4/get/status`,
+        method: 'GET',
+        headers: DEV_HEADERS,
+        params,
     });
-    return new Promise((resolve, reject) => {
-        const worker = new worker_threads.Worker(path.resolve(__dirname, './scripts/worker.js'));
-        worker.on('message', msg => {
-            if (msg.type === 'status' && msg.status === 'end') {
-                const { isSuccess, errorMsg, packages } = msg;
-                if (!isSuccess) {
-                    store.setState({
-                        isUnderCompiling: false,
-                    });
-                    wsServer.sendCompilationStatus('end', {
-                        errorMsg,
-                        isSuccess: false,
-                    });
-                    console.log(chalk.red.bold(errorMsg));
-                }
-                else {
-                    store.setState({
-                        isUnderCompiling: false,
-                        packages,
-                    });
-                    /**
-                     * 编译成功后，需要触发上传
-                     */
-                    eventEmitter.emit('compileSuccess', {});
-                    wsServer.sendCompilationStatus('end', {
-                        isSuccess: true,
-                    });
-                    console.log(chalk.green.bold('✔ Game resources compiled successfully!'));
-                    resolve(msg); // 编译结束，返回结果
-                }
-                worker.terminate();
-            }
-            else if (msg.type === 'error') {
-                reject(msg.error);
-                worker.terminate();
-            }
-        });
-        worker.on('error', err => {
-            console.log(chalk.red.bold(err.message));
-            reject(err);
-            worker.terminate();
-        });
-        worker.postMessage({
-            type: 'compile',
-            context: {
-                clientKey,
-                outputDir,
-                devPort: store.getState().nodeServerPort,
-                entryDir,
+};
+
+const getTaskInfo = async (params) => {
+    return request({
+        url: `${BASE_URL}/api/stark_wasm/v4/get/taskinfo`,
+        method: 'GET',
+        headers: DEV_HEADERS,
+        params,
+    });
+};
+
+const successCode = 0;
+const errorCode = -1;
+const outputDir = getOutputDir();
+const publicPath = path.join(__dirname, 'public');
+const devToolVersion = getDevToolVersion();
+async function start() {
+    const startTime = Date.now();
+    const app = express();
+    app.use(fileUpload()); // 启用 express-fileupload 中间件
+    // --- 中间件和路由设置 ---
+    app.use(expressStaticGzip(publicPath, {
+        enableBrotli: true,
+        orderPreference: ['br'],
+    }));
+    app.use((req, res, next) => {
+        res.header('Access-Control-Allow-Origin', '*');
+        res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+        res.header('Cache-Control', 'no-cache, no-store, must-revalidate');
+        res.header('Pragma', 'no-cache');
+        res.header('Expires', '0');
+        res.header('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+        next();
+    });
+    app.use(express.json());
+    app.use(express.urlencoded({ extended: true }));
+    app.use('/game/files', express.static(outputDir));
+    app.get('/game/config', async (req, res) => {
+        const basic = await ttmgPack.getPkgs({ entryDir: process.cwd() });
+        const user = getCurrentUser();
+        const { clientKey } = getClientKey();
+        res.send({
+            error: null,
+            data: {
+                user,
+                code: successCode,
+                nodeWsPort: store.getState().nodeWsPort,
+                clientKey: clientKey,
+                schema: `https://www.tiktok.com/ttmg/dev/${clientKey}?host=${getLocalIP()}&port=${store.getState().nodeWsPort}&host_list=${encodeURIComponent(JSON.stringify(getLocalIPs()))}`,
+                ...basic,
+                devToolVersion,
             },
         });
     });
-}
-
-// import { uploadGame } from './uploadGame';
-async function watch() {
-    let debounceTimer = null;
-    // 监听当前工作目录，排除 node_modules 和 .git
-    const watcher = chokidar.watch(process.cwd(), {
-        // ignored: /(^|[\/\\])(\.git|node_modules)/, // 忽略 .git 和 node_modules
-        ignoreInitial: true, // 忽略初始添加事件
-        persistent: true,
-        awaitWriteFinish: {
-            stabilityThreshold: 1000,
-        },
+    app.get('/game/detail', async (req, res) => {
+        const basic = await ttmgPack.getPkgs({ entryDir: process.cwd() });
+        const { clientKey } = getClientKey();
+        const { error, data: gameInfo } = await fetchGameInfo(clientKey);
+        store.setState({
+            appId: gameInfo?.app_id,
+            sandboxId: gameInfo?.sandbox_info?.sandbox_id,
+        });
+        if (error) {
+            res.send({ error, data: null });
+            return;
+        }
+        else {
+            res.send({ error: null, data: { ...basic, ...gameInfo } });
+        }
     });
-    // 任意文件变化都触发
-    watcher.on('all', (event, path) => {
-        // 清除之前的定时器
-        if (debounceTimer)
-            clearTimeout(debounceTimer);
-        // 重新设置定时器
-        debounceTimer = setTimeout(async () => {
-            (await compile({
-                mode: 'watch',
-            }),
-                wsServer.sendResourceChange());
-            debounceTimer = null;
-        }, 2000);
+    app.get('/game/check', async (req, res) => {
+        const checkResult = await ttmgPack.checkPkgs({
+            entryDir: process.cwd(),
+            config: {
+                entry: process.cwd(),
+                output: outputDir,
+                dev: {
+                    enable: true,
+                    port: store.getState().nodeServerPort,
+                    host: 'localhost',
+                    enableSourcemap: false,
+                    enableLog: false,
+                },
+                build: {
+                    enableOdr: false,
+                    enableAPICheck: true,
+                    ...PKG_SIZE_LIMIT,
+                },
+            },
+        });
+        res.send({ code: successCode, data: checkResult });
     });
-    watcher.on('error', error => {
-        // console.error(chalk.red('[watch] 监听发生错误:'), error);
+    /**
+     * @description 上传游戏代码到服务器
+     */
+    app.post('/game/upload', async (req, res) => {
+        const fileKeys = Object.keys(req.files);
+        const uploadedFile = req.files[fileKeys[0]];
+        if (!uploadedFile) {
+            res.status(400).send({ code: errorCode, data: 'No file uploaded' }); // 使用正确的 HTTP 状态码
+            return;
+        }
+        try {
+            // 通过 header 获取 desc
+            const desc = req.headers['ttmg-game-desc'];
+            // 需要做 decodeURIComponent 处理
+            const decodedDesc = decodeURIComponent(desc || '--');
+            // 直接传递需要的信息
+            const { data, error } = await uploadGameToPlatform({
+                data: uploadedFile.data, // 这是 Buffer
+                name: uploadedFile.name, // 这是文件名
+                clientKey: getClientKey().clientKey,
+                note: decodedDesc,
+                appId: store.getState().appId,
+                sandboxId: store.getState().sandboxId,
+            });
+            if (error) {
+                res.send({ code: errorCode, error });
+            }
+            else {
+                res.send({ code: successCode, data });
+            }
+        }
+        catch (error) {
+            // 错误处理可以更具体
+            let errorMessage = 'An unknown error occurred.';
+            if (error instanceof Error) {
+                errorMessage = error.message;
+            }
+            // 打印详细错误到服务器日志，方便排查
+            res.status(500).send({ code: errorCode, data: errorMessage }); // 使用正确的 HTTP 状态码
+        }
     });
-}
-
-let spinner;
-async function uploadGame(callback) {
-    const ora = await import('ora');
-    spinner = ora.default({
-        text: chalk.cyan.bold('Uploading game assets to client...'),
-        spinner: 'dots',
+    app.get('/game/wasm-split-config', (req, res) => {
+        const config = getSplitConfig();
+        if (!config) {
+            res.send({ code: errorCode, data: 'Failed to parse split config' });
+        }
+        else {
+            res.send({ code: successCode, data: config });
+        }
     });
-    spinner.start();
-    const outputDir = getOutputDir();
-    callback({
-        status: 'start',
-        percent: 0,
+    app.get('/game/wasm-split-options', (req, res) => {
+        res.send({
+            code: successCode,
+            data: {
+                options: [
+                    {
+                        md5: '123',
+                        desc: 'test',
+                        version: '1.0.0',
+                        time: '2023-01-01',
+                        funcCounts: 100,
+                    },
+                    {
+                        md5: '456',
+                        desc: 'test2',
+                        version: '1.0.1',
+                        time: '2023-01-02',
+                        funcCounts: 200,
+                    },
+                ],
+            },
+        });
     });
-    const zipPath = path.join(os.homedir(), '__TTMG__', 'upload.zip');
-    await zipDirectory(outputDir, zipPath);
-    await uploadZip(zipPath, callback);
-}
-/**
- * 复制源目录内容到临时目录，然后根据 glob 模式过滤并压缩文件。
- * 原始目录保持不变。
- *
- * @param sourceDir - 要压缩的源文件夹路径。
- * @param outPath - 输出的 zip 文件路径。
- */
-async function zipDirectory(sourceDir, outPath) {
-    const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'zip-temp-'));
-    try {
-        // 2. 将源目录的所有内容复制到临时目录
-        await fs.promises.cp(sourceDir, tempDir, { recursive: true });
-        // 3. 对临时目录进行压缩
-        const output = fs.createWriteStream(outPath);
-        const archive = archiver('zip', { zlib: { level: 9 } });
-        // 使用 Promise 包装流操作
-        const archivePromise = new Promise((resolve, reject) => {
-            output.on('close', () => {
-                resolve();
+    /**
+     * 分包预处理
+     */
+    app.post('/game/wasm-prepare', async (req, res) => {
+        const { codePath, desc, codeMd5, clientKey } = req.body;
+        console.log('wasm-prepare-start', req.body);
+        const result = await startPrepare({
+            client_key: clientKey,
+            desc,
+            wasm_md5: codeMd5,
+            wasm_file_path: codePath,
+        });
+        if (result.error) {
+            res.send({
+                code: errorCode,
+                error: result.error,
+                ctx: result.ctx,
             });
-            archive.on('warning', err => console.warn('Archiver warning:', err));
-            output.on('error', err => reject(err));
-            archive.on('error', err => reject(err));
+        }
+        else {
+            const { md5 } = result.data?.result || {};
+            if (!md5) {
+                res.send({
+                    code: errorCode,
+                    error: result.data,
+                    ctx: result.ctx,
+                });
+            }
+            else {
+                res.send({
+                    code: successCode,
+                    data: result.data?.result || {},
+                    ctx: result.ctx,
+                });
+            }
+        }
+    });
+    /**
+     * @description 分包预处理查询，根据 taskId 查询预处理状态
+     * 前十次返回 process，第11次返回 success
+     */
+    app.post('/game/wasm-prepare-result', async (req, res) => {
+        console.log('wasm-prepare-result-request', req.body);
+        const { clientKey, codeMd5 } = req.body;
+        const response = await getTaskStatus({
+            client_key: clientKey,
+            wasm_md5: codeMd5,
         });
-        archive.pipe(output);
-        // 4. 使用 glob 在临时目录中查找文件，并应用过滤规则
-        const files = await glob__namespace.glob('**/*', {
-            cwd: tempDir,
-            nodir: true,
-            ignore: '**/*.js.map', // 过滤规则
+        if (response.error) {
+            res.send({
+                code: errorCode,
+                error: response.error,
+                ctx: response.ctx,
+            });
+        }
+        else {
+            res.send({
+                code: successCode,
+                data: response.data?.result || {},
+                ctx: response.ctx,
+            });
+        }
+    });
+    /**
+     * @description 下载预处理后的 wasm 包
+     */
+    app.post('/game/wasm-prepare-download', async (req, res) => {
+        /**
+         * 下载完成后需要进行 br 并替换 codePath 对应的文件后再返回成功
+         */
+        const { clientKey, codeMd5, codePath } = req.body;
+        console.log('wasm-prepare-download-start', req.body);
+        const response = await downloadPrepared({
+            client_key: clientKey,
+            wasm_md5: codeMd5,
+            wasm_path: codePath,
         });
-        // 5. 将过滤后的文件逐个添加到压缩包
-        for (const file of files) {
-            const filePath = path.join(tempDir, file);
-            archive.file(filePath, { name: file });
+        if (response.isSuccess) {
+            res.send({
+                code: successCode,
+                msg: 'download success',
+                ctx: response.ctx,
+            });
+        }
+        else {
+            res.send({
+                code: errorCode,
+                error: response.error,
+                ctx: response.ctx,
+            });
         }
-        // 6. 完成压缩
-        await archive.finalize();
-        // 等待文件流关闭
-        await archivePromise;
-    }
-    catch (err) {
-        console.error('压缩过程中发生错误:', err);
-        throw err;
-    }
-    finally {
-        // 7. 无论成功还是失败，都清理临时目录
-        await fs.promises.rm(tempDir, { recursive: true, force: true });
-    }
-}
-async function uploadZip(zipPath, callback) {
-    const startTime = Date.now();
-    const form = new FormData$1();
-    form.append('file', fs.createReadStream(zipPath), {
-        filename: 'upload.zip',
-        contentType: 'application/zip',
     });
-    // 帮我计算下文件大小，变成 MB 为单位
-    const fileSize = fs.statSync(zipPath).size / 1024 / 1024;
-    spinner.text = chalk.cyan.bold(`Start upload Game assets to client, size: ${fileSize.toFixed(2)} MB`);
-    const { clientHttpPort, clientHost } = store.getState();
-    const url = `http://${clientHost}:${clientHttpPort}/game/upload`;
-    try {
-        // 1. 创建请求流
-        const stream = got.stream.post(url, {
-            body: form,
+    /**
+     * 开始代码分包
+     */
+    app.post('/game/wasm-split', async (req, res) => {
+        const { clientKey, codeMd5 } = req.body;
+        console.log('wasm-split-start', req.body);
+        const response = await startSplit({
+            client_key: clientKey,
+            wasm_md5: codeMd5,
         });
-        const handleProgress = progress => {
-            const percent = progress.percent;
-            // const transferred = progress.transferred;
-            // const total = progress.total;
-            spinner.text = chalk.cyan.bold(`Uploading game assets to client... ${(percent * 100).toFixed(0)}%`);
-            callback({
-                status: 'process',
-                percent,
+        if (response.error) {
+            res.send({
+                code: errorCode,
+                error: response.error,
+                ctx: response.ctx,
             });
-        };
-        stream.on('uploadProgress', handleProgress);
-        const chunks = [];
-        // 当流传输数据时，收集数据块
-        stream.on('data', chunk => {
-            chunks.push(chunk);
+        }
+        else {
+            res.send({
+                code: successCode,
+                data: response.data,
+                ctx: response.ctx,
+            });
+        }
+    });
+    app.get('/game/wasm-taskinfo', async (req, res) => {
+        const { clientKey, codeMd5 } = req.query;
+        console.log('wasm-taskinfo', req.query);
+        const response = await getTaskInfo({
+            client_key: clientKey,
+            wasm_md5: codeMd5,
+        });
+        if (response.error) {
+            res.send({
+                code: errorCode,
+                error: response.error,
+                ctx: response.ctx,
+            });
+        }
+        else {
+            res.send({
+                code: successCode,
+                data: response.data?.result || {},
+                ctx: response.ctx,
+            });
+        }
+    });
+    app.post('/game/wasm-set-collect', async (req, res) => {
+        const { clientKey, codeMd5 } = req.body;
+        console.log('wasm-set-collect', req.body);
+        const response = await setCollect({
+            client_key: clientKey,
+            wasm_md5: codeMd5,
         });
-        // 当流成功结束时
-        stream.on('end', () => {
-            spinner.succeed(chalk.green.bold(`Upload game assets to client success! Cost: ${Date.now() - startTime}ms`));
-            callback({
-                status: 'success',
-                percent: 1,
+        if (response.error) {
+            res.send({
+                code: errorCode,
+                error: response.error,
+                ctx: response.ctx,
+            });
+        }
+        else {
+            res.send({
+                code: successCode,
+                data: response.data || {},
+                ctx: response.ctx,
             });
+        }
+    });
+    app.get('/game/wasm-collect-funcids', async (req, res) => {
+        const { clientKey, codeMd5 } = req.query;
+        console.log('wasm-collect-funcids', req.query);
+        const response = await getCollectedFuncIds({
+            client_key: clientKey,
+            wasm_md5: codeMd5,
         });
-        // 当流发生错误时
-        stream.on('error', err => {
-            stream.off('uploadProgress', handleProgress);
-            spinner.fail(chalk.red.bold(`Upload failed with error: ${err.message}, please check current debug env and try to scan qrcode to reupload again.`));
-            callback({
-                status: 'error',
-                percent: 0,
-                msg: err.message,
+        if (response.error) {
+            res.send({
+                code: errorCode,
+                error: response.error,
+                ctx: response.ctx,
+            });
+        }
+        else {
+            res.send({
+                code: successCode,
+                data: response.data?.result || {},
+                ctx: response.ctx,
             });
+        }
+    });
+    app.get('/game/wasm-collect-info', async (req, res) => {
+        const { clientKey, codeMd5 } = req.query;
+        console.log('wasm-collect-info', req.query);
+        const response = await getCollecttingInfo({
+            client_key: clientKey,
+            wasm_md5: codeMd5,
         });
-    }
-    catch (err) {
-        callback({
-            status: 'error',
-            percent: 0,
-            msg: err?.message,
+        if (response.error) {
+            res.send({
+                code: errorCode,
+                error: response.error,
+                ctx: response.ctx,
+            });
+        }
+        else {
+            res.send({
+                code: successCode,
+                data: response.data?.result || {},
+                ctx: response.ctx,
+            });
+        }
+    });
+    /**
+     * 获取代码分包结果
+     */
+    app.post('/game/wasm-split-result', async (req, res) => {
+        const { codeMd5, clientKey } = req.body;
+        console.log('wasm-split-result', req.body);
+        const response = await getTaskStatus({
+            client_key: clientKey,
+            wasm_md5: codeMd5,
         });
-        process.stdout.write('\n');
-        console.log('\n');
-        console.error(chalk.red.bold('✖ Upload failed with server error, please scan qrcode to reupload'));
-    }
-}
-
-function listen() {
-    eventEmitter.on('startUpload', () => {
-        /**
-         * 如果还在编译中，需要等到编译结束再上传
-         */
-        if (store.getState().isUnderCompiling) {
-            store.setState({
-                isWaitingForUpload: true,
+        if (response.error) {
+            res.send({
+                code: errorCode,
+                error: response.error,
+                ctx: response.ctx,
             });
-            return;
         }
-        wsServer.sendUploadStatus('start');
-        uploadGame(({ status, percent, msg }) => {
-            if (status === 'process') {
-                wsServer.sendUploadStatus('process', {
-                    status: 'process',
-                    progress: percent,
-                });
-            }
-            else if (status === 'error') {
-                wsServer.sendUploadStatus('error', {
-                    status: 'error',
-                    errMsg: msg,
-                    isSuccess: false,
-                });
-            }
-            else if (status === 'success') {
-                wsServer.sendUploadStatus('success', {
-                    status: 'success',
-                    packages: store.getState().packages,
-                    clientKey: getClientKey().clientKey,
-                    isSuccess: true,
-                });
-            }
+        else {
+            res.send({
+                code: successCode,
+                data: response.data?.result || {},
+                ctx: response.ctx,
+            });
+        }
+    });
+    /**
+     *
+  高鹏
+  抄一下码下面的话
+  我试试这个咋样看[看]闵行的是好吃的
+  可以
+  下周大哥来 让他别整一群的 就咱们几个吃个串挺好
+  哪个unity筹备群拉你了哈
+  好
+  新知识 30% 等于部分用户
+  0.3.1-unity.6
+  {
+      "code": 0,
+      "data": {
+          "isSuccess": true
+      },
+      "msg": "download success",
+      "ctx":
+  }
+  发现个小问题
+  wasmcode1-ios 下面下载缺了一个func_bytes_range.json 以及subjs.data.br 多了一个 br 后缀
+     ​​​
+  Shift + Enter 换行
+  
+     */
+    app.post('/game/wasm-split-download-result', async (req, res) => {
+        const { clientKey, codeMd5, codePath } = req.body;
+        console.log('game/wasm-split-download-result-start', req.body);
+        const response = await getSplitResult({
+            client_key: clientKey,
+            wasm_md5: codeMd5,
+            wasm_path: codePath,
         });
+        if (response.error) {
+            res.send({
+                code: errorCode,
+                error: response.error,
+                ctx: response.ctx,
+            });
+        }
+        else {
+            res.send({
+                code: successCode,
+                data: response.data || {},
+                msg: 'download success',
+                ctx: response.ctx,
+            });
+        }
     });
-    eventEmitter.on('compileSuccess', () => {
-        /**
-         * 如果有等待上传的任务，需要触发上传
-         */
-        if (store.getState().isWaitingForUpload) {
-            eventEmitter.emit('startUpload', {});
-            store.setState({
-                isWaitingForUpload: false,
+    app.post('/game/wasm-split-download', async (req, res) => {
+        console.log('game/wasm-split-download-start', req.body);
+        const response = await downloadSplited(req.body);
+        console.log('game/wasm-split-download-end', response);
+        if (response.error) {
+            res.send({
+                code: errorCode,
+                error: response.error,
+                ctx: response.ctx,
+            });
+        }
+        else {
+            res.send({
+                code: successCode,
+                data: response.data || {},
+                msg: 'download success',
+                ctx: response.ctx,
             });
         }
     });
-}
-
-async function init() {
-    const promptModule = inquirer.createPromptModule();
-    const { clientKey: lastUsedClientKey } = getTTMGRC() || {};
-    if (lastUsedClientKey) {
-        const { selectedClientKey } = await promptModule([
-            {
-                type: 'list',
-                name: 'selectedClientKey',
-                message: 'Select game client key for debugging:',
-                choices: [{
-                        name: `${lastUsedClientKey} (last used)`,
-                        value: lastUsedClientKey,
-                    }, {
-                        name: 'Add a new client key',
-                        value: 'new',
-                    }],
-            },
-        ]);
-        if (selectedClientKey === 'new') {
-            /**
-             * 输入新的 clientKey
-             */
-            const { clientKey } = await promptModule([
-                {
-                    type: 'input',
-                    name: 'clientKey',
-                    message: 'Input new client key:',
-                    validate: input => {
-                        if (!input) {
-                            return 'Client key is required, please input client key';
-                        }
-                        return true;
-                    },
-                },
-            ]);
-            setTTMGRC({
-                clientKey,
+    app.post('/game/wasm-cancel', async (req, res) => {
+        const { clientKey, codePath } = req.body;
+        console.log('wasm-cancel', req.body);
+        await cancelSplit({
+            wasmCodePath: codePath,
+        });
+        res.send({
+            code: successCode,
+            msg: 'cancel success',
+        });
+    });
+    app.post('/game/wasm-split-reset', async (req, res) => {
+        const { clientKey, codeMd5, codePath } = req.body;
+        console.log('wasm-split-reset', req.body);
+        const response = await resetWasmSplit({
+            clientkey: clientKey,
+            wasmMd5: codeMd5});
+        if (response.error) {
+            res.send({
+                code: errorCode,
+                error: response.error,
+                ctx: response.ctx,
             });
         }
         else {
-            // 并将 selectedClientKey 放到最前面
-            setTTMGRC({
-                clientKey: selectedClientKey,
+            res.send({
+                code: successCode,
+                data: response.data || {},
+                ctx: response.ctx,
             });
         }
-    }
-    else {
-        // 没有历史 clientKey，直接输入新的 clientKey
-        const { clientKey } = await promptModule([
-            {
-                type: 'input',
-                name: 'clientKey',
-                message: 'Input your Client Key:',
-                validate: input => {
-                    if (!input) {
-                        return 'Client key is required, please input client key';
-                    }
-                    return true;
-                },
-            },
-        ]);
-        setTTMGRC({
-            clientKey,
+    });
+    app.get('*', (req, res) => {
+        res.sendFile(path.join(publicPath, `index.html`));
+    });
+    // --- 中间件和路由设置结束 ---
+    // 步骤 2: 用配置好的 app 实例创建一个 http.Server。我们只创建这一次！
+    const server = http.createServer(app);
+    /**
+     * @description 尝试在指定端口启动服务。这是个纯粹的辅助函数。
+     * @param {number} port - 要尝试的端口号。
+     * @returns {Promise<boolean>} 成功返回 true，因端口占用失败则返回 false。
+     */
+    function tryListen(port) {
+        return new Promise(resolve => {
+            // 定义错误处理函数
+            const onError = err => {
+                // 清理掉另一个事件的监听器，防止内存泄漏
+                server.removeListener('listening', onListening);
+                if (err.code === 'EADDRINUSE') {
+                    console.log(chalk(`Port ${port} is already in use, trying ${port + 1}...`));
+                    resolve(false); // 明确表示因端口占用而失败
+                }
+                else {
+                    // 对于其他致命错误，直接退出进程
+                    console.log(chalk.red.bold(err.message));
+                    process.exit(1);
+                }
+            };
+            // 定义成功处理函数
+            const onListening = () => {
+                // 清理掉另一个事件的监听器
+                server.removeListener('error', onError);
+                resolve(true); // 明确表示成功
+            };
+            // 使用 .once() 来确保监听器只执行一次然后自动移除
+            server.once('error', onError);
+            server.once('listening', onListening);
+            // 执行监听动作
+            server.listen(port);
         });
     }
-}
-
-/**
- * 检查当前目录是否为 Mini Game 项目的入口目录
- */
-function checkEntry() {
-    const entryFiles = NATIVE_GAME_ENTRY_FILES.map(file => path.join(process.cwd(), file));
-    const foundEntryFile = entryFiles.find(file => fs.existsSync(file));
-    if (!foundEntryFile) {
-        /**
-         * 如果当前目录下没有任何一个入口文件，提示用户检查当前目录是否为 Mini Game 项目的入口目录，需要提醒开发者进入到游戏项目根目录进行调试
-         */
-        console.error(chalk.red.bold(`Current directory is not a Mini Game project entry directory, please enter the game project root directory for debugging`));
+    // 步骤 3: 使用循环来线性、串行地尝试启动服务
+    let isListening = false;
+    const maxRetries = 20; // 设置一个最大重试次数，以防万一
+    for (let i = 0; i < maxRetries; i++) {
+        const currentPort = store.getState().nodeServerPort;
+        isListening = await tryListen(currentPort);
+        if (isListening) {
+            break; // 成功，跳出循环
+        }
+        else {
+            // 失败（端口占用），更新端口号，准备下一次循环
+            store.setState({ nodeServerPort: currentPort + 1 });
+        }
+    }
+    // 步骤 4: 检查最终结果，如果所有尝试都失败了，则退出
+    if (!isListening) {
+        console.log(chalk.red.bold(`Failed to start server after trying ${maxRetries} ports.`));
         process.exit(1);
     }
+    // --- 服务启动成功后的逻辑 ---
+    // @ts-ignore
+    const finalPort = server.address().port; // 从成功的 server 实例安全地获取最终端口
+    console.log(chalk.green.bold(`TTMG`), chalk.green(`v${devToolVersion}`), chalk.gray(`ready in`), chalk.bold(`${Date.now() - startTime}ms`));
+    const baseUrl = `http://localhost:${finalPort}?v=${devToolVersion}`;
+    showTips({ server: baseUrl });
+    openUrl(baseUrl);
 }
 
 async function dev() {
@@ -1911,7 +3218,7 @@ async function dev() {
     watch();
 }
 
-var version = "0.3.1-login.2";
+var version = "0.3.1-unity.10";
 var pkg = {
 	version: version};