electron-version-deployer-cli 0.0.1

package/dist/cli.cjs

@@ -0,0 +1,496 @@
+#!/usr/bin/env node
+"use strict";
+const commander = require("commander");
+const pkgUp = require("pkg-up");
+const node_fs = require("node:fs");
+const logSymbols = require("log-symbols");
+const prompts = require("@inquirer/prompts");
+const node_path = require("node:path");
+const vite = require("vite");
+const vm = require("node:vm");
+const node_child_process = require("node:child_process");
+const parseChangelog = require("changelog-parser");
+const marked = require("marked");
+const jsdom = require("jsdom");
+const DOMPurify = require("dompurify");
+const archiver = require("archiver");
+const node_https = require("node:https");
+const download = require("download");
+const pkgPath = pkgUp.sync();
+function r(...paths) {
+  if (!pkgPath)
+    return "./";
+  if (paths.length === 0)
+    return node_path.dirname(node_path.resolve(pkgPath));
+  return node_path.join(node_path.dirname(node_path.resolve(pkgPath)), ...paths);
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) {
+    return bytes + " B";
+  } else if (bytes < 1048576) {
+    return (bytes / 1024).toFixed(2) + " KB";
+  } else {
+    return (bytes / 1048576).toFixed(2) + " MB";
+  }
+}
+const CLI_NAME = "electron-version-deployer-cli";
+const CONFIG_FILE_NAME = "evd.config.js";
+commander.program.command("init").option("-y", "自动确认初始化", false).description("生成配置文件").action(async (source, destination) => {
+  const pkgPath2 = pkgUp.sync();
+  if (!pkgPath2)
+    return console.log(
+      logSymbols.error,
+      "当前 cwd 下找不到 package.json 文件 \n 请确保该命令在 node 项目中执行！"
+    );
+  const pkgContent = JSON.parse(node_fs.readFileSync(pkgPath2, "utf-8"));
+  const name = pkgContent.name.split("/").pop().replaceAll("-", "");
+  const defaultConfig = {
+    compileCommand: "compile:mac",
+    changelogsPath: "CHANGELOG.md",
+    sources: {
+      folder: `dist/mac-arm64/${name}.app/Resources/app`,
+      nodeModules: "node_modules",
+      codes: "build",
+      packageJSON: "package.json"
+    },
+    netlify: {
+      url: "",
+      token: "",
+      siteID: ""
+    },
+    prebuiltConfig: {}
+  };
+  if (!source.y) {
+    defaultConfig.compileCommand = await prompts.input({
+      message: "请输入编译命令",
+      default: defaultConfig.compileCommand
+      // validate(str) {
+      //   const scripts = pkgContent.scripts ?? {};
+      //   return Promise.resolve(
+      //     scripts[str] ? true : `无法在 package.json 中找到该命令！`
+      //   );
+      // },
+    });
+    defaultConfig.changelogsPath = await prompts.input({
+      message: "请输入 changelogs 文件位置（以项目根目录为准的相对路径)",
+      default: defaultConfig.changelogsPath
+      // validate(str) {
+      //   return Promise.resolve(
+      //     existsSync(r(str))
+      //       ? /\.md$/.test(str)
+      //         ? true
+      //         : "该文件必须是以 .md 结尾的 Markdown 文件"
+      //       : "该文件不存在！"
+      //   );
+      // },
+    });
+    defaultConfig.sources.folder = await prompts.input({
+      message: "请输入源文件目录",
+      default: `dist/mac-arm64/myapp.app/Resources/app`
+    });
+    defaultConfig.sources.nodeModules = await prompts.input({
+      message: "请输入源文件 node_modules 目录",
+      default: defaultConfig.sources.nodeModules
+    });
+    defaultConfig.sources.codes = await prompts.input({
+      message: "请输入源文件 逻辑代码目录",
+      default: defaultConfig.sources.codes
+    });
+    defaultConfig.sources.packageJSON = await prompts.input({
+      message: "请输入源文件 package.json 路径",
+      default: defaultConfig.sources.packageJSON
+    });
+    defaultConfig.netlify.url = await prompts.input({
+      message: "请输入 Netlify 网站域名"
+    });
+    defaultConfig.netlify.token = await prompts.input({
+      message: "请输入 Netlify Token"
+    });
+    defaultConfig.netlify.siteID = await prompts.input({
+      message: "请输入 Netlify SiteID"
+    });
+  }
+  let evdConfigContent = node_fs.readFileSync(
+    node_path.join(node_path.resolve(__dirname), "templates", "evd.config.ts"),
+    "utf-8"
+  );
+  evdConfigContent = evdConfigContent.replace(/\/\/\s+@ts-nocheck\n/, "");
+  evdConfigContent = evdConfigContent.replace(/"@\/index"/, `"${CLI_NAME}"`);
+  Object.entries(defaultConfig).map(([key, value]) => {
+    if (typeof value === "object") {
+      Object.entries(value).map(([_key, _value]) => {
+        evdConfigContent = evdConfigContent.replace(
+          new RegExp(`__${key}_${_key}__`),
+          `"${_value}"`
+        );
+      });
+    } else {
+      evdConfigContent = evdConfigContent.replace(
+        new RegExp(`__${key}__`),
+        `"${value}"`
+      );
+    }
+  });
+  node_fs.writeFileSync(r(CONFIG_FILE_NAME), evdConfigContent, "utf-8");
+  console.log(
+    logSymbols.success,
+    `生成配置文件 ${r(CONFIG_FILE_NAME)} 成功!`
+  );
+});
+async function getConfigs() {
+  const configFilePath = r(CONFIG_FILE_NAME);
+  if (!node_fs.existsSync(configFilePath)) {
+    throw new Error(`无法找到 ${configFilePath} 文件! `);
+  }
+  return await bundleConfigFileAndRead(r(CONFIG_FILE_NAME));
+}
+async function bundleConfigFileAndRead(configFilePath) {
+  return new Promise((resolve) => {
+    vite.build({
+      mode: "development",
+      configFile: false,
+      logLevel: "error",
+      root: r(),
+      resolve: {
+        alias: {
+          [CLI_NAME]: node_path.resolve(__dirname, "./index.es.js")
+        }
+      },
+      build: {
+        write: false,
+        commonjsOptions: {
+          esmExternals: true
+        },
+        emptyOutDir: false,
+        sourcemap: false,
+        cssCodeSplit: false,
+        minify: false,
+        lib: {
+          entry: configFilePath,
+          //  注意，由于我们需要将文件打包到一起，所以用的 iife 格式
+          //  这里给一个全局名称，方便等等在上下文中获取
+          name: "_",
+          formats: ["iife"]
+        }
+      }
+    }).then((data) => {
+      const script = new vm.Script(data[0].output[0].code);
+      const ctx = {};
+      script.runInNewContext(ctx);
+      resolve(ctx._);
+    });
+  });
+}
+function archiveFiles(outputPath, files) {
+  return new Promise((res, rej) => {
+    const output = node_fs.createWriteStream(outputPath);
+    const archive = archiver("zip");
+    output.on("close", function() {
+      console.log(
+        logSymbols.success,
+        `压缩完成 ${node_path.basename(outputPath)} ${formatBytes(archive.pointer())}`
+      );
+      res();
+    });
+    archive.on("error", function(err) {
+      rej(err);
+    });
+    archive.pipe(output);
+    for (let filePath of files) {
+      if (~filePath.indexOf("package.json")) {
+        archive.file(filePath, { name: node_path.basename(filePath) });
+      } else {
+        archive.directory(filePath, node_path.basename(filePath));
+      }
+    }
+    archive.finalize();
+  });
+}
+commander.program.command("prepare").description(
+  "部署前的准备工作，如获取编译软件获取逻辑代码，生成 changelog 等"
+).action(async (source, destination) => {
+  const configs = await getConfigs();
+  try {
+    await genTmpFolder();
+    await compile(configs);
+    await genChangelog(configs);
+    await copySourceAndZipFiles(configs);
+  } catch (e) {
+    console.log(logSymbols.error, e.toString());
+  }
+  console.log(logSymbols.info, "请执行 evd deploy 命令进行部署");
+});
+async function copySourceAndZipFiles(configs) {
+  const logicCodeZipPath = r("node_modules/.evd/logicCode.zip");
+  const fullCodeZipPath = r("node_modules/.evd/fullCode.zip");
+  const nodeModulesPath = node_path.join(
+    node_path.resolve(configs.sources.folder),
+    configs.sources.nodeModules
+  );
+  const codesPath = node_path.join(
+    node_path.resolve(configs.sources.folder),
+    configs.sources.codes
+  );
+  const packageJSONPath = node_path.join(
+    node_path.resolve(configs.sources.folder),
+    configs.sources.packageJSON
+  );
+  if (!node_fs.existsSync(nodeModulesPath)) {
+    throw new Error(
+      `${r(
+        configs.sources.nodeModules
+      )} 文件夹不存在，请检查 configs.sources.nodeModules 配置是否正确！`
+    );
+  }
+  if (!node_fs.existsSync(codesPath)) {
+    throw new Error(
+      `${r(
+        configs.sources.codes
+      )} 文件夹不存在，请检查 configs.sources.codes 配置是否正确！`
+    );
+  }
+  if (!node_fs.existsSync(packageJSONPath)) {
+    throw new Error(
+      `${r(
+        configs.sources.packageJSON
+      )} 文件夹不存在，请检查 configs.sources.packageJSON 配置是否正确！`
+    );
+  }
+  await archiveFiles(fullCodeZipPath, [
+    nodeModulesPath,
+    codesPath,
+    packageJSONPath
+  ]);
+  await archiveFiles(logicCodeZipPath, [codesPath, packageJSONPath]);
+  node_fs.copyFileSync(packageJSONPath, r("node_modules/.evd/package.json"));
+  console.log(logSymbols.success, "更新包创建成功！");
+}
+async function genChangelog(configs) {
+  if (!node_fs.existsSync(r(configs.changelogsPath))) {
+    throw new Error(`${r(configs.changelogsPath)} 文件不存在，请先创建！`);
+  }
+  const outputPackageJSONPath = node_path.join(
+    node_path.resolve(configs.sources.folder),
+    configs.sources.packageJSON
+  );
+  if (!node_fs.existsSync(outputPackageJSONPath)) {
+    throw new Error(
+      `${outputPackageJSONPath} 文件不存在，请检查 sources.packageJSON 配置是否正确`
+    );
+  }
+  const pkgContent = JSON.parse(node_fs.readFileSync(outputPackageJSONPath, "utf-8"));
+  const currentVersion = pkgContent.version;
+  const changes = await parseChangelog({
+    filePath: r(configs.changelogsPath),
+    removeMarkdown: false
+  });
+  const currentChange = changes.versions.find((change) => {
+    return change.version === currentVersion;
+  });
+  if (!currentChange) {
+    throw new Error(
+      `无法在 ${configs.changelogsPath} 中找到当前版本 ${currentVersion} 的记录，请检查是否按正确格式编写 changelog！`
+    );
+  }
+  const { date, version, title, body } = currentChange;
+  if (body.trim().length === 0) {
+    throw new Error(`当前版本 ${currentVersion} 的 Changelog 记录为空！`);
+  }
+  const window = new jsdom.JSDOM("").window;
+  const purify = DOMPurify(window);
+  const html = purify.sanitize(
+    marked.marked.parse(body, {
+      mangle: false,
+      headerIds: false
+    })
+  );
+  node_fs.writeFileSync(
+    r("node_modules/.evd/changelog.json"),
+    JSON.stringify({
+      title,
+      version,
+      date,
+      changes: html
+    }),
+    "utf-8"
+  );
+  console.log(
+    logSymbols.success,
+    `写入 changelog.json 成功 ${r("node_modules/.evd/changelog.json")}`
+  );
+}
+async function compile(configs) {
+  console.log(logSymbols.info, "开始编译", r());
+  node_child_process.execSync(`npm run ${configs.compileCommand}`, {
+    stdio: "inherit",
+    cwd: r()
+  });
+  console.log(logSymbols.success, "编译成功！");
+  if (!node_fs.existsSync(configs.sources.folder)) {
+    throw new Error(
+      `无法找到资源目录, ${configs.sources.folder} 请检查配置是否正确！`
+    );
+  }
+}
+function genTmpFolder() {
+  const folderPath = r("node_modules/.evd");
+  if (!node_fs.existsSync(folderPath))
+    node_fs.mkdirSync(folderPath);
+}
+function fetchRemotePkgJSON(remote_url) {
+  return new Promise((res, rej) => {
+    node_https.get(`${remote_url}/package.json`, (_res) => {
+      let data = "";
+      _res.on("data", (chunk) => {
+        data += chunk;
+      });
+      _res.on("end", () => {
+        try {
+          res(JSON.parse(data));
+        } catch (e) {
+          res(null);
+        }
+      });
+    }).on("error", (err) => {
+      rej(`自动更新检查请求失败:` + err.toString());
+    });
+  });
+}
+function versionToNum(a) {
+  let c = a.split(".");
+  let num_place = ["", "0", "00", "000", "0000"], r2 = num_place.reverse();
+  for (let i = 0; i < c.length; i++) {
+    let len = c[i].length;
+    c[i] = r2[len] + c[i];
+  }
+  let res = c.join("");
+  return res;
+}
+commander.program.command("deploy").description("执行部署").action(async (source, destination) => {
+  const configs = await getConfigs();
+  try {
+    await checkEVDFolderExist();
+    await validateConfigs(configs);
+    await checkIsFirstTimeDeploy(configs);
+    await validateRemotePackageJSON(configs);
+    await deploy(configs);
+  } catch (e) {
+    console.log(logSymbols.error, e.toString());
+  }
+});
+async function deploy(configs) {
+  console.log(logSymbols.info, "开始部署", r());
+  const output = node_child_process.spawn("netlify", [
+    "deploy",
+    "--dir",
+    r("node_modules/.evd"),
+    "--site",
+    configs.netlify.siteID,
+    "--auth",
+    configs.netlify.token,
+    "--prod",
+    "--debug"
+  ], {
+    stdio: ["pipe", "inherit", "inherit"]
+  });
+  output.on("exit", function(code) {
+    if (code === 0) {
+      console.log(logSymbols.success, "部署完成！");
+      return;
+    }
+    throw new Error("部署失败！");
+  });
+}
+async function validateRemotePackageJSON(configs) {
+  const compiledPackageJSON = JSON.parse(
+    node_fs.readFileSync(r("node_modules/.evd/package.json"), "utf-8")
+  );
+  const compiledName = compiledPackageJSON.name;
+  const remotePKG = await fetchRemotePkgJSON(configs.netlify.url);
+  if (!remotePKG)
+    return;
+  const remoteName = remotePKG.name;
+  if (compiledName !== remoteName) {
+    const answer = await prompts.confirm({
+      message: `检测到项目名称不一致，确定继续吗 编译后的项目名称: ${compiledName}, 远程 package.json 中的项目名称 ${remoteName}`
+    });
+    if (!answer)
+      throw new Error(`部署已停止`);
+    const answerDoubleCheck = await prompts.confirm({
+      message: `确定继续执行吗？这将会覆盖远程的版本！`
+    });
+    if (!answerDoubleCheck)
+      throw new Error(`部署已停止`);
+  }
+  const localVersion = versionToNum(compiledPackageJSON.version);
+  const remoteVersion = versionToNum(remotePKG.version);
+  if (localVersion == remoteVersion) {
+    const answer = await prompts.confirm({
+      message: `检测到远程部署版本和当前版本一致 ${remotePKG.version}，确定要覆盖部署吗?`
+    });
+    if (!answer)
+      throw new Error(`部署已停止`);
+  } else if (remoteVersion > localVersion) {
+    const answer = await prompts.confirm({
+      message: `检测到远程部署版本为 ${remotePKG.version} 大于当前版本 ${compiledPackageJSON.version}，确定要覆盖部署吗?`
+    });
+    if (!answer)
+      throw new Error(`部署已停止`);
+  }
+}
+async function checkIsFirstTimeDeploy(configs) {
+  const remotePKG = await fetchRemotePkgJSON(configs.netlify.url);
+  if (!remotePKG) {
+    const answer = await prompts.confirm({
+      message: `似乎 ${configs.netlify.url} 还未部署过任何版本，确认继续吗？`
+    });
+    if (!answer) {
+      throw new Error("部署已停止！");
+    }
+  }
+}
+async function validateConfigs(configs) {
+  if (!configs.netlify.url || !/^https/.test(configs.netlify.url)) {
+    throw new Error(`configs.netlify.url 配置不正确`);
+  }
+  if (!configs.netlify.token) {
+    throw new Error(`configs.netlify.token 未配置`);
+  }
+  if (!configs.netlify.siteID) {
+    throw new Error(`configs.netlify.siteID 未配置`);
+  }
+}
+async function checkEVDFolderExist() {
+  if (!node_fs.existsSync(r("node_modules/.evd"))) {
+    throw new Error(`未找到 .evd 文件夹，你需要先执行 evd prepare`);
+  }
+}
+commander.program.command("install-prebuilt").description("安装与构建包").action(async (source, destination) => {
+  const configs = await getConfigs();
+  if (configs.prebuiltConfig && Object.values(configs.prebuiltConfig).length > 0) {
+    await installPrebuilt(configs);
+  }
+});
+async function installPrebuilt(configs) {
+  Object.entries(configs.prebuiltConfig).map(async ([moduleName, config]) => {
+    const projectFolder = require.resolve(moduleName).split("node_modules")[0];
+    const pkgFolder = node_path.join(projectFolder, "node_modules", moduleName);
+    const pkgJSON = JSON.parse(
+      node_fs.readFileSync(node_path.join(pkgFolder, "package.json"), "utf-8")
+    );
+    const pkgVersion = pkgJSON.version;
+    const hostUrl = pkgJSON.binary.host;
+    const outputFolder = node_path.join(pkgFolder, ...config.outputPath);
+    for (let j = 0; j < config.files.length; j++) {
+      const downloadURL = `${hostUrl}v${pkgVersion}/${config.files[j]}`;
+      const outputPath = node_path.join(outputFolder);
+      await download(downloadURL, outputPath, {
+        extract: true
+      });
+      console.log(logSymbols.success, `下载: ${downloadURL} 成功！`);
+    }
+  });
+}
+commander.program.description(
+  "Electron 版本部署 CLI，简化你的 Electron 软件更新，让一切变得简单。"
+).helpOption("-h, --help", "使用帮助").version("0.0.1", "-V, --version", "显示版本号").parse(process.argv);

