@wjwjq/release-helper 0.0.1

package/dist/prepare.js

@@ -0,0 +1,75 @@
+import path, { dirname } from 'path';
+import fs from 'fs';
+import YAML from 'yaml';
+import * as inquirer from '@inquirer/prompts';
+import { execa } from 'execa';
+import { fileURLToPath } from 'node:url';
+import { logger } from './logger.js';
+import 'picocolors';
+
+const __work_dir = process.cwd();
+const __releaseDir = path.resolve(__work_dir, ".release");
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const releaseConfFileName = "release.conf.yaml";
+const __releaseConfPath = path.resolve(__releaseDir, releaseConfFileName);
+function parseConf(file) {
+  try {
+    const conf = fs.readFileSync(file, "utf-8");
+    return YAML.parse(conf);
+  } catch (error) {
+    return {};
+  }
+}
+const releaseConf = Object.assign({
+  /** 打包脚本 默认npm run build */
+  buildCmd: "npm run build",
+  /** 打包后资源 相对工作区所在路径  默认dist/*/
+  assetsDir: "dist"
+}, parseConf(__releaseConfPath));
+const $ = execa({ encoding: "utf8" });
+async function prepare() {
+  const copyFiles = () => {
+    fs.cpSync(path.resolve(__dirname, ".release"), __releaseDir, { recursive: true });
+  };
+  if (!fs.existsSync(__releaseDir)) {
+    fs.mkdirSync(__releaseDir);
+    copyFiles();
+    logger.tip(`\u8BF7\u6CE8\u610F\u4FEE\u6539.release/${releaseConfFileName} \u914D\u7F6E\u4FE1\u606F`);
+  } else {
+    const shouldRegenerate = await inquirer.confirm(
+      {
+        message: ".release\u914D\u7F6E\u5DF2\u5B58\u5728\uFF0C\u662F\u5426\u91CD\u65B0\u751F\u6210\uFF1F"
+      }
+    );
+    if (shouldRegenerate) {
+      copyFiles();
+    }
+  }
+}
+async function checkEnvInfo() {
+  const { stdout: isGitRepo } = await $(`git rev-parse --is-inside-work-tree`);
+  if (isGitRepo !== "true") {
+    logger.error("\u5F53\u524D\u9879\u76EE\u4E0D\u662Fgit\u4ED3\u5E93");
+    process.exit(1);
+  }
+  if (!fs.existsSync(path.resolve(__releaseDir, "nginx/nginx.conf"))) {
+    logger.error(".release\u76EE\u5F55\u4E0B\u4E0D\u5B58\u5728nginx/nginx.conf \u6587\u4EF6\uFF0C \u8BF7\u4F7F\u7528 release-helper init \u521D\u59CB\u5316\u751F\u6210");
+    process.exit(1);
+  }
+  if (!fs.existsSync(__releaseConfPath)) {
+    logger.error(`.release\u76EE\u5F55\u4E0B\u4E0D\u5B58\u5728${releaseConfFileName}\u6587\u4EF6\uFF0C\u8BF7\u4F7F\u7528 release-helper init \u521D\u59CB\u5316\u751F\u6210`);
+    process.exit(1);
+  }
+  const { host, token } = releaseConf;
+  if (!host) {
+    logger.error(`The host field is required in the configuration file!`);
+    process.exit(1);
+  }
+  if (!token) {
+    logger.error(`The token field is required in the configuration file!`);
+    process.exit(1);
+  }
+}
+
+export { $, __dirname, __releaseConfPath, __releaseDir, __work_dir, checkEnvInfo, prepare, releaseConf, releaseConfFileName };

package/dist/publish.js

