tt-minigame-ide-cli 0.0.1-beta.0

package/lib/create.js

@@ -0,0 +1,106 @@
+// 创建小程序模版
+const fs = require('fs-extra');
+const path = require('path');
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const axios = require('axios');
+const unzipper = require('unzipper');
+const { createProjectConfigFile } = require('./util/config');
+const { clearConsole } = require('./util/logger');
+const { getVersion } = require('./util/version');
+const TEMPLATE_DOWNLOAD_URL = 'https://sf1-cdn-tos.douyinstatic.com/obj/microapp/frontend/ide/template/tma-showcase.zip';
+
+async function create(projectName, options) {
+  const cwd = options.cwd || process.cwd();
+  const targetDir = path.resolve(cwd, projectName || '.');
+  clearConsole(chalk.bold.green(`miniprogram ide CLI v${getVersion()}`));
+  if (fs.existsSync(targetDir)) {
+    if (options.force) {
+      await fs.remove(targetDir);
+    } else {
+      const { action } = await inquirer.prompt([
+        {
+          name: 'action',
+          type: 'list',
+          message: `Target directory ${chalk.cyan(targetDir)} already exists. Pick an action:`,
+          choices: [
+            { name: 'Overwrite', value: 'overwrite' },
+            { name: 'Cancel', value: false }
+          ]
+        }
+      ]);
+      if (!action) {
+        return;
+      } else if (action === 'overwrite') {
+        console.log(`\nRemoving ${chalk.cyan(targetDir)}...`);
+        await fs.remove(targetDir);
+      }
+    }
+  }
+  // Choose template
+  const { action } = await inquirer.prompt([
+    {
+      name: 'action',
+      type: 'list',
+      message: `Please select a template:`,
+      choices: [
+        { name: 'Blank template', value: 'blank' },
+        { name: 'Capability-rich template', value: 'rich' },
+        { name: 'Cancel', value: false }
+      ]
+    }
+  ]);
+
+  if (!action) return;
+  
+  fs.ensureDirSync(targetDir);
+  if (action === 'rich') {
+    // Pull the template from the web
+    console.log(`⚙\u{fe0f}   Installing template. This might take a while....`);
+    await downloadRemoteTemplate(TEMPLATE_DOWNLOAD_URL, targetDir)
+  } else {
+    // Copy template from local
+    await fs.copy(path.join(__dirname, '../template'), targetDir);
+    await createProjectConfigFile(projectName, targetDir);
+  }
+
+  console.log(`🎉  Successfully created project ${chalk.yellow(projectName)}.`);
+}
+
+async function downloadRemoteTemplate(sourcePath, targetPath) {
+  return new Promise(async (resolve, reject) => {
+    const zipPath = path.join(targetPath, 'template.zip');
+    const stream = fs.createWriteStream(zipPath);
+    const response = await axios({
+      url: sourcePath,
+      method: "GET",
+      responseType: "stream",
+    });
+    response.data.pipe(stream);
+
+    stream.on('finish', () => {
+      fs.createReadStream(zipPath).
+        pipe(unzipper.Extract({ path: targetPath }))
+          .on('close', () => {
+            fs.unlinkSync(zipPath);
+            resolve();
+          })
+          .on('error', (err) => {
+            fs.unlinkSync(zipPath);
+            reject(err);
+          });
+    });
+
+    stream.on('error', (err) => {
+      reject(err);
+    });
+  });
+}
+
+
+module.exports = (...args) => {
+  return create(...args).catch(err => {
+    console.log(chalk.red(`[CLI CREATE ERROR]: ${err}`));
+    process.exit(1);
+  });
+}

package/lib/index.d.ts

@@ -0,0 +1,23 @@
+interface PreviewOptions {
+	entry?: string;
+	copy?: boolean;
+	force?: boolean;
+	small?: boolean;
+	proxy?: string;
+}
+
+interface UploadOptions {
+	entry?: string;
+	version: string;
+	changeLog: string;
+	proxy?: string;
+	copy?: boolean;
+}
+
+declare namespace ttIdeCli {
+	function create(projectName: string, options: { force?: boolean }): void;
+	function loginByName(email: string, password: string): void;
+	function login(options: { type?: string; proxy?: string }): void;
+	function preview(options: PreviewOptions): void;
+	function upload(options: UploadOptions): void;
+}

package/lib/index.js

