@ttmg/cli 0.1.9-beta.7 → 0.1.9-beta.9

package/README.md

@@ -1,72 +1,40 @@
-## @ttmg/cli
+### @ttmg/cli
+`ttmg` is a command-line tool designed for managing and developing mini-game projects. It supports initialization, development, debugging, and packaging for both H5 and native mini-games.
+`ttmg` 是一款专为小游戏项目管理与开发设计的命令行工具，支持 H5 小游戏和原生小游戏的初始化、开发调试及打包构建。
+#### Installation 安装
 
-`ttmg` 是一个用于管理和开发小游戏项目的命令行工具，支持 H5 小游戏和原生小游戏的初始化、开发调试和打包构建。
-
-### 安装
-
-你可以通过 npm 本地安装或全局安装：
+You can install `ttmg` globally or as a project dependency via npm:
+你可以通过 npm 全局或本地安装 `ttmg`：
 
 ```
 npm install @ttmg/cli -g
 ```
 
-或者在项目中作为开发依赖：
+Or add it as a development dependency in your project:
+或者作为项目开发依赖安装：
 
 ```
 npm install @ttmg/cli --save-dev
 ```
 
-### 使用方法
-
-安装后，可以在命令行中使用 `ttmg` 命令。
-
-#### 查看帮助
-
-```
-ttmg --help
-```
-
-#### 命令说明
-
-##### 1. 初始化项目
-
-- 对基于游戏引擎构建好的 H5 小游戏进行初始化
-
-```
-ttmg init --h5
-```
-
-- 对基于游戏引擎构建好的 Native 小游戏进行初始化
-
-```
-ttmg init --native
-```
-
-##### 2. 开发调试
+#### Login 登录
 
-启动本地开发环境，打开浏览器进行调试。
-
-- H5 小游戏调试
-
-```
-ttmg dev --h5
-```
-
-- 原生小游戏调试
+Before running any `ttmg` commands, please log in with your TikTok account. Once logged in, the tool will automatically use your account for project initialization, development, debugging, and packaging.
+在首次使用 `ttmg` 命令前，请先登录你的 TikTok 账号。登录后，工具会自动使用该账号进行项目初始化、开发调试和打包构建。
 
 ```
-ttmg dev --native
+ttmg login
 ```
 
-##### 3. 项目打包
-
-打包项目用于发布。
+#### Debugging 调试
 
-- 打包 H5 小游戏
+- By default, debug native mini-games:
+- 默认调试原生小游戏：
 
 ```
-ttmg build --h5
+ttmg dev
 ```
 
-- 打包原生小游戏
-  ttmg build --native
+- 调试 H5 小游戏：
+- To debug H5 mini-games:
+  ttmg dev --h5

package/dist/index.js

@@ -17,13 +17,15 @@ 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 = require('form-data');
+var FormData$1 = require('form-data');
 
 function _interopNamespaceDefault(e) {
   var n = Object.create(null);
@@ -243,27 +245,26 @@ async function checkUpdate() {
     });
 }
 
-let config$1 = null;
+let config = null;
 const CONFIG_PATH = path.join(os.homedir(), '.ttmgrc');