@@ -0,0 +1,238 @@
+import fs from 'fs';
+import path from 'path';
+import { URL } from 'url';
+import crypto from 'crypto';
+import mime from 'mime';
+import * as inquirer from '@inquirer/prompts';
+import { setTimeout } from 'node:timers/promises';
+import { Gitlab } from '@gitbeaker/rest';
+import { $, releaseConf, __releaseDir } from './prepare.js';
+import { logger } from './logger.js';
+import 'yaml';
+import 'execa';
+import 'node:url';
+import 'picocolors';
+
+async function isGitFlowRepo() {
+  try {
+    let { stdout } = await $("git config", ["--get-regexp", `^gitflow.`]);
+    return stdout.toString().length > 0;
+  } catch (error) {
+    console.error("\u{1F680} ~ doGitFlowRelease ~ error:", error);
+  }
+  return false;
+}
+async function getRepo() {
+  const res = await $`git remote -v `.pipe` sed -n '1p'`.pipe`awk -F ' ' '{print $2}'`.pipe`sed -e 's/.git//'`;
+  const repo = res.stdout.replace("\n", "");
+  if (repo.startsWith("git@")) {
+    const ps2 = repo.split("/");
+    return {
+      isHttpRepo: false,
+      repo: repo.split(":")[1],
+      repoName: ps2[ps2.length - 1].replace(".git", "")
+    };
+  }
+  const url = new URL(repo);
+  const ps = url.pathname.split("/");
+  return {
+    isHttpRepo: true,
+    repo: url.pathname,
+    origin: url.origin,
+    repoName: ps[ps.length - 1]
+  };
+}
+async function getChangeLog(host, newVersion, userSelectedLatestTag, markdownUrls) {
+  async function getLog() {
+    let output2 = "";
+    try {
+      const isGitFlow = await isGitFlowRepo();
+      const { stdout } = await $`git tag --sort=-creatordate`;
+      const tags = stdout.split("\n");
+      const latestTag = tags[0];
+      let tagRange = "";
+      if (isGitFlow) {
+        if (tags.length >= 2) {
+          const secondLastTag = userSelectedLatestTag !== "" ? userSelectedLatestTag : tags[1];
+          tagRange = `${secondLastTag}..${latestTag}`;
+        } else if (tags.length === 1) {
+          tagRange = latestTag;
+        }
+      } else {
+        if (tags.length >= 1) {
+          tagRange = `${latestTag}..HEAD`;
+        }
+      }
+      let logCmd = `git log ${tagRange} --format=%B%H----DELIMITER---- --abbrev-commit`;
+      const { stdout: r } = await $(logCmd);
+      output2 = r;
+    } catch (error) {
+      console.error("\u{1F680} ~ getLog ~ error:", error);
+      const { stdout: r } = await $`git log --format=%B%H----DELIMITER----`;
+      output2 = r;
+    }
+    return output2;
+  }
+  const output = await getLog();
+  const commitsArray = output.split("----DELIMITER----\n").map((commit) => {
+    const [message, sha] = commit.split("\n").filter((msg) => msg != "" && !msg.startsWith("Merge"));
+    return { sha, message };
+  }).filter((commit) => Boolean(commit.sha));
+  let currentChangelog = "";
+  const { repo } = await getRepo();
+  let newChangelog = ``;
+  let features = [];
+  let Bugfixes = [];
+  commitsArray.forEach((commit) => {
+    const commitSha = `([${commit.sha.substring(0, 6)}](${host}/${repo}/-/commit/${commit.sha}))`;
+    if (commit.message.startsWith("feat:") || commit.message.startsWith("feat\uFF1A")) {
+      const feats = commit.message.replace(/feat[:|：]/, "").replace(/;|；/g, "$").split("$");
+      features = features.concat(feats.map((f) => `* ${f.replace(/^\s+/, "")} ${commitSha}
+`));
+    }
+    if (commit.message.startsWith("fix:") || commit.message.startsWith("fix\uFF1A")) {
+      const fixes = commit.message.replace(/fix[:|：]/, "").replace(/;|；/g, "$").split("$");
+      Bugfixes = Bugfixes.concat(fixes.map((f) => `* ${f.replace(/^\s+/, "")} ${commitSha}
+`));
+    }
+  });
+  if (features.length) {
+    newChangelog += `# Features
+`;
+    features.forEach((feature) => {
+      newChangelog += feature;
+    });
+    newChangelog += "\n";
+  }
+  if (Bugfixes.length) {
+    newChangelog += `# Bugfixes
+`;
+    Bugfixes.forEach((bugfix) => {
+      newChangelog += bugfix;
+    });
+    newChangelog += "\n";
+  }
+  console.log("\u{1F680} ~ getChangeLog ~features & Bugfixes:", features, Bugfixes);
+  newChangelog += `# Artifacts
+`;
+  newChangelog += `## tar\u5305
+`;
+  newChangelog += `${markdownUrls.tar}
+`;
+  newChangelog += `## md5
+`;
+  newChangelog += `${markdownUrls.md5}
+`;
+  newChangelog += `## \u6587\u6863
+`;
+  newChangelog += `${markdownUrls.doc}
+`;
+  return `${newChangelog}${currentChangelog}`;
+}
+async function getGitTags() {
+  const { stdout } = await $`git tag --sort=-creatordate`;
+  return stdout.split("\n");
+}
+async function selectLatestTag(targetVersion) {
+  let latestTag = "";
+  const tags = await getGitTags();
+  if (tags.length >= 2) {
+    const ac = new AbortController();
+    const prompt = inquirer.select(
+      {
+        message: "\u8BF7\u9009\u62E9\u53D1\u5E03\u4FE1\u606F\u4ECE\u54EA\u6B21tag\u5F00\u59CB\u751F\u6210\uFF0C\uFF08\u9ED8\u8BA4\uFF1A \u6700\u8FD1\u4E00\u6B21\uFF0C\u7279\u522B\u9488\u5BF9\u67D0\u4E3B\u7248\u672C\u4E4B\u95F4\u6709\u5C0F\u7248\u672C\u8FC7\u6E21\u7684\u60C5\u51B5\uFF09(timing out in 10 seconds)\uFF1A",
+        default: tags[0],
+        choices: tags.filter((item) => item !== targetVersion).map((tag) => ({ value: tag }))
+      }
+    );
+    prompt.finally(() => {
+      ac.abort();
+    }).catch(() => {
+    });
+    const defaultValue = setTimeout(1e4, "timeout", { signal: ac.signal }).then(() => {
+      prompt.cancel();
+      return tags[0];
+    });
+    latestTag = await Promise.race([defaultValue, prompt]);
+  }
+  return latestTag;
+}
+async function publish(params) {
+  const {
+    version,
+    pkgName,
+    appName,
+    remoteBranch,
+    userSelectedLatestTag = ""
+  } = params || {};
+  try {
+    const { repo } = await getRepo();
+    const { host, token } = releaseConf;
+    logger.tip("start to publish");
+    const api = new Gitlab({
+      host,
+      token,
+      rejectUnauthorized: false
+    });
+    const projects = await api.Projects.all();
+    const proj = projects.find((item) => item.path_with_namespace === repo);
+    if (proj === void 0) {
+      throw Error(`The target repo not founded!`);
+    }
+    const id = proj.id;
+    const assetFile = path.resolve(__releaseDir, pkgName);
+    const file = fs.readFileSync(assetFile);
+    const hash = crypto.createHash("md5");
+    hash.update(file);
+    const md5 = hash.digest("hex");
+    const md5FileName = `${appName}_${version}.md5.txt`;
+    const docPath = path.join(__releaseDir, "doc");
+    const replacedConstants = [["\\$APP_NAME\\$", appName], ["\\$VERSION\\$", version], ["\\$TAR_PKG\\$", pkgName]];
+    const docUploadsPromises = fs.readdirSync(docPath).map((docFIleName) => {
+      const docFilePath = path.resolve(docPath, docFIleName);
+      const stats = fs.statSync(docFilePath);
+      if (stats.isFile()) {
+        let content = fs.readFileSync(docFilePath).toString();
+        const doc = replacedConstants.reduce((prev, [reg, value]) => {
+          return prev.replace(new RegExp(reg, "g"), value);
+        }, content);
+        return api.Projects.uploadForReference(id, { content: new Blob([doc], { type: mime.getType(docFIleName) }), filename: docFIleName });
+      }
+    }).filter((item) => item);
+    logger.info("start to upload resources");
+    const [tarUploads, md5Uploads, ...docUploads] = await Promise.all([
+      api.Projects.uploadForReference(id, { content: new Blob([file], { type: "application/gzip" }), filename: pkgName }),
+      api.Projects.uploadForReference(id, { content: new Blob([md5], { type: "text/plain" }), filename: md5FileName }),
+      ...docUploadsPromises
+    ]);
+    const description = await getChangeLog(host, version, userSelectedLatestTag, { tar: tarUploads.markdown, md5: md5Uploads.markdown, doc: docUploads.map((item) => item.markdown).join("\n") });
+    logger.tip("start tag and release to git repo");
+    const tags = await api.Tags.all(id);
+    if (tags.find((r) => r.name === version) === void 0) {
+      await api.Tags.create(id, version, remoteBranch);
+    }
+    const releases = await api.ProjectReleases.all(id);
+    let res;
+    if (releases.find((r) => r.name === version)) {
+      res = await api.ProjectReleases.edit(id, version, {
+        description
+      });
+    } else {
+      res = await api.ProjectReleases.create(id, {
+        tag_name: version,
+        description
+      });
+    }
+    await api.ReleaseLinks.create(id, version, pkgName, `${host}${tarUploads.full_path}`, { linkType: "package" });
+    await api.ReleaseLinks.create(id, version, md5FileName, `${host}${md5Uploads.full_path}`, { linkType: "other" });
+    await Promise.all(docUploads.map((doc) => api.ReleaseLinks.create(id, version, doc.alt, `${host}${doc.full_path}`, { linkType: "other" })));
+    fs.unlinkSync(assetFile);
+    logger.success(`Successfully released at: ${res._links.self} `);
+  } catch (error) {
+    logger.error("\u{1F680} ~ file: publish.js ~ error:");
+    console.error(error);
+    return Promise.reject(error);
+  }
+}
+
+export { getGitTags, isGitFlowRepo, publish, selectLatestTag };