@@ -0,0 +1,79 @@
+const _preview = require('./preview');
+const _upload = require('./upload');
+const _create = require('./create');
+const _auth = require('./auth');
+const buildNpm = require('./build-npm');
+const config = require('./util/config');
+const cookieHandler = require('./util/cookie');
+
+function create(projectName, { force = false }) {
+	return _create(projectName, {
+		force,
+	});
+}
+
+function loginByEmail(email, password, customOptions) {
+	const options = {
+		type: 'direct',
+		email,
+		password,
+		...customOptions,
+	};
+
+	return _auth(options);
+}
+
+function login({ type = '', proxy = '' }) {
+	if (type === 'mobile' || type === 'email') {
+		return _auth({ [type]: true, proxy });
+	} else {
+		return _auth({ proxy });
+	}
+}
+
+function preview({
+	entry = '',
+	copy = false,
+	force = false,
+	small = false,
+	proxy = '',
+	tempDir = null
+}) {
+	return _preview(entry, {
+		copy,
+		force,
+		small,
+		proxy,
+		tempDir,
+	});
+}
+
+function upload({ entry = '', version, changeLog, proxy = '', copy = false, tempDir = null }) {
+	return _upload(entry, {
+		appVersion: version,
+		appChangelog: changeLog,
+		proxy,
+		copy,
+		tempDir
+	});
+}
+
+function setConfig(customConfig) {
+	console.log('configconfigconfig=:', customConfig);
+	return config.setConfig(customConfig);
+}
+
+async function checkSession() {
+	return await cookieHandler.checkSession();
+}
+
+module.exports = {
+	create,
+	loginByEmail,
+	login,
+	preview,
+	upload,
+	buildNpm,
+	setConfig,
+	checkSession,
+};

package/lib/preview.js

@@ -0,0 +1,86 @@
+// Preview project
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const { hashElement } = require('folder-hash');
+const { outputResult, clearConsole } = require('./util/logger');
+const { checkBeforeUpload } = require('./util/check');
+const { zipFile, savePreviewResult, getCachedPreviewResult } = require('./util/helper');
+const { uploadProject, getCompileProgress, getQrCode } = require('./util/request');
+const { generateQrCode } = require('./util/qrcode');
+
+async function preview(entry, options) {
+  const cwd = options.cwd || process.cwd();
+  if (!entry || entry === '.') {
+    entry = cwd;
+  } else {
+    entry = path.resolve(cwd, entry);
+  }
+  const dirHash = await hashElement(entry, { folders: { exclude: ['node_modules'] } });
+  const cacheDisabled = options.force || options.disableCache;
+  if (!cacheDisabled) {
+    // check local cache
+    const cacheRet = getCachedPreviewResult('native', dirHash.hash);
+    if (cacheRet) {
+      generateQrCode(cacheRet, options);
+      console.log(chalk.cyan(`Since local files have not changed, use the cache result\nUse option ${chalk.yellow('-f')} to ignore cache`));
+      return;
+    }
+  }
+
+  const { success, msg, appId } = await checkBeforeUpload(entry);
+  if (!success) {
+    const errMsg = `[CLI PREVIEW ERROR]: ${msg}`;
+    console.log(chalk.red(errMsg));
+    throw new Error(errMsg);
+    return;
+  }
+
+  const tempDir = options.tempDir || path.join(__dirname, '../temp');
+  await fs.emptyDir(tempDir);
+  const { filePath } = await zipFile(entry, tempDir);
+  if (!filePath) {
+    const errMsg = `[CLI PREVIEW ERROR]`;
+    console.log(chalk.red(errMsg));
+    throw new Error(errMsg);
+    return;
+  }
+  await uploadProject({ type: 'preview', appId, zipPath: filePath, proxy: options.proxy });
+
+  outputResult('info', 'WAIT', 'Compiling...\n');
+  return await new Promise((resolve, reject) => {
+    const timer = setInterval(async () => {
+      const { success, msg, done } = await getCompileProgress(appId, options.proxy);
+      if (!success) {
+        const errMsg = `[CLI PREVIEW ERROR]: ${msg}`;
+        console.log(chalk.red(errMsg));
+        clearInterval(timer);
+        reject(errMsg);
+        return;
+      }
+      if (success && done) {
+        clearInterval(timer);
+        const ret = await getQrCode(appId, options.proxy);
+        if (ret.success) {
+          clearConsole();
+          outputResult('success', `DONE`, `Scan the QR Code for remote preview\n`);
+          generateQrCode(ret.url, options);
+          // save preview result
+          savePreviewResult(ret.url, 'native', dirHash.hash);
+          resolve(ret.url);
+        } else {
+          console.log(chalk.red(`[CLI PREVIEW ERROR]: ${ret.msg}`));
+          reject(ret.msg);
+        }
+      }
+    }, 1500);
+  });
+}
+
+module.exports = (...args) => {
+  return preview(...args).catch(err => {
+    const errMsg = `[CLI PREVIEW ERROR]: ${err}`;
+    console.log(chalk.red(errMsg));
+    throw new Error(errMsg);
+  });
+}

