@teams-max/mwsp 1.0.0

package/lib/internal/buildNotify.js

@@ -0,0 +1,112 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/internal/buildNotify.ts
+var buildNotify_exports = {};
+__export(buildNotify_exports, {
+  default: () => buildNotify_default
+});
+module.exports = __toCommonJS(buildNotify_exports);
+var import_umi_request = require("umi-request");
+var import_crypto_js = __toESM(require("crypto-js"));
+var import_globals = require("zx/globals");
+var import_datetimeFormat = __toESM(require("./datetimeFormat"));
+function base64Url(str) {
+  return import_crypto_js.default.enc.Base64.stringify(str).replace(/\+/g, "-").replace(/\//g, "_");
+}
+function formatChangeLog(log) {
+  if (!log)
+    return "";
+  const commits = log.split("\n").map((commit) => {
+    const splitIndex = commit.lastIndexOf(" ");
+    return {
+      message: commit.slice(0, splitIndex),
+      id: commit.slice(splitIndex + 1)
+    };
+  });
+  return commits.map((commit) => `- ${commit.message}  ${commit.id}`).join("\n");
+}
+var statusTextMap = { doing: "\u6B63\u5728\u6784\u5EFA\u9879\u76EE", success: "\u9879\u76EE\u6784\u5EFA\u6210\u529F", fail: "\u9879\u76EE\u6784\u5EFA\u5931\u8D25" };
+var request = (0, import_umi_request.extend)({
+  headers: {
+    "Content-Type": "application/json"
+  }
+});
+var accessToken = "5ab4ff650f3c47d7a4c7feae3ce5715ae1a36c81e34c4452af25b96a8669b165";
+var secret = "81d89e48be684b94ab9acd43b49657ea7f94506b23e2400894105ecc7779735e";
+var url = "https://im.360teams.com/api/qfin-api/rce-app/robot/send";
+async function buildNotify_default({ args, appList, environment, buildStatus = "doing" }) {
+  $.verbose = false;
+  const omitDevEnv = environment.filter((item) => item !== "development");
+  const changeLog = args.changeLog || args.CHANGELOG || args.change_log || args.CHANGE_LOG || "";
+  const branch = args.branch || args.BRANCH || "";
+  const serverEnv = args.opsEnv || args.OPSENV || args.ops_env || args.OPS_ENV || "";
+  if (!omitDevEnv.length)
+    return;
+  const timestamp = new Date().getTime();
+  const msgId = timestamp;
+  const str = timestamp + "\n" + secret;
+  const sign = encodeURIComponent(base64Url(import_crypto_js.default.HmacSHA256(str, secret)));
+  let BUILD_USER = args.buildUser || args.build_user || args.BUILD_USER || (await $`git config user.name`).stdout.trim();
+  const changeLogText = formatChangeLog(changeLog);
+  let content = `${BUILD_USER} ${statusTextMap[buildStatus]}:
+`;
+  content += `APP: [${appList.join(", ")}] 
+`;
+  if (branch) {
+    content += `BRANCH: ${branch} 
+`;
+  }
+  content += `ENV: [${omitDevEnv.join(", ")}] 
+`;
+  if (serverEnv) {
+    content += `SERVER: ${serverEnv} 
+`;
+  }
+  content += `TIME: ${(0, import_datetimeFormat.default)(timestamp, "yyyy-MM-dd hh:mm:ss:S")} 
+`;
+  if (buildStatus === "doing") {
+    content += `LOG: ${changeLogText ? "\n" : ""}`;
+    content += `${changeLogText ? changeLogText : "no change"}
+`;
+  }
+  request.post(`${url}?access_token=${accessToken}&timestamp=${timestamp}&sign=${sign}`, {
+    data: {
+      msgId,
+      msgtype: "text",
+      text: { content },
+      at: {
+        isAtAll: false,
+        userIds: ["zhangxiaoyang-jk", "liuxiangdong1-jk"]
+      }
+    }
+  });
+  $.verbose = true;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/lib/internal/cross-spawn/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Made With MOXY Lda <hello@moxy.studio>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/lib/internal/cross-spawn/index.d.ts

@@ -0,0 +1,39 @@
+// Type definitions for cross-spawn 6.0
+// Project: https://github.com/moxystudio/node-cross-spawn
+// Definitions by: Alorel <https://github.com/Alorel>
+//                 ExE Boss <https://github.com/ExE-Boss>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference types="node" />
+
+import * as child_process from 'child_process';
+
+declare namespace spawn {
+  /**
+   * The `spawn()` method spawns a new process using the given `command`, with
+   * command line arguments in `args`. If omitted, `args` defaults to an empty array.
+   */
+  const spawn: typeof child_process.spawn;
+
+  /**
+   * The `spawn.sync()` method spawns a new process using the given `command`, with
+   * command line arguments in `args`. If omitted, `args` defaults to an empty array.
+   */
+  const sync: typeof child_process.spawnSync;
+}
+
+/**
+ * The `spawn()` method spawns a new process using the given `command`, with
+ * command line arguments in `args`. If omitted, `args` defaults to an empty array.
+ */
+declare function spawn(
+  command: string,
+  options: child_process.SpawnOptions,
+): child_process.ChildProcess;
+declare function spawn(
+  command: string,
+  args?: ReadonlyArray<string>,
+  options?: child_process.SpawnOptions,
+): child_process.ChildProcess;
+
+export = spawn;

package/lib/internal/cross-spawn/index.js

@@ -0,0 +1,465 @@
+// src/internal/cross-spawn/index.js
+module.exports = (() => {
+  var t = {
+    746: (t2, e2, n) => {
+      "use strict";
+      const r = n(129);
+      const s = n(855);
+      const o = n(101);
+      function spawn(t3, e3, n2) {
+        const c = s(t3, e3, n2);
+        const i = r.spawn(c.command, c.args, c.options);
+        o.hookChildProcess(i, c);
+        return i;
+      }
+      function spawnSync(t3, e3, n2) {
+        const c = s(t3, e3, n2);
+        const i = r.spawnSync(c.command, c.args, c.options);
+        i.error = i.error || o.verifyENOENTSync(i.status, c);
+        return i;
+      }
+      t2.exports = spawn;
+      t2.exports.spawn = spawn;
+      t2.exports.sync = spawnSync;
+      t2.exports._parse = s;
+      t2.exports._enoent = o;
+    },
+    101: (t2) => {
+      "use strict";
+      const e2 = process.platform === "win32";
+      function notFoundError(t3, e3) {
+        return Object.assign(new Error(`${e3} ${t3.command} ENOENT`), {
+          code: "ENOENT",
+          errno: "ENOENT",
+          syscall: `${e3} ${t3.command}`,
+          path: t3.command,
+          spawnargs: t3.args
+        });
+      }
+      function hookChildProcess(t3, n) {
+        if (!e2) {
+          return;
+        }
+        const r = t3.emit;
+        t3.emit = function(e3, s) {
+          if (e3 === "exit") {
+            const e4 = verifyENOENT(s, n, "spawn");
+            if (e4) {
+              return r.call(t3, "error", e4);
+            }
+          }
+          return r.apply(t3, arguments);
+        };
+      }
+      function verifyENOENT(t3, n) {
+        if (e2 && t3 === 1 && !n.file) {
+          return notFoundError(n.original, "spawn");
+        }
+        return null;
+      }
+      function verifyENOENTSync(t3, n) {
+        if (e2 && t3 === 1 && !n.file) {
+          return notFoundError(n.original, "spawnSync");
+        }
+        return null;
+      }
+      t2.exports = {
+        hookChildProcess,
+        verifyENOENT,
+        verifyENOENTSync,
+        notFoundError
+      };
+    },
+    855: (t2, e2, n) => {
+      "use strict";
+      const r = n(622);
+      const s = n(274);
+      const o = n(48);
+      const c = n(252);
+      const i = process.platform === "win32";
+      const a = /\.(?:com|exe)$/i;
+      const u = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+      function detectShebang(t3) {
+        t3.file = s(t3);
+        const e3 = t3.file && c(t3.file);
+        if (e3) {
+          t3.args.unshift(t3.file);
+          t3.command = e3;
+          return s(t3);
+        }
+        return t3.file;
+      }
+      function parseNonShell(t3) {
+        if (!i) {
+          return t3;
+        }
+        const e3 = detectShebang(t3);
+        const n2 = !a.test(e3);
+        if (t3.options.forceShell || n2) {
+          const n3 = u.test(e3);
+          t3.command = r.normalize(t3.command);
+          t3.command = o.command(t3.command);
+          t3.args = t3.args.map((t4) => o.argument(t4, n3));
+          const s2 = [t3.command].concat(t3.args).join(" ");
+          t3.args = ["/d", "/s", "/c", `"${s2}"`];
+          t3.command = process.env.comspec || "cmd.exe";
+          t3.options.windowsVerbatimArguments = true;
+        }
+        return t3;
+      }
+      function parse(t3, e3, n2) {
+        if (e3 && !Array.isArray(e3)) {
+          n2 = e3;
+          e3 = null;
+        }
+        e3 = e3 ? e3.slice(0) : [];
+        n2 = Object.assign({}, n2);
+        const r2 = {
+          command: t3,
+          args: e3,
+          options: n2,
+          file: void 0,
+          original: { command: t3, args: e3 }
+        };
+        return n2.shell ? r2 : parseNonShell(r2);
+      }
+      t2.exports = parse;
+    },
+    48: (t2) => {
+      "use strict";
+      const e2 = /([()\][%!^"`<>&|;, *?])/g;
+      function escapeCommand(t3) {
+        t3 = t3.replace(e2, "^$1");
+        return t3;
+      }
+      function escapeArgument(t3, n) {
+        t3 = `${t3}`;
+        t3 = t3.replace(/(\\*)"/g, '$1$1\\"');
+        t3 = t3.replace(/(\\*)$/, "$1$1");
+        t3 = `"${t3}"`;
+        t3 = t3.replace(e2, "^$1");
+        if (n) {
+          t3 = t3.replace(e2, "^$1");
+        }
+        return t3;
+      }
+      t2.exports.command = escapeCommand;
+      t2.exports.argument = escapeArgument;
+    },
+    252: (t2, e2, n) => {
+      "use strict";
+      const r = n(747);
+      const s = n(32);
+      function readShebang(t3) {
+        const e3 = 150;
+        const n2 = Buffer.alloc(e3);
+        let o;
+        try {
+          o = r.openSync(t3, "r");
+          r.readSync(o, n2, 0, e3, 0);
+          r.closeSync(o);
+        } catch (t4) {
+        }
+        return s(n2.toString());
+      }
+      t2.exports = readShebang;
+    },
+    274: (t2, e2, n) => {
+      "use strict";
+      const r = n(622);
+      const s = n(207);
+      const o = n(60);
+      function resolveCommandAttempt(t3, e3) {
+        const n2 = t3.options.env || process.env;
+        const c = process.cwd();
+        const i = t3.options.cwd != null;
+        const a = i && process.chdir !== void 0 && !process.chdir.disabled;
+        if (a) {
+          try {
+            process.chdir(t3.options.cwd);
+          } catch (t4) {
+          }
+        }
+        let u;
+        try {
+          u = s.sync(t3.command, { path: n2[o({ env: n2 })], pathExt: e3 ? r.delimiter : void 0 });
+        } catch (t4) {
+        } finally {
+          if (a) {
+            process.chdir(c);
+          }
+        }
+        if (u) {
+          u = r.resolve(i ? t3.options.cwd : "", u);
+        }
+        return u;
+      }
+      function resolveCommand(t3) {
+        return resolveCommandAttempt(t3) || resolveCommandAttempt(t3, true);
+      }
+      t2.exports = resolveCommand;
+    },
+    60: (t2) => {
+      "use strict";
+      const e2 = (t3 = {}) => {
+        const e3 = t3.env || process.env;
+        const n = t3.platform || process.platform;
+        if (n !== "win32") {
+          return "PATH";
+        }
+        return Object.keys(e3).reverse().find((t4) => t4.toUpperCase() === "PATH") || "Path";
+      };
+      t2.exports = e2;
+      t2.exports.default = e2;
+    },
+    126: (t2, e2, n) => {
+      var r = n(747);
+      var s;
+      if (process.platform === "win32" || global.TESTING_WINDOWS) {
+        s = n(1);
+      } else {
+        s = n(728);
+      }
+      t2.exports = isexe;
+      isexe.sync = sync;
+      function isexe(t3, e3, n2) {
+        if (typeof e3 === "function") {
+          n2 = e3;
+          e3 = {};
+        }
+        if (!n2) {
+          if (typeof Promise !== "function") {
+            throw new TypeError("callback not provided");
+          }
+          return new Promise(function(n3, r2) {
+            isexe(t3, e3 || {}, function(t4, e4) {
+              if (t4) {
+                r2(t4);
+              } else {
+                n3(e4);
+              }
+            });
+          });
+        }
+        s(t3, e3 || {}, function(t4, r2) {
+          if (t4) {
+            if (t4.code === "EACCES" || e3 && e3.ignoreErrors) {
+              t4 = null;
+              r2 = false;
+            }
+          }
+          n2(t4, r2);
+        });
+      }
+      function sync(t3, e3) {
+        try {
+          return s.sync(t3, e3 || {});
+        } catch (t4) {
+          if (e3 && e3.ignoreErrors || t4.code === "EACCES") {
+            return false;
+          } else {
+            throw t4;
+          }
+        }
+      }
+    },
+    728: (t2, e2, n) => {
+      t2.exports = isexe;
+      isexe.sync = sync;
+      var r = n(747);
+      function isexe(t3, e3, n2) {
+        r.stat(t3, function(t4, r2) {
+          n2(t4, t4 ? false : checkStat(r2, e3));
+        });
+      }
+      function sync(t3, e3) {
+        return checkStat(r.statSync(t3), e3);
+      }
+      function checkStat(t3, e3) {
+        return t3.isFile() && checkMode(t3, e3);
+      }
+      function checkMode(t3, e3) {
+        var n2 = t3.mode;
+        var r2 = t3.uid;
+        var s = t3.gid;
+        var o = e3.uid !== void 0 ? e3.uid : process.getuid && process.getuid();
+        var c = e3.gid !== void 0 ? e3.gid : process.getgid && process.getgid();
+        var i = parseInt("100", 8);
+        var a = parseInt("010", 8);
+        var u = parseInt("001", 8);
+        var p = i | a;
+        var l = n2 & u || n2 & a && s === c || n2 & i && r2 === o || n2 & p && o === 0;
+        return l;
+      }
+    },
+    1: (t2, e2, n) => {
+      t2.exports = isexe;
+      isexe.sync = sync;
+      var r = n(747);
+      function checkPathExt(t3, e3) {
+        var n2 = e3.pathExt !== void 0 ? e3.pathExt : process.env.PATHEXT;
+        if (!n2) {
+          return true;
+        }
+        n2 = n2.split(";");
+        if (n2.indexOf("") !== -1) {
+          return true;
+        }
+        for (var r2 = 0; r2 < n2.length; r2++) {
+          var s = n2[r2].toLowerCase();
+          if (s && t3.substr(-s.length).toLowerCase() === s) {
+            return true;
+          }
+        }
+        return false;
+      }
+      function checkStat(t3, e3, n2) {
+        if (!t3.isSymbolicLink() && !t3.isFile()) {
+          return false;
+        }
+        return checkPathExt(e3, n2);
+      }
+      function isexe(t3, e3, n2) {
+        r.stat(t3, function(r2, s) {
+          n2(r2, r2 ? false : checkStat(s, t3, e3));
+        });
+      }
+      function sync(t3, e3) {
+        return checkStat(r.statSync(t3), t3, e3);
+      }
+    },
+    32: (t2, e2, n) => {
+      "use strict";
+      const r = n(638);
+      t2.exports = (t3 = "") => {
+        const e3 = t3.match(r);
+        if (!e3) {
+          return null;
+        }
+        const [n2, s] = e3[0].replace(/#! ?/, "").split(" ");
+        const o = n2.split("/").pop();
+        if (o === "env") {
+          return s;
+        }
+        return s ? `${o} ${s}` : o;
+      };
+    },
+    638: (t2) => {
+      "use strict";
+      t2.exports = /^#!(.*)/;
+    },
+    207: (t2, e2, n) => {
+      const r = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
+      const s = n(622);
+      const o = r ? ";" : ":";
+      const c = n(126);
+      const i = (t3) => Object.assign(new Error(`not found: ${t3}`), { code: "ENOENT" });
+      const a = (t3, e3) => {
+        const n2 = e3.colon || o;
+        const s2 = t3.match(/\//) || r && t3.match(/\\/) ? [""] : [...r ? [process.cwd()] : [], ...(e3.path || process.env.PATH || "").split(n2)];
+        const c2 = r ? e3.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
+        const i2 = r ? c2.split(n2) : [""];
+        if (r) {
+          if (t3.indexOf(".") !== -1 && i2[0] !== "")
+            i2.unshift("");
+        }
+        return { pathEnv: s2, pathExt: i2, pathExtExe: c2 };
+      };
+      const u = (t3, e3, n2) => {
+        if (typeof e3 === "function") {
+          n2 = e3;
+          e3 = {};
+        }
+        if (!e3)
+          e3 = {};
+        const { pathEnv: r2, pathExt: o2, pathExtExe: u2 } = a(t3, e3);
+        const p2 = [];
+        const l = (n3) => new Promise((o3, c2) => {
+          if (n3 === r2.length)
+            return e3.all && p2.length ? o3(p2) : c2(i(t3));
+          const a2 = r2[n3];
+          const u3 = /^".*"$/.test(a2) ? a2.slice(1, -1) : a2;
+          const l2 = s.join(u3, t3);
+          const d = !u3 && /^\.[\\\/]/.test(t3) ? t3.slice(0, 2) + l2 : l2;
+          o3(f(d, n3, 0));
+        });
+        const f = (t4, n3, r3) => new Promise((s2, i2) => {
+          if (r3 === o2.length)
+            return s2(l(n3 + 1));
+          const a2 = o2[r3];
+          c(t4 + a2, { pathExt: u2 }, (o3, c2) => {
+            if (!o3 && c2) {
+              if (e3.all)
+                p2.push(t4 + a2);
+              else
+                return s2(t4 + a2);
+            }
+            return s2(f(t4, n3, r3 + 1));
+          });
+        });
+        return n2 ? l(0).then((t4) => n2(null, t4), n2) : l(0);
+      };
+      const p = (t3, e3) => {
+        e3 = e3 || {};
+        const { pathEnv: n2, pathExt: r2, pathExtExe: o2 } = a(t3, e3);
+        const u2 = [];
+        for (let i2 = 0; i2 < n2.length; i2++) {
+          const a2 = n2[i2];
+          const p2 = /^".*"$/.test(a2) ? a2.slice(1, -1) : a2;
+          const l = s.join(p2, t3);
+          const f = !p2 && /^\.[\\\/]/.test(t3) ? t3.slice(0, 2) + l : l;
+          for (let t4 = 0; t4 < r2.length; t4++) {
+            const n3 = f + r2[t4];
+            try {
+              const t5 = c.sync(n3, { pathExt: o2 });
+              if (t5) {
+                if (e3.all)
+                  u2.push(n3);
+                else
+                  return n3;
+              }
+            } catch (t5) {
+            }
+          }
+        }
+        if (e3.all && u2.length)
+          return u2;
+        if (e3.nothrow)
+          return null;
+        throw i(t3);
+      };
+      t2.exports = u;
+      u.sync = p;
+    },
+    129: (t2) => {
+      "use strict";
+      t2.exports = require("child_process");
+    },
+    747: (t2) => {
+      "use strict";
+      t2.exports = require("fs");
+    },
+    622: (t2) => {
+      "use strict";
+      t2.exports = require("path");
+    }
+  };
+  var e = {};
+  function __nccwpck_require__(n) {
+    if (e[n]) {
+      return e[n].exports;
+    }
+    var r = e[n] = { exports: {} };
+    var s = true;
+    try {
+      t[n](r, r.exports, __nccwpck_require__);
+      s = false;
+    } finally {
+      if (s)
+        delete e[n];
+    }
+    return r.exports;
+  }
+  __nccwpck_require__.ab = __dirname + "/";
+  return __nccwpck_require__(746);
+})();

package/lib/internal/cross-spawn/package.json

@@ -0,0 +1 @@
+{"name":"cross-spawn","main":"index.js","author":"André Cruz <andre@moxy.studio>","license":"MIT","types":"index.d.ts"}

package/lib/internal/datetimeFormat.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 日期时间格式化
+ * @param {Date | String | Number} value 时间、类时间对象
+ * @param {String} format 格式：yyyy-MM-dd hh:mm:ss:S
+ * @param {Boolean} isCoerce 是否对类时间格式强制转换
+ * @returns {String} 返回格式化后的值
+ */
+declare function datetimeFormat(value: any, format: string, isCoerce?: boolean): string;
+export default datetimeFormat;