package/dist/release.js

@@ -0,0 +1,200 @@
+import * as inquirer from '@inquirer/prompts';
+import process from 'process';
+import pc from 'picocolors';
+import { pack } from './pack.js';
+import { getGitTags, selectLatestTag, publish, isGitFlowRepo } from './publish.js';
+import { checkEnvInfo, $, releaseConf } from './prepare.js';
+import { logger } from './logger.js';
+import 'fs';
+import 'path';
+import 'tar';
+import 'url';
+import 'crypto';
+import 'mime';
+import 'node:timers/promises';
+import '@gitbeaker/rest';
+import 'yaml';
+import 'execa';
+import 'node:url';
+
+async function release(fromPublishCmd = false) {
+  try {
+    await checkEnvInfo();
+    await hasUncommittedChanges();
+    let { stdout: originalBranch } = await $(`git branch --show-current`);
+    let version = await inquirer.input({
+      message: "\u8BF7\u8F93\u5165\u7248\u672C\u53F7\uFF1A"
+    });
+    if (version == "") {
+      logger.error("\u7248\u672C\u53F7\u4E0D\u80FD\u4E3A\u7A7A\uFF01");
+      return;
+    }
+    if (/^\d/.test(version)) {
+      version = `v${version}`;
+    }
+    const tags = await getGitTags();
+    if (tags.some((tag) => tag === version)) {
+      logger.error("\u7248\u672C\u53F7\u5DF2\u5B58\u5728\uFF0C\u8BF7\u66F4\u6362\u7248\u672C\u53F7\uFF01");
+      return;
+    }
+    let remoteTargetBranch = "master";
+    if (fromPublishCmd) {
+      remoteTargetBranch = await doCustomSpecifyBranchRelease();
+    } else {
+      const releaseWay = await inquirer.select(
+        {
+          message: "\u8BF7\u9009\u62E9\u53D1\u5E03\u65B9\u5F0F\uFF1A",
+          default: "1",
+          choices: [
+            {
+              name: "Git flow\u6D41\u7A0B\u53D1\u5E03",
+              value: "1",
+              description: "\u9075\u5FAAGit flow\u6D41\u7A0B\uFF0C\u9700\u4FDD\u8BC1\u4ED3\u5E93\u5DF2\u521D\u59CB\u5316\u4E3Agit flow\u6A21\u5F0F, \u4EE5master\u4E3A\u8FDC\u7A0B\u5206\u652F\uFF0C\u6253Tag"
+            },
+            {
+              name: "\u81EA\u5B9A\u4E49\u5206\u652F\u6253\u5305\u53D1\u5E03",
+              value: "2",
+              description: "\u81EA\u5B9A\u4E49\u6307\u5B9A\u8FDC\u7A0B\u5206\u652F\uFF0C\u6253Tag\u7684\u65B9\u5F0F"
+            }
+          ]
+        }
+      );
+      if (releaseWay === "1") {
+        remoteTargetBranch = await doGitFlowRelease(version);
+      } else if (releaseWay === "2") {
+        remoteTargetBranch = await doCustomSpecifyBranchRelease();
+      } else {
+        logger.error(`\u53D1\u5E03\u65B9\u5F0F\u4E0D\u80FD\u4E3A\u7A7A`);
+        return;
+      }
+      if (remoteTargetBranch == null) {
+        logger.error(`\u76EE\u6807\u53D1\u5E03\u5206\u652F\u4E0D\u80FD\u4E3A\u7A7A`);
+        return;
+      }
+    }
+    logger.tip(`start build and pack`);
+    await execGitCheckout(remoteTargetBranch);
+    await execGitPullOrigin(remoteTargetBranch);
+    const userSelectedLatestTag = await selectLatestTag(version);
+    await execWithPipe(releaseConf.buildCmd);
+    const source = await pack(version);
+    if (source === void 0) {
+      return;
+    }
+    await publish({ ...source, remoteBranch: remoteTargetBranch, userSelectedLatestTag });
+    logger.info(pc.green("done"));
+    await execGitCheckout(originalBranch);
+  } catch (error) {
+    console.error("Error:", error);
+  }
+}
+async function doGitFlowRelease(version) {
+  const isGitFlow = await isGitFlowRepo();
+  if (!isGitFlow) {
+    logger.error("\u5F53\u524D\u4ED3\u5E93 \u975Egit flow\u4ED3\u5E93\uFF0C\u8BF7\u4F7F\u7528git flow init \u521D\u59CB\u5316\u540E\uFF0C\u518D\u6267\u884C\u6B64\u547D\u4EE4");
+    process.exit(1);
+  }
+  let { stdout: currentBranch } = await $(`git branch --show-current`);
+  const releaseBranch = `release/${version}`;
+  if (currentBranch !== "develop" && currentBranch !== releaseBranch) {
+    const { stdout } = await $("git branch -a");
+    const branches = stdout.split("\n").map((branch) => branch.trim().replace(/^\* /, ""));
+    const preReleaseBranch = branches.includes(releaseBranch) ? releaseBranch : "develop";
+    await execGitCheckout(preReleaseBranch);
+  }
+  if (currentBranch === "develop") {
+    await execGitPullOrigin(`develop`);
+    const flowReleaseRes = await execWithPipe(`git flow release start ${version}`);
+    if (!(flowReleaseRes.stdout.indexOf(`A new branch '${releaseBranch}' was created`) > -1)) {
+      logger.error("\u6267\u884C git flow release \u5931\u8D25");
+      process.exit(1);
+    }
+  } else {
+    try {
+      await execGitPullOrigin(releaseBranch);
+    } catch (error) {
+      console.error("\u{1F680} ~ doGitFlowRelease ~ error:", error);
+      if (!(error && error.toString().indexOf(`fatal: couldn't find remote ref ${releaseBranch}`) > -1)) {
+        logger.error(`\u540C\u6B65\u5206\u652F\uFF1A ${releaseBranch} \u5931\u8D25`);
+        process.exit(1);
+      }
+    }
+  }
+  try {
+    const npmVersionRes = await $(`npm version ${version} --no-git-tag-version`);
+    if (npmVersionRes.stderr) {
+      logger.error("\u6DFB\u52A0\u7248\u672C\u4FE1\u606F\u5230package.json\u5931\u8D25");
+      process.exit(1);
+    }
+    logger.info(pc.green(`\u6DFB\u52A0 ${version} \u7248\u672C\u4FE1\u606F\u5230package.json \u6210\u529F`));
+  } catch (error) {
+    if (error && error.toString().indexOf("npm error Version not changed") == -1) {
+      logger.error("\u6DFB\u52A0\u7248\u672C\u4FE1\u606F\u5230package.json\u5931\u8D25");
+      process.exit(1);
+    }
+  }
+  const hasUncommitted = await hasUncommittedChanges(true);
+  if (hasUncommitted) {
+    await $(`git add -A`);
+    await $("git commit", ["-m", `Release version: ${version}`, "--no-verify"]);
+  }
+  await execWithPipe(`git flow release finish`, [version, "-m", `Release version: ${version}`]);
+  await $(`git push --all`);
+  await $(`git push --tags`);
+  return "master";
+}
+async function doCustomSpecifyBranchRelease() {
+  const { stdout } = await $("git branch -r");
+  const branches = stdout.split("\n").map((branch) => branch.trim()).filter((item) => !item.startsWith("origin/HEAD")).map((branch) => ({ value: branch.replace("origin/", "") }));
+  const selectedBranch = await inquirer.select({
+    message: "\u8BF7\u9009\u62E9\u76EE\u6807\u5206\u652F, \u5206\u652F\u672A\u627E\u5230\uFF0C\u8BF7\u5148\u5C06\u672C\u5730\u5206\u652F\u63A8\u5230\u8FDC\u7AEF\uFF0C\u518D\u6267\u884C\u6B64\u547D\u4EE4",
+    choices: branches
+  });
+  return selectedBranch;
+}
+async function hasUncommittedChanges(boolReturned = false) {
+  const { stdout: uncommitted } = await $`git status --porcelain`;
+  if (boolReturned) {
+    return !!uncommitted.toString().length;
+  }
+  if (uncommitted.toString().length) {
+    logger.error("\u5F53\u524D\u5206\u652F\u5B58\u5728\u5C1A\u672A\u63D0\u4EA4\u7684\u6587\u4EF6\uFF0C\u8BF7\u63D0\u4EA4\u540E\u518D\u8FD0\u884C\u6B64\u547D\u4EE4");
+    return Promise.reject(true);
+  }
+  return Promise.resolve(false);
+}
+async function execGitPullOrigin(remoteTargetBranch) {
+  logger.tip(`${remoteTargetBranch} syncing...`);
+  const syncReleaseBranchRes = $("git", ["pull", "origin", remoteTargetBranch]);
+  syncReleaseBranchRes.stdout.pipe(process.stdout);
+  syncReleaseBranchRes.stderr.pipe(process.stderr);
+  const res = await syncReleaseBranchRes;
+  if (res.stdout.indexOf("fatal:") > -1 || res.stderr.indexOf("fatal:") > -1) {
+    logger.error(`\u540C\u6B65${remoteTargetBranch} \u5931\u8D25`);
+    process.exit(1);
+  }
+}
+async function execWithPipe(...args) {
+  const execRes = $(...args);
+  execRes.stdout.pipe(process.stdout);
+  execRes.stderr.pipe(process.stderr);
+  const result = await execRes;
+  return result;
+}
+async function execGitCheckout(remoteTargetBranch) {
+  await hasUncommittedChanges();
+  const { stdout: prevCurrentBranch } = await $(`git branch --show-current`);
+  if (prevCurrentBranch !== remoteTargetBranch) {
+    const execRes = $(`git checkout ${remoteTargetBranch}`);
+    execRes.stdout.pipe(process.stdout);
+    execRes.stderr.pipe(process.stderr);
+    const result = await execRes;
+    const { stdout: currentBranch } = await $(`git branch --show-current`);
+    if (currentBranch !== remoteTargetBranch) {
+      logger.error(`\u76EE\u6807\u53D1\u5E03\u5206\u652F[${remoteTargetBranch}] checkout \u5931\u8D25`);
+      return Promise.reject(result);
+    }
+  }
+}
+
+export { release };

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@wjwjq/release-helper",
+  "version": "0.0.1",
+  "description": "generate deployment package for frontend, include nginx...",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "repository": {
+    "url": "http://10.17.5.2:90/cd_front/release-helper"
+  },
+  "scripts": {
+    "localpack": "pnpm link --global",
+    "postinstall": "release-helper init",
+    "build": "rollup -c",
+    "prepublish": "pnpm build"
+  },
+  "bin": {
+    "release-helper": "./bin/index.js"
+  },
+  "keywords": [
+    "frontend",
+    "deployment",
+    "nginx"
+  ],
+  "author": "wjwjq",
+  "license": "ISC",
+  "peerDependencies": {
+    "@gitbeaker/rest": "^40.0.3",
+    "@inquirer/prompts": "^5.0.6",
+    "cac": "^6.7.14",
+    "execa": "^9.2.0",
+    "fs-extra": "^11.2.0",
+    "mime": "^4.0.3",
+    "picocolors": "^1.0.1",
+    "tar": "^7.4.0",
+    "tsx": "^4.15.6",
+    "yaml": "^2.4.5"
+  },
+  "dependencies": {
+    "@gitbeaker/rest": "^40.0.3",
+    "@inquirer/prompts": "^5.0.6",
+    "cac": "^6.7.14",
+    "execa": "^9.2.0",
+    "fs-extra": "^11.2.0",
+    "mime": "^4.0.3",
+    "picocolors": "^1.0.1",
+    "tar": "^7.4.0",
+    "tsx": "^4.15.6",
+    "yaml": "^2.4.5"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^26.0.1",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^15.2.3",
+    "@types/node": "^20.14.6",
+    "eslint": "^9.5.0",
+    "eslint-plugin-import-x": "^0.5.1",
+    "eslint-plugin-n": "^17.9.0",
+    "eslint-plugin-regexp": "^2.6.0",
+    "glob": "^10.4.2",
+    "prettier": "3.3.2",
+    "rollup": "^4.18.0",
+    "rollup-plugin-copy": "^3.5.0",
+    "rollup-plugin-dts": "^6.1.1",
+    "rollup-plugin-esbuild": "^6.1.1",
+    "typescript": "^5.5.2"
+  },
+  "type": "module",
+  "engines": {
+    "node": "^18.20.0 || >=20.0.0"
+  }
+}