package/lib/upload.js

@@ -0,0 +1,120 @@
+// Upload project
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const {
+    outputResult,
+    clearConsole
+} = require('./util/logger');
+const {
+    checkBeforeUpload,
+    isValidAppVersion
+} = require('./util/check');
+const {
+    zipFile
+} = require('./util/helper');
+const {
+    uploadProject,
+    getCompileProgress,
+    checkUserPermissions,
+    getQrCode
+} = require('./util/request');
+const {
+    generateQrCode
+} = require('./util/qrcode');
+
+async function upload(entry, options) {
+    const cwd = options.cwd || process.cwd();
+    if (!entry) {
+      entry = cwd
+    } else if (path.isAbsolute(entry)) {
+        // skip if entry if absolute path
+    } else {
+        // resolve the relative entry with cwd
+        entry = path.resolve(cwd, entry);
+    }
+
+    if (!isValidAppVersion(options.appVersion)) {
+        const errMsg = `[CLI UPLOAD ERROR]: App version ${options.appVersion} is not valid, expected [major].[minor].[patch]`;
+        console.log(chalk.red(errMsg));
+        throw new Error(errMsg);
+    }
+
+    const {
+        success: beforeSuccess,
+        msg: beforeMsg,
+        appId
+    } = await checkBeforeUpload(entry);
+    if (!beforeSuccess) {
+        const errMsg = `[CLI UPLOAD ERROR]: ${beforeMsg}`;
+        console.log(chalk.red(errMsg));
+        throw new Error(errMsg);
+    }
+    const tempDir = options.tempDir || path.join(__dirname, '../temp');
+    await fs.emptyDir(tempDir);
+
+    const {
+        success: authSuccess,
+        msg: authMsg
+    } = await checkUserPermissions(appId, options.proxy);
+    if (!authSuccess) {
+        const errMsg = `[CLI UPLOAD ERROR]: ${authMsg}`;
+        console.log(chalk.red(errMsg));
+        throw new Error(errMsg);
+    }
+
+    const { filePath } = await zipFile(entry, tempDir);
+    if (!filePath) {
+        const errMsg = `[CLI UPLOAD ERROR]`;
+        console.log(chalk.red(errMsg));
+        throw new Error(errMsg);
+    }
+    await uploadProject({
+        type: 'upload',
+        appId,
+        zipPath: filePath,
+        versionInfo: options.appVersion,
+        updateInfo: options.appChangelog,
+        proxy: options.proxy,
+    });
+
+    outputResult('info', 'WAIT', 'Compiling...\n');
+    return new Promise((resolve, reject) => {
+        const timer = setInterval(async () => {
+            const {
+                success,
+                msg,
+                done
+            } = await getCompileProgress(appId, options.proxy);
+            if (!success) {
+                const errMsg = `[CLI UPLOAD ERROR]: ${msg}`;
+                console.log(chalk.red(errMsg));
+                clearInterval(timer);
+                reject(errMsg);
+            }
+            if (success && done) {
+                clearConsole();
+                outputResult('success', `v${options.appVersion}`, ` 🎉 Successfully uploaded project`);
+                const ret = await getQrCode(appId, options.proxy, 'latest');
+                if (ret.success) {
+                    outputResult('success', `DONE`, `Scan the QR Code for remote preview\n`);
+                    generateQrCode(ret.url, options);
+                    resolve(ret.url);
+                } else {
+                    const errMsg = `[CLI UPLOAD ERROR]: ${ret.msg}`;
+                    console.log(chalk.red(errMsg));
+                    reject(ret.msg);
+                }
+                clearInterval(timer);
+            }
+        }, 1500);
+    });
+}
+
+module.exports = (...args) => {
+    return upload(...args).catch(err => {
+        const errMsg = `[CLI UPLOAD ERROR]: ${err}`;
+        console.log(chalk.red(errMsg));
+        throw new Error(errMsg);
+    });
+}

package/lib/util/check.js