package/dist/const.d.ts

@@ -0,0 +1,2 @@
+export declare const CLI_NAME: any;
+export declare const CONFIG_FILE_NAME = "evd.config.js";

package/dist/helpers/fetchRemotePkgJSON.d.ts

@@ -0,0 +1,2 @@
+export declare function fetchRemoteChangelogJSON(remote_url: string): Promise<any>;
+export declare function fetchRemotePkgJSON(remote_url: string): Promise<any>;

package/dist/index.cjs.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const CLI_NAME = "electron-version-deployer-cli";
+const CONFIG_FILE_NAME = "evd.config.js";
+function defineEVDConfig(configs) {
+  return configs;
+}
+exports.CLI_NAME = CLI_NAME;
+exports.CONFIG_FILE_NAME = CONFIG_FILE_NAME;
+exports.defineEVDConfig = defineEVDConfig;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { EVDConfigType } from "./types/EVDConfigType";
+export * from "./types/EVDConfigType";
+export * from "./const";
+export declare function defineEVDConfig(configs: EVDConfigType): EVDConfigType;

package/dist/index.es.js

@@ -0,0 +1,10 @@
+const CLI_NAME = "electron-version-deployer-cli";
+const CONFIG_FILE_NAME = "evd.config.js";
+function defineEVDConfig(configs) {
+  return configs;
+}
+export {
+  CLI_NAME,
+  CONFIG_FILE_NAME,
+  defineEVDConfig
+};