package/rollup.config.js

@@ -0,0 +1,78 @@
+import nodeResolvePlugin from '@rollup/plugin-node-resolve'
+import esbuildPlugin from 'rollup-plugin-esbuild'
+import dtsPlugin from 'rollup-plugin-dts'
+import commonjsPlugin from '@rollup/plugin-commonjs'
+import jsonPlugin from '@rollup/plugin-json';
+import copyPlugin from 'rollup-plugin-copy'
+import { globSync } from 'glob';
+
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import fs from 'fs';
+
+const pkg = JSON.parse(
+  fs.readFileSync(new URL('./package.json', import.meta.url)).toString(),
+)
+
+function createConfig({ dts, esm } = {}) {
+  let file = 'dist/index.js'
+  if (dts) {
+    file = file.replace('.js', '.d.ts')
+  }
+  if (esm) {
+    file = file.replace('.js', '.mjs')
+  }
+  return {
+    input: Object.fromEntries(
+      globSync('src/**/*.ts').map(file => [
+        // This remove `src/` as well as the file extension from each
+        // file, so e.g. src/nested/foo.js becomes nested/foo
+        path.relative(
+          'src',
+          file.slice(0, file.length - path.extname(file).length)
+        ),
+        // This expands the relative paths to absolute paths, so e.g.
+        // src/nested/foo becomes /project/src/nested/foo.js
+        fileURLToPath(new URL(file, import.meta.url))
+      ])
+    ),
+    output: {
+      format: dts || esm ? 'esm' : 'cjs',
+      dir: 'dist'
+    },
+    external: [...Object.keys(pkg.dependencies)],
+    plugins: [
+      jsonPlugin(),
+      nodeResolvePlugin({
+        // mainFields: dts ? ['types', 'typings'] : ['module', 'main'],
+        // extensions: dts ? ['.d.ts', '.ts'] : ['.js', '.json', '.mjs'],
+        // customResolveOptions: {
+        //   moduleDirectories: dts
+        //     ? ['node_modules/@types', 'node_modules']
+        //     : ['node_modules'],
+        // },
+
+        // modulesOnly: true
+      }),
+      !dts && commonjsPlugin(),
+      !dts &&
+        esbuildPlugin({
+          target: 'es2022',
+        }),
+      dts && dtsPlugin(),
+      copyPlugin({
+        targets: [
+          { src: 'src/deploy', dest: 'dist' },
+          { src: 'src/.release', dest: 'dist' },
+        ]
+      })
+    ].filter(Boolean),
+  }
+}
+
+export default [
+  createConfig(),
+  // createConfig({ dts: true }),
+  createConfig({ esm: true }),
+]
+ 

package/src/.release/README.md

@@ -0,0 +1,23 @@
+# .release 目录说明
+
+## doc 目录
+
+用于release时附带的文档，文档中可以使用指定变量占位，后续执行release-helper release时会自动遍历，并替换所有变量
+
+可使用变量及说明:
+
+| **占位符**    | **含义**                                             |
+| ------------- | ---------------------------------------------------- |
+| \$APP\_NAME\$ | 应用名称（自动读取package.json中name字段值）         |
+| \$VERSION\$   | 用户指定的版本号                                     |
+| \$PKG_NAME\$  | tar.gz包名称（值为\$APP_NAME\$\_\$VERSION\$.tar.gz） |
+
+## nginx 目录
+
+用于存放服务器端nginx的启动配置文件等，部分占位说明及占位符请勿删除，会在服务器端安装后更新时，由脚本自动替换
+
+文件说明：
+| **文件或目录** | **说明**                                                  |
+| -------------- | --------------------------------------------------------- |
+| ca             | nginx https使用到的证书，变更时需对应修改nginx.conf中的值 |
+| nginx.conf     | nginx启动时 需要的配置文件                                |