@@ -0,0 +1,84 @@
+const fs = require('fs-extra');
+const chalk = require('chalk');
+const path = require('path');
+const semver = require('semver');
+const { checkRemoteVersion } = require('./request');
+const { getUserCookies } = require('./cookie');
+const { getLatestVersionFromLocal, saveLatestVersionToLocal, getVersion } = require('./version');
+
+function isValidPhoneNumber(number) {
+  return /^1[3-9]\d{9}$/.test(number);
+}
+
+function isValidVerificationCode(number) {
+  return /^\d{4}$/.test(number);
+}
+
+function isValidEmail(email) {
+  return /^([A-Za-z0-9_\-\.])+\@([A-Za-z0-9_\-\.])+\.([A-Za-z]{2,4})$/.test(email);
+}
+
+function isValidAppId(id) {
+  return /^tt[0-9a-f]{16}([0-9a-f]{2})?$/.test(id);
+}
+
+function isValidAppVersion(version) {
+  return /^\d+\.\d+\.\d+$/.test(version);
+}
+
+async function checkBeforeUpload(entry) {
+  const configPath = path.join(entry, 'project.config.json');
+  const exists = await fs.pathExists(configPath);
+  if (!exists) {
+    return {
+      success: false,
+      msg: 'Invalid project: project.config.json file not found'
+    }
+  }
+  const appConfig = await fs.readFile(configPath, 'utf-8');
+  const appConfigJSON = JSON.parse(appConfig);
+  const appId = appConfigJSON.ttappid || appConfigJSON.appid;
+  if (!isValidAppId(appId)) {
+    return { success: false, msg: `AppId ${chalk.cyan(appId)} is not valid` };
+  }
+  if (!getUserCookies()) {
+    console.log(chalk.red());
+    return {
+      success: false,
+      msg: `This feature requires login, please login via ${chalk.cyan(
+        'tmg login'
+      )} command`,
+    };
+  }
+  return { success: true, appId };
+}
+// 该方法暂无调用
+async function checkNeedUpdate() {
+  let needUpdate = false;
+  const versionCache = await getLatestVersionFromLocal();
+  const daysPassed = (Date.now() - versionCache.time || 0) / (60 * 60 * 1000 * 24);
+  if (daysPassed > 1 || !versionCache.version) {
+    const { version } = await checkRemoteVersion();
+    versionCache.version = version || '0.0.0';
+    saveLatestVersionToLocal(version, Date.now());
+  }
+  const currentVersion = getVersion();
+  if (semver.gt(versionCache.version, currentVersion)) {
+    needUpdate = true;
+  }
+  return {
+    needUpdate,
+    latest: versionCache.version,
+    current: currentVersion
+  }
+}
+
+module.exports = {
+  isValidPhoneNumber,
+  isValidEmail,
+  isValidVerificationCode,
+  isValidAppId,
+  isValidAppVersion,
+  checkBeforeUpload,
+  checkNeedUpdate
+}

package/lib/util/config.js

@@ -0,0 +1,41 @@
+const path = require('path');
+const fs = require('fs-extra');
+const os = require('os');
+let customConfig = {};
+
+function setConfig(config = {}) {
+	return customConfig = {
+		...customConfig,
+		...config
+	};
+}
+
+function createProjectConfigFile(projectName, projectDir) {
+  const configJson = `{
+    "setting": {
+        "urlCheck": true,
+        "es6": true,
+        "postcss": true,
+        "minified": true,
+        "newFeature": true
+    },
+    "miniprogramRoot": "./",
+    "appid": "testappId",
+    "projectname": "${projectName}"
+}`;
+  const filePath = path.resolve(projectDir, 'project.config.json');
+  return fs.writeFile(filePath, configJson);
+}
+
+function getStoragePath() {
+	if (customConfig.storagePath) {
+		return customConfig.storagePath;
+	}
+  	return path.join(os.homedir(), `.tmg-cli/`);
+}
+
+module.exports = {
+	setConfig,
+	createProjectConfigFile,
+	getStoragePath
+};

package/lib/util/cookie.js

@@ -0,0 +1,36 @@
+// const os = require('os');
+const fs = require('fs-extra');
+const path = require('path');
+const { getStoragePath } = require('./config');
+let cookieStr = '';
+
+async function saveUserCookies(cookies) {
+  const cookieSavedPath = path.join(getStoragePath(), '.cookies');
+  fs.ensureFileSync(cookieSavedPath);
+  if (!cookies || cookies.length < 1) return;
+  cookieStr = cookies.map(cookie => cookie.split(';')[0]).join(';');
+  try {
+	fs.writeFile(path.join(cookieSavedPath), cookieStr);
+  }
+  catch (err) {
+	console.error(err);
+  }
+}
+
+
+function getUserCookies() {
+  const cookieSavedPath = path.join(getStoragePath(), '.cookies');
+  return cookieStr || fs.readFileSync(cookieSavedPath, 'utf-8').trim();
+}
+
+async function checkSession() {
+	const cookieSavedPath = path.join(getStoragePath(), '.cookies');
+	const cookieExists = await fs.pathExists(cookieSavedPath);
+	return cookieExists;
+}
+
+module.exports = {
+  saveUserCookies,
+  getUserCookies,
+  checkSession
+}