-const getTTmgrcConfig = () => {
-    if (config$1) {
-        return config$1;
+const getTTMGRC = () => {
+    if (config) {
+        return config;
     }
     else {
         // only check one time
         if (!fs.existsSync(CONFIG_PATH)) {
-            fs.writeFileSync(CONFIG_PATH, '{}');
-            return {};
+            return null;
         }
         else {
             // safe parse
             let res = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
-            config$1 = res;
+            config = res;
             return res;
         }
     }
 };
-const setTTmgrcConfig = (config) => {
+const setTTMGRC = (config) => {
     // updata cache config
     config = config;
     fs.writeFileSync(CONFIG_PATH, JSON.stringify(config));
@@ -335,27 +336,26 @@ async function login() {
             user_id: response?.data?.data?.user_id,
             cookie: response?.headers['set-cookie'].join('; '),
         };
-        setTTmgrcConfig(data);
+        setTTMGRC(data);
         spinner$2.succeed(chalk.bold.green('login successfully!'));
         process.exit(0);
     }
 }
 
-/**
- * 获取配置文件中的 cookie
- */
-const config = getTTmgrcConfig();
-const cookie = config.cookie;
-axios.defaults.headers.common['Cookie'] = cookie;
 // ppe_dev_tool
 async function request({ url, method, data, headers, params, }) {
+    const config = getTTMGRC();
+    const cookie = config?.cookie;
     try {
         const res = await axios({
             url,
             method,
             data,
             params,
-            headers,
+            headers: {
+                ...(headers || {}),
+                Cookie: cookie,
+            },
         });
         return {
             data: res.data,
@@ -399,16 +399,35 @@ async function fetchGameInfo(gameId) {
     }
 }
 
+async function uploadGameToPlatform({ data, name, gameId, desc = '--', }) {
+    const formData = new FormData();
+    formData.append('file', new Blob([data], { type: 'application/zip' }), name);
+    formData.append('client_key', gameId);
+    formData.append('desc', desc);
+    const response = await request({
+        method: 'POST',
+        url: 'https://developers.tiktok.com/tiktok/v3/devportal/minigame/devtool/upload',
+        data: formData,
+        headers: {
+            'x-use-ppe': '1',
+            'x-tt-env': 'ppe_dev_tool',
+            // @ts-ignore
+            'Content-Type': `multipart/form-data; boundary=${formData._boundary}`,
+        },
+    });
+    return {
+        data: response?.data,
+        error: response?.error,
+    };
+}
+
 function getCurrentUser() {
     try {
-        const config = getTTmgrcConfig();
-        return {
-            email: config?.email || '',
-            user_id: config?.user_id || '',
-        };
+        const config = getTTMGRC();
+        return config;
     }
     catch (err) {
-        return {};
+        return null;
     }
 }
 
@@ -729,10 +748,67 @@ function getOutputDir() {
     return path.join(os.homedir(), '__TTMG__', clientKey);
 }
 
-const DEV_PORT = 9528;
-const DEV_WS_PORT = 9529;
+const DEV_PORT = 3000;
+const DEV_WS_PORT = 4000;
 path.join(os.homedir(), '__TTMG__');
 
+// store.ts
+class Store {
+    constructor(initialState) {
+        this.listeners = [];
+        this.state = initialState;
+    }
+    // 获取单例实例
+    static getInstance(initialState) {
+        if (!Store.instance) {
+            Store.instance = new Store(initialState);
+        }
+        return Store.instance;
+    }
+    // 获取状态
+    getState() {
+        return this.state;
+    }
+    // 设置状态
+    setState(newState) {
+        this.state = { ...this.state, ...newState };
+        this.listeners.forEach(listener => listener(this.state));
+    }
+    // 订阅状态变化
+    subscribe(listener) {
+        this.listeners.push(listener);
+        return () => {
+            this.listeners = this.listeners.filter(l => l !== listener);
+        };
+    }
+    // 重置状态
+    reset(newState) {
+        this.state = newState;
+        this.listeners.forEach(listener => listener(this.state));
+    }
+}
+const store = Store.getInstance({
+    clientHost: '',
+    clientHttpPort: '',
+    clientWsPort: '',
+    clientWsHost: '',
+    clientKey: '',
+    nodeServerPort: DEV_PORT,
+    nodeWsPort: DEV_WS_PORT,
+    packages: {},
+    isUnderCompiling: false,
+    isWaitingForUpload: false,
+    projectInfo: {
+        projectSize: 0,
+        mainPkg: {
+            pkgSize: 0,
+            isMatchSizeLimit: false,
+        },
+        independentPkgs: {},
+    },
+    checkResults: [],
+});
+
 function showTips(context) {
     console.log(chalk.gray('─────────────────────────────────────────────'));
     console.log(chalk.yellow.bold('1.') +
@@ -753,76 +829,55 @@ function showTips(context) {
 }
 
 const successCode = 0;
+const errorCode = -1;
 const outputDir = getOutputDir();
 const publicPath = path.join(__dirname, 'public');
-let server;
 async function start() {
     const startTime = Date.now();
-    if (server) {
-        closeServer();
-    }
     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('Access-Control-Allow-Headers', 'Content-Type, Authorization');
         next();
     });
-    const port = DEV_PORT;
     app.use(express.json());
-    // 解析 FormData body
     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 { email, user_id } = getCurrentUser();
+        const basic = await ttmgPack.getPkgs({ entryDir: process.cwd() });
+        const user = getCurrentUser();
         const { clientKey } = getClientKey();
         res.send({
             error: null,
             data: {
-                email,
-                user_id,
+                user,
                 code: successCode,
-                nodeWsPort: DEV_WS_PORT,
+                nodeWsPort: store.getState().nodeWsPort,
                 clientKey: clientKey,
-                schema: `https://www.tiktok.com/ttmg/dev/${clientKey}?host=${getLocalIP()}&port=${DEV_WS_PORT}`,
+                schema: `https://www.tiktok.com/ttmg/dev/${clientKey}?host=${getLocalIP()}&port=${store.getState().nodeWsPort}`,
                 ...basic,
                 devToolVersion: require(path.join(__dirname, 'package.json')).version,
             },
         });
     });
     app.get('/game/detail', async (req, res) => {
-        const basic = await ttmgPack.getPkgs({
-            entryDir: process.cwd(),
-        });
+        const basic = await ttmgPack.getPkgs({ entryDir: process.cwd() });
         const { clientKey } = getClientKey();
         const { error, data: gameInfo } = await fetchGameInfo(clientKey);
         if (error) {
-            res.send({
-                error,
-                data: null,
-            });
+            res.send({ error, data: null });
             return;
         }
-        res.send({
-            error: null,
-            data: {
-                ...basic,
-                ...gameInfo,
-            },
-        });
+        else {
+            res.send({ error: null, data: { ...basic, ...gameInfo } });
+        }
     });
     app.get('/game/check', async (req, res) => {
         const checkResult = await ttmgPack.checkPkgs({
@@ -832,7 +887,7 @@ async function start() {
                 output: outputDir,
                 dev: {
                     enable: true,
-                    port: DEV_PORT,
+                    port: store.getState().nodeServerPort,
                     host: 'localhost',
                     enableSourcemap: false,
                     enableLog: false,
@@ -845,36 +900,113 @@ async function start() {
                 },
             },
         });
-        res.send({
-            code: successCode,
-            data: checkResult,
-        });
+        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'];
+            // 直接传递需要的信息
+            const { data, error } = await uploadGameToPlatform({
+                data: uploadedFile.data, // 这是 Buffer
+                name: uploadedFile.name, // 这是文件名
+                gameId: getClientKey().clientKey,
+                desc,
+            });
+            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 状态码
+        }
     });
     app.get('*', (req, res) => {
         res.sendFile(path.join(publicPath, 'index.html'));
     });
-    // 启动服务
-    server = await new Promise((resolve, reject) => {
-        const server = app.listen(port, () => {
-            /**
-             * 获取当前版本号
-             */
-            const version = require(path.join(__dirname, 'package.json')).version;
-            console.log(chalk.green.bold(`TTMG`), chalk.green(`v${version}`), chalk.gray(`ready in`), chalk.bold(`${Date.now() - startTime}ms`));
-            resolve(server);
+    // --- 中间件和路由设置结束 ---
+    // 步骤 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);
         });
-    });
-    const baseUrl = `http://localhost:${port}`;
+    }
+    // 步骤 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 实例安全地获取最终端口
+    const version = require(path.join(__dirname, 'package.json')).version;
+    console.log(chalk.green.bold(`TTMG`), chalk.green(`v${version}`), chalk.gray(`ready in`), chalk.bold(`${Date.now() - startTime}ms`));
+    const baseUrl = `http://localhost:${finalPort}`;
     showTips({ server: baseUrl });
     openUrl(baseUrl);
 }
-function closeServer() {
-    server.close(() => {
-        console.log('Dev server closed');
-        server = null;
-        process.exit(0);
-    });
-}
 
 /**
  * 一个类型安全的、通用的事件发射器类。
@@ -951,63 +1083,12 @@ class TypedEventEmitter {
 }
 const eventEmitter = new TypedEventEmitter();
 
-class Store {
-    constructor(initialState) {
-        this.listeners = [];
-        this.state = initialState;
-    }
-    // 获取单例实例
-    static getInstance(initialState) {
-        if (!Store.instance) {
-            Store.instance = new Store(initialState);
-        }
-        return Store.instance;
-    }
-    // 获取状态
-    getState() {
-        return this.state;
-    }
-    // 设置状态
-    setState(newState) {
-        this.state = { ...this.state, ...newState };
-        this.listeners.forEach(listener => listener(this.state));
-    }
-    // 订阅状态变化
-    subscribe(listener) {
-        this.listeners.push(listener);
-        return () => {
-            this.listeners = this.listeners.filter(l => l !== listener);
-        };
-    }
-    // 重置状态
-    reset(newState) {
-        this.state = newState;
-        this.listeners.forEach(listener => listener(this.state));
-    }
-}
-const store = Store.getInstance({
-    clientHost: '',
-    clientHttpPort: '',
-    clientWsPort: '',
-    clientWsHost: '',
-    clientKey: '',
-    packages: {},
-    isUnderCompiling: false,
-    isWaitingForUpload: false,
-    projectInfo: {
-        projectSize: 0,
-        mainPkg: {
-            pkgSize: 0,
-            isMatchSizeLimit: false,
-        },
-        independentPkgs: {},
-    },
-    checkResults: [],
-});
-
 class WsServer {
     constructor() {
-        this.ws = new WebSocket.Server({ port: DEV_WS_PORT });
+        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) {
@@ -1041,8 +1122,6 @@ class WsServer {
                              * 关闭调试服务
                              */
                             this.ws.close();
-                            closeServer();
-                            console.log('close server');
                             break;
                     }
                 }
@@ -1112,6 +1191,18 @@ class WsServer {
                 }
             });
         });
+        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 => {
@@ -1225,7 +1316,7 @@ function compile(context) {
             context: {
                 clientKey,
                 outputDir,
-                devPort: DEV_PORT,
+                devPort: store.getState().nodeServerPort,
                 entryDir,
             },
         });
@@ -1331,7 +1422,7 @@ async function zipDirectory(sourceDir, outPath) {
 }
 async function uploadZip(zipPath, callback) {
     const startTime = Date.now();
-    const form = new FormData();
+    const form = new FormData$1();
     form.append('file', fs.createReadStream(zipPath), {
         filename: 'upload.zip',
         contentType: 'application/zip',
@@ -1467,7 +1558,7 @@ async function upload() {
     });
 }
 
-var version = "0.1.9-beta.7";
+var version = "0.1.9-beta.9";
 var pkg = {
 	version: version};