@taole/deploy-helper 1.0.0-beta.6 → 1.0.0

package/index.mjs

@@ -1,39 +1,46 @@
 #!/usr/bin/env node
 
+import { Client } from 'node-scp'
 import fs from 'fs';
 import { join, basename, dirname } from "path";
-import { triggerPipeline } from './lib/pipelineApi.mjs';
-import { setDebug, log } from './lib/util.mjs';
+import { simpleGit } from 'simple-git';
+import { homedir } from 'os'
+import { runPipeline, checkYunxiaoToken, triggerPipeline } from './lib/pipelineApi.mjs';
+import { setDebug, log, getUserDeployHelperConfig } from './lib/util.mjs';
+import path from 'path';
 import { fileURLToPath } from 'url';
-import Deployer from './deploy.mjs';
-import Deployer2 from './deploy2.mjs';
-import { getScpClient, TEST_SERVER_HOST } from './util.mjs';
-
+import { checkOfflinePkg, syncApi as syncOfflinePkgApi } from './lib/offlinePkg.mjs';
+import { cmdWhoami, cmdLogout, cmdLogin } from './lib/login.mjs';
+import { cmdProjectCreate, cmdProjectPublish, cmdProjectPull } from './lib/project.mjs';
 
 const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
+const __dirname = path.dirname(__filename);
+
+
+const TEST_SERVER_HOST = "192.168.0.35";
 
+function fmtAssetsCommit(msg) {
+    if (msg.startsWith("-#")) {
+        return msg;
+    }
+    return `-#DH-1 ${msg}`;
+}
 
 /**
  * 加载配置
  * @returns 配置对象
  */
-async function loadConfig() {
-    const configJsonPath = join(process.cwd(), "deploy.config.json");
-    let configJson = null;
-    if (fs.existsSync(configJsonPath)) {
-        configJson = JSON.parse(fs.readFileSync(configJsonPath, "utf-8"));
-    }
-    if(!configJson){
-        log(`deploy.config.json不存在, 请先创建`);
-        return null;
+async function loadConfig(configFileName) {
+    if(!configFileName){
+        configFileName = 'deploy.config.json';
     }
-    const repoPackageJsonPath = join(process.cwd(), "package.json");
-    if (fs.existsSync(repoPackageJsonPath)) {
-        const repoPackageJson = JSON.parse(fs.readFileSync(repoPackageJsonPath, "utf-8"));
-        configJson.packageJson = repoPackageJson;
+    const configJsonPath = join(process.cwd(), configFileName);
+    if (fs.existsSync(configJsonPath)) {
+        const configJson = JSON.parse(fs.readFileSync(configJsonPath, "utf-8"));
+        return configJson;
     }
-    return configJson;
+    log(`文件${configFileName}不存在, 请先创建`);
+    return null;
 }
 
 async function initConfigJson() {
@@ -78,6 +85,28 @@ async function initConfigJson() {
     process.exit(0);
 }
 
+function hasChangeMe(content) {
+    return content.includes("CHANGE_ME");
+}
+
+async function getScpClient() {
+    let scpClient = null;
+    // 不能放密码。。残念
+    const scpClientConfig = {
+        host: TEST_SERVER_HOST,
+        username: 'root',
+        tryKeyboard: false,
+        password: 'tuwan123!@#',
+    }
+    // const sshKeyPath = join(homedir(), ".ssh/id_rsa");
+    // if (fs.existsSync(sshKeyPath)) {
+    //     scpClientConfig.privateKey = fs.readFileSync(sshKeyPath, "utf-8");
+    // } else {
+    //     log(`${sshKeyPath}不存在, 建议配置本机ssh免密登录, 参考地址：https://foochane.cn/article/2019061601.html`);
+    // }
+    scpClient = await Client(scpClientConfig);
+    return scpClient;
+}
 
 async function getVersion() {
     const packageJsonPath = join(__dirname, "package.json");
@@ -85,50 +114,95 @@ async function getVersion() {
     return packageJson.version;
 }
 
-
-function getDeployer(config) {
-    if(config.useDeploy2 === true){
-        return new Deployer2();
+const commandMap = {};
+function registerCommand(command, handler, help) {
+    if(!command || !handler){
+        return;
     }
-    return new Deployer();
+    commandMap[command] = {
+        handler,
+        help,
+    };
 }
 
+// 注册命令
+function doRegisterCommands() {
+    registerCommand("create", cmdProjectCreate, "创建项目");
+    registerCommand("publish", cmdProjectPublish, "更新项目到H5平台");
+    registerCommand("pull", cmdProjectPull, "拉取已有项目到本地");
+    registerCommand("whoami", cmdWhoami, "查看当前登录用户信息");
+    registerCommand("logout", cmdLogout, "退出登录");
+    registerCommand("login", cmdLogin, "登录");
+}
+
+doRegisterCommands();
+
 async function main() {
     const version = await getVersion();
 
     // process.argv.includes("--debug") || 
     // 默认开启debug debug目前只是打印日志的时候额外打印时间
     setDebug(true);
+    log(`deploy-helper v${version}`);
 
 
+    // await devTest();
     // log(`process.argv: ${process.argv[2]} ${process.argv[3]} ${process.argv[4]}`);
 
     // return;
     // other commands
     let command = process.argv[2];
-    if (!["init", "prod", "test", "scp", "scpevt", "pipeline"].includes(command)) {
+    const registeredCommand = commandMap[command];
+    if(registeredCommand){
+        // pass
+    } else if (!["init", "prod", "test", "scp", "scpevt", "pipeline", "offlinepkgrm"].includes(command)) {
         command = "help";
     }
 
+    if(registeredCommand){
+        const handler = registeredCommand.handler;
+        try {
+            await Promise.resolve(handler());
+            process.exit(0);
+        } catch (error) {
+            log(`执行命令失败: ${error}`);
+            console.log(error.stack);
+            process.exit(1);
+        }
+    }
+
     if (command === "help") {
         console.log(`deploy-helper v${version}`);
         console.log(`usage: deploy-helper [command]`);
-        console.log(`command: init 初始化配置`);
-        console.log(`command: prod 生产环境部署`);
-        console.log(`command: test 测试环境部署`);
+        console.log(`command: init [-c {configFileName}] 初始化配置`);
+        console.log(`command: prod [-c {configFileName}] 生产环境部署`);
+        console.log(`command: test [-c {configFileName}] 测试环境部署`);
         console.log(`command: scp {file} 复制文件{file}到OfficialSite测试服务器{file}`);
         console.log(`command: scp {file} {dest} 复制文件{file}到OfficialSite测试服务器{dest}`);
         console.log(`command: scpevt {file} 复制文件{file}到events测试服务器{file}`);
         console.log(`command: scpevt {file} {dest} 复制文件{file}到events测试服务器{dest}`);
         console.log(`command: pipeline {pipelineName|pipelineId} [branch] 触发流水线{pipelineName|pipelineId}， 指定分支(可省略)`);
+        console.log(`command: offlinepkgrm {name} {platform} [mode] 删除离线包{name}， 指定平台{platform}， 指定模式(可省略，默认test)`);
+        Object.keys(commandMap).forEach(command => {
+            const cmdObj = commandMap[command];
+            console.log(`command: ${command} ${cmdObj.help}`);
+        })
         process.exit(0);
     }
-    log(`deploy-helper v${version} start`);
 
     // 其他命令
     if (command === "init") {
         await initConfigJson();
         process.exit(0);
+    } else if (command === "whoami") {
+        await cmdWhoami();
+        process.exit(0);
+    } else if (command === "logout") {
+        await cmdLogout();
+        process.exit(0);
+    } else if (command === "login") {
+        await cmdLogin();
+        process.exit(0);
     } else if (["scp", "scpevt"].includes(command)) {
         const file = process.argv[3];
         if (!file) {
@@ -182,17 +256,296 @@ async function main() {
             process.exit(1);
         }
 
+    } else if (command === "offlinepkgrm") {
+        const name = process.argv[3];
+        if (!name) {
+            log(`name参数不能为空`);
+            process.exit(1);
+        }
+        const platform = process.argv[4];
+        if (!platform) {
+            log(`platform参数不能为空`);
+            process.exit(1);
+        }
+        const mode = process.argv[5] || "test";
+        if (!["prod", "test"].includes(mode)) {
+            log(`mode参数只能是prod或test`);
+            process.exit(1);
+        }
+        const userDeployHelperConfig = getUserDeployHelperConfig();
+        if (!userDeployHelperConfig || !userDeployHelperConfig.offlineApi || !userDeployHelperConfig.offlineApi.get || !userDeployHelperConfig.offlineApi.set) {
+            log(`配置文件未配置离线包api接口, 请先配置`);
+            process.exit(1);
+        }
+        await syncOfflinePkgApi(userDeployHelperConfig, mode, { name, remove: true, platform }, null);
+        process.exit(0);
     }
     try {
         const workDir = process.cwd(); // 当前项目根目录
         const mode = process.argv[2] === 'prod' ? 'prod' : 'test'; // 部署环境
         log(`deploy mode: ${mode}`);
         log(`workDir: ${workDir}`);
-        const config = await loadConfig();
-        const deployer = getDeployer(config);
-        await deployer.deploy(workDir, mode, config);
+        let configFileName = '';
+        if(process.argv[3] === '-c'){
+            // 尝试从-c中获取配置文件名
+            configFileName = process.argv[4];
+            if(!configFileName){
+                log(`-c参数必须指定配置文件名`);
+                process.exit(1);
+            } else if(configFileName){
+                log(`将使用配置文件: ${configFileName}`);
+            }
+        }
+        // 读取配置
+        const config = await loadConfig(configFileName);
+        if(!config){
+            return;
+        }
+        // log(`config`, config);
+
+        const result = hasChangeMe(JSON.stringify(config));
+        if (result) {
+            log(`配置中存在默认值(CHANGE_ME), 请先修改配置`);
+            process.exit(1);
+        }
+
+
+        const needHandleAssets = config.assets && config.assets.dest;
+
+        // 需要处理entry
+        const needHandleEntry = config.entry && config.entry.dest && (mode === 'prod' || (mode === 'test' && !config.entry.onlyProd));
+        const entryTestBranch = (config.entry && config.entry.testBranch) || "test";
+        const entryProdBranch = (config.entry && config.entry.prodBranch) || "master";
+        const entryTargetBranch = mode === 'prod' ? entryProdBranch : entryTestBranch;
+        // const currentProdBranch = config.prodBranch || "master";
+
+
+        // 检查流水线配置
+        checkYunxiaoToken(config, mode);
+        const offlinePkgResult = checkOfflinePkg({
+            workDir: workDir,
+            mode,
+        });
+        if (!offlinePkgResult.canBuild && offlinePkgResult.errorMsg) {
+            log(`${offlinePkgResult.errorMsg}`);
+            process.exit(1);
+        }
+        if (offlinePkgResult.canBuild) {
+            await offlinePkgResult.hookPostBuild();
+        }
+
+        // 检查项目
+        // 1. 检查项目是否存在
+        let assetsDest = null;
+        let entryDest = null;
+        if (needHandleAssets) {
+            assetsDest = join(workDir, config.assets.dest);
+            if (!fs.existsSync(assetsDest)) {
+                log(`assets.dest路径不存在: ${assetsDest}, 请先创建`);
+                process.exit(1);
+            }
+        }
+        // entry.dest
+        if (needHandleEntry) {
+            entryDest = join(workDir, config.entry.dest);
+            if (!fs.existsSync(entryDest)) {
+                log(`entry.dest路径不存在: ${entryDest}, 请先创建`);
+                process.exit(1);
+            }
+        }
+
+        // 2. 检查项目是否clean
+        let assetsGit = null;
+        let assetsStatus = null;
+        if (needHandleAssets) {
+            assetsGit = simpleGit(assetsDest);
+            assetsStatus = await assetsGit.status();
+            if (!assetsStatus.isClean()) {
+                log(`${assetsDest}目前有未提交内容, 请先处理`);
+                return;
+            }
+        }
+
+        let entryGit;
+        let entryStatus;
+        if (needHandleEntry) {
+            entryGit = simpleGit(entryDest);
+            entryStatus = await entryGit.status();
+            if (!entryStatus.isClean()) {
+                log(`${entryDest}目前有未提交内容, 请先处理`);
+                return;
+            }
+        }
+
+        // 2.1如果是prod模式，检查当前项目是不是处于主分支
+        // if (mode === 'prod') {
+        //     const currentGit = simpleGit(workDir);
+        //     const currentStatus = await currentGit.status();
+        //     if (!currentStatus.isClean()) {
+        //         log(`当前项目有未提交内容, 请先处理`);
+        //         process.exit(1);
+        //     }
+        //     if (currentStatus.branch !== currentProdBranch) {
+        //         log(`当前项目分支${currentStatus.branch}不是${currentProdBranch}分支, 请切换至${currentProdBranch}分支再执行prod命令`);
+        //         process.exit(1);
+        //     }
+        // }
+
+        // 3. 检查assets项目分支，并切换至master分支
+        // assets项目固定使用master分支
+        if (needHandleAssets && assetsStatus.current !== "master") {
+            log(`${assetsDest}当前分支不是master, 切换至master分支`);
+            await assetsGit.checkout("master");
+            log(`${assetsDest}切换至master分支成功`);
+        }
+        if (needHandleEntry && entryStatus.current !== entryTargetBranch) {
+            log(`${entryDest}当前分支不是${entryTargetBranch}, 切换至${entryTargetBranch}分支`);
+            await entryGit.checkout(entryTargetBranch);
+            log(`${entryDest}切换至${entryTargetBranch}分支成功`);
+        }
+
+        // 4. 执行git pull
+        if (assetsGit) {
+            log(`${assetsDest}执行git pull`);
+            await assetsGit.pull();
+            log(`${assetsDest} git pull done`);
+        }
+        if (entryGit) {
+            log(`${entryDest}执行git pull`);
+            await entryGit.pull();
+            log(`${entryDest} git pull done`);
+        }
+
+        let assetsFilesCount = 0;
+        // 5. 复制构建产物
+        // 5.1 复制assets
+        if (needHandleAssets) {
+            const assetsFiles = config.assets.files;
+            for (const [src, dest] of Object.entries(assetsFiles)) {
+                const srcPath = join(workDir, src);
+                if (!fs.existsSync(srcPath)) {
+                    log(`${srcPath}不存在，请确认构建产物是否正确`);
+                    return;
+                }
+                const destPath = join(assetsDest, dest);
+                if (fs.statSync(srcPath).isDirectory()) {
+                    fs.cpSync(srcPath, destPath, { recursive: true });
+                } else {
+                    fs.copyFileSync(srcPath, destPath);
+                }
+                log(`assets copy: ${srcPath} -> ${destPath}`);
+                assetsFilesCount++;
+            }
+            // log(`assets copy done.`);
+        }
+        // 5.2 复制entry
+        if (needHandleEntry) {
+            const entryFiles = config.entry.files;
+            for (const [src, dest] of Object.entries(entryFiles)) {
+                const srcPath = join(workDir, src);
+                if (!fs.existsSync(srcPath)) {
+                    log(`${srcPath}不存在，请确认构建产物是否正确`);
+                    return;
+                }
+                if (fs.statSync(srcPath).isDirectory()) {
+                    log(`entry: ${srcPath}是目录，不支持entry为目录的部署`);
+                    return;
+                }
+                const dests = Array.isArray(dest) ? dest : [dest];
+                for (const dest of dests) {
+                    const destPath = join(entryDest, dest);
+                    fs.copyFileSync(srcPath, destPath);
+                    log(`entry copy: ${srcPath} -> ${destPath}`);
+                }
+            }
+            // log(`entry copy done.`);
+        }
+
+        // 6. 提交
+        let canPushAssets = false;
+        let canPushEntry = false;
+        if (needHandleAssets) {
+            assetsStatus = await assetsGit.status();
+            if (!assetsStatus.isClean()) {
+                canPushAssets = true;
+                await assetsGit.add(".");
+                let assetsCommit = `${config.assets.commit || "feat:部署资源文件"} by deploy-helper`;
+                assetsCommit = fmtAssetsCommit(assetsCommit);
+                const assetsCommitResult = await assetsGit.commit(assetsCommit);
+                log(`assets commit: ${assetsCommit}`);
+                log(`assets commit: ${JSON.stringify(assetsCommitResult.summary)}`);
+            } else {
+                log(`${assetsDest} 未发现修改内容,跳过提交`);
+            }
+        }
+        if (needHandleEntry) {
+            entryStatus = await entryGit.status();
+            if (!entryStatus.isClean()) {
+                canPushEntry = true;
+                await entryGit.add(".");
+                let entryCommit = `${config.entry.commit || "feat:部署入口文件"} by deploy-helper`;
+                entryCommit = fmtAssetsCommit(entryCommit);
+                const entryCommitResult = await entryGit.commit(entryCommit);
+                log(`entry commit: ${entryCommit}`);
+                log(`entry commit: ${JSON.stringify(entryCommitResult.summary)}`);
+            } else {
+                log(`${entryDest} 未发现修改内容,跳过提交`);
+            }
+        }
+
+        // 7. 推送
+        if (canPushAssets) {
+            log(`assets push start`);
+            try {
+                await assetsGit.push();
+            } catch (error) {
+                await assetsGit.pull();
+                await assetsGit.push();
+            }
+            log(`assets push done.`);
+        }
+        if (canPushEntry) {
+            log(`entry push start`);
+            try {
+                await entryGit.push();
+            } catch (error) {
+                await entryGit.pull();
+                await entryGit.push();
+            }
+            log(`entry push done.`);
+        }
+
+        try {
+            // 8 测试环境将entry scp至测试环境
+            if (mode === 'test' && config.testSync) {
+                const syncTestFiles = config.testSync;
+                const scpClient = await getScpClient();
+                for (const [src, dest] of Object.entries(syncTestFiles)) {
+                    const srcPath = join(workDir, src);
+                    const dests = Array.isArray(dest) ? dest : [dest];
+                    for (const dest of dests) {
+                        const destPath = "/home/web/website/tuwan_www/templets/static/play/" + dest;
+                        log(`scp: ${srcPath} -> ${TEST_SERVER_HOST}:${destPath}`);
+                        await scpClient.uploadFile(srcPath, destPath)
+                    }
+                }
+            }
+        } catch (error) {
+            log(`scp error: ${error}`);
+            log(`复制文件到测试环境服务器失败, 建议配置本机ssh免密登录, 参考地址：https://foochane.cn/article/2019061601.html`);
+            if (assetsFilesCount > 0) {
+                log(`不过请放心，构建产物的assets已经处理完成，只要手动处理index.html文件即可。`);
+            }
+            process.exit(1);
+        }
+
+
+        // 处理触发流水线的任务
+        await runPipeline(config, mode);
+
         log(`deploy-helper deploy done.`);
         process.exit(0);
+
     } catch (error) {
         log(`error occurred in deploy-helper`, error);
         process.exit(1);

package/lib/login.mjs

@@ -0,0 +1,167 @@
+import { log } from "./util.mjs";
+import path from "path";
+import os from "os";
+import fs from "fs";
+import { exec } from "child_process";
+import { promisify } from "util";
+
+const execAsync = promisify(exec);
+const isDev = false;
+/**
+ * 保存本地用户登录状态的缓存文件
+ */
+const cacheFilePath = path.join(os.homedir(), ".tw-cli-userinfo-cache.json");
+let host =
+  "https://fapi.tuwan.com";
+if (isDev) {
+  host = "https://local-h5-plat.tuwan.com";
+}
+const devHost = "http://localhost:9000";
+let CREATE_SESSION_URL = `${host}/api/login/createLoginSession`;
+
+export async function getCache() {
+  try {
+    if (fs.existsSync(cacheFilePath)) {
+      const cacheStr = fs.readFileSync(cacheFilePath, "utf8");
+      const cache = JSON.parse(cacheStr);
+      const Tuwan_Passport = cache.Tuwan_Passport;
+      if (Tuwan_Passport) {
+        // 检查Tuwan_Passport是否还有效
+        const res = await fetch(
+          "https://yapi.tuwan.com/User/getUid?format=json",
+          {
+            headers: {
+              Cookie: `Tuwan_Passport=${Tuwan_Passport}`,
+            },
+          }
+        );
+        //log("getCache res", res);
+        const uidResp = await res.json();
+        //log("getCache uidResp", uidResp);
+        if (
+          uidResp &&
+          uidResp.error === 0 &&
+          uidResp.data &&
+          uidResp.data.uid === cache.userInfo.uid
+        ) {
+          return cache;
+        } else {
+          log("验证本地缓存失败, 已清理本地缓存");
+        }
+      }
+    }
+    clearCache();
+    return null;
+  } catch (error) {
+    console.error("获取缓存失败:", error);
+    clearCache();
+    return null;
+  }
+}
+
+function setCache(data) {
+  fs.writeFileSync(cacheFilePath, JSON.stringify(data));
+}
+
+function clearCache() {
+  if (fs.existsSync(cacheFilePath)) {
+    fs.unlinkSync(cacheFilePath);
+  }
+}
+
+async function openBrowser(url) {
+  const platform = process.platform;
+  if (platform === "win32") {
+    await execAsync(`start "" "${url}"`);
+  } else if (platform === "darwin") {
+    await execAsync(`open "${url}"`);
+  } else {
+    await execAsync(`xdg-open "${url}"`);
+  }
+}
+
+async function createLoginSession() {
+  let url = CREATE_SESSION_URL;
+  if (isDev) {
+    url = url.replace(host, devHost);
+  }
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+  });
+  if (!res.ok) {
+    throw new Error(`创建登录会话失败: ${res.status} ${res.statusText}`);
+  }
+  return res.json();
+}
+
+async function queryLoginResult(
+  doneUrl,
+  intervalMs = 2000,
+  timeoutMs = 120000
+) {
+  const start = Date.now();
+  if (isDev) {
+    doneUrl = doneUrl.replace(host, devHost);
+  }
+  while (Date.now() - start < timeoutMs) {
+    const res = await fetch(doneUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+    });
+    //log("queryLoginResult res", res);
+    if (!res.ok) {
+      throw new Error(`轮询登录结果失败: ${res.status} ${res.statusText}`);
+    }
+    const data = await res.json();
+    //log("queryLoginResult data", JSON.stringify(data, null, 2));
+    let loginResult = data.loginResult;
+    if (loginResult && data.status === "success") {
+      return JSON.parse(loginResult);
+    }
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+  }
+  throw new Error("登录超时，请重试");
+}
+
+export async function cmdLogin() {
+  const cache = await getCache();
+  if (cache && cache.userInfo && cache.userInfo.uid) {
+    log(
+      `已登录账号: ${cache.userInfo.nickname}(${cache.userInfo.uid}), 若需登录其他账号请先登出`
+    );
+    return;
+  }
+  log("正在创建登录会话...");
+  const { openUrl, doneUrl } = await createLoginSession();
+  log("请在浏览器中完成登录:", openUrl);
+
+  log("正在打开浏览器...");
+  await openBrowser(openUrl);
+
+  log("等待登录结果...");
+  const result = await queryLoginResult(doneUrl);
+  log(`${result.userInfo.nickname}(${result.userInfo.uid})登录成功`);
+  setCache(result);
+}
+
+export async function cmdWhoami() {
+  const cache = await getCache();
+  const userInfo = cache?.userInfo;
+  if (!userInfo || !userInfo.uid) {
+    log("当前未登录");
+    return;
+  }
+  log(`当前登录账号: ${userInfo.nickname}(${userInfo.uid})`);
+}
+
+export async function cmdLogout() {
+  const cache = await getCache();
+  const userInfo = cache?.userInfo;
+  if (!userInfo || !userInfo.uid) {
+    log("当前未登录");
+    return;
+  }
+  clearCache();
+  log("已退出登录");
+}