@lazycatcloud/lzc-cli 1.2.26 → 1.2.28

package/lib/utils.js

@@ -1,25 +1,26 @@
-import path from "path";
-import fs from "fs";
-import os from "os";
-import glob from "fast-glob";
-import yaml from "js-yaml";
-import mergeWith from "lodash.mergewith";
-import { dirname } from "path";
-import { fileURLToPath } from "url";
-import ignore from "ignore";
-import { createHash } from "node:crypto";
-import https from "node:https";
-import http from "node:http";
-import zlib from "node:zlib";
-import process from "node:process";
-import { spawnSync } from "node:child_process";
-import logger from "loglevel";
-import * as tar from "tar";
+import path from "path"
+import fs from "fs"
+import os from "os"
+import glob from "fast-glob"
+import yaml from "js-yaml"
+import mergeWith from "lodash.mergewith"
+import { dirname } from "path"
+import { fileURLToPath } from "url"
+import ignore from "ignore"
+import { createHash } from "node:crypto"
+import https from "node:https"
+import http from "node:http"
+import zlib from "node:zlib"
+import process from "node:process"
+import { spawnSync } from "node:child_process"
+import logger from "loglevel"
+import * as tar from "tar"
+import dns from "node:dns/promises"
 
 export const envsubstr = async (templateContents, args) => {
-  const parse = await importDefault("envsub/js/envsub-parser.js");
-  return parse(templateContents, args);
-};
+  const parse = await importDefault("envsub/js/envsub-parser.js")
+  return parse(templateContents, args)
+}
 
 /**
  * 确保文件夹存在
@@ -27,31 +28,70 @@ export const envsubstr = async (templateContents, args) => {
  *
  */
 export function ensureDir(filePath) {
-  let dirPath;
+  let dirPath
   if (filePath.endsWith("/")) {
-    dirPath = filePath;
+    dirPath = filePath
   } else {
-    dirPath = path.dirname(filePath);
+    dirPath = path.dirname(filePath)
   }
   if (!fs.existsSync(dirPath)) {
-    fs.mkdirSync(dirPath, { recursive: true });
+    fs.mkdirSync(dirPath, { recursive: true })
   }
 }
 
+export function ensureDirectoryExists(filePath, isRenameOrClear) {
+  let result = { isExists: false, renamedFileName: undefined }
+  try {
+    const stats = fs.statSync(filePath) // 获取文件或目录的状态
+    result.isExists = true
+    if (isRenameOrClear) {
+      if (stats.isDirectory()) {
+        const newPath = getUniquePath(filePath)
+        result.renamedFileName = path.basename(newPath)
+        fs.renameSync(filePath, newPath)
+      } else {
+        fs.rmSync(filePath)
+      }
+      fs.mkdirSync(filePath, { recursive: true })
+    }
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      fs.mkdirSync(filePath, { recursive: true })
+    } else {
+      throw `创建文件夹${filePath}错误: ${err}`
+    }
+  }
+  return result
+}
+
+// 如果该路径已存在，则返回带递增数字的路径
+function getUniquePath(basePath) {
+  let dirName = path.basename(basePath)
+  let dirPath = basePath
+  let index = 1
+  // 检查是否存在同名目录
+  while (fs.existsSync(dirPath)) {
+    dirName = `${path.basename(basePath, path.extname(basePath))}_${index}`
+    dirPath = path.join(path.dirname(basePath), dirName)
+    index++
+  }
+  return dirPath
+}
+
 export async function createTemplateFileCommon(templateFile, outputFile, env) {
   const options = {
     envs: toPair(env),
     syntax: "default",
-    protect: false,
-  };
+    protect: false
+  }
   const output = await envsubstr(fs.readFileSync(templateFile, "utf-8"), {
-    options,
-  });
-  fs.writeFileSync(outputFile, output);
+    options
+  })
+  fs.writeFileSync(outputFile, output)
 }
 
 export function loadFromYaml(file) {
-  return yaml.load(fs.readFileSync(file, "utf8"));
+  return yaml.load(fs.readFileSync(file, "utf8"))
 }
 
 export function dumpToYaml(template, target) {
@@ -59,113 +99,113 @@ export function dumpToYaml(template, target) {
     target,
     yaml.dump(template, {
       styles: {
-        "!!null": "empty", // dump null as ""
-      },
-    }),
-  );
+        "!!null": "empty" // dump null as ""
+      }
+    })
+  )
 }
 
 export function toPair(object) {
   return Object.keys(object).map((key) => {
-    let value = object[key] ? object[key].toString() : "";
-    key = key.replace(/-/g, "_");
+    let value = object[key] ? object[key].toString() : ""
+    key = key.replace(/-/g, "_")
     return {
       name: key,
-      value,
-    };
-  });
+      value
+    }
+  })
 }
 
 export async function envTemplateFile(templateFile, env) {
-  const template = yaml.load(fs.readFileSync(templateFile, "utf8"));
+  const template = yaml.load(fs.readFileSync(templateFile, "utf8"))
   const options = {
     envs: toPair(env),
     syntax: "default",
-    protect: false,
-  };
+    protect: false
+  }
   return await envsubstr(
     yaml.dump(template, {
       styles: {
-        "!!null": "empty", // dump null as ""
-      },
+        "!!null": "empty" // dump null as ""
+      }
     }),
-    { options },
-  );
+    { options }
+  )
 }
 
 export function mergeYamlInMemory(args) {
   if (args.length == 0) {
-    return {};
+    return {}
   } else if (args.length == 1) {
-    return args[0];
+    return args[0]
   }
   return args.reduce((prev, curr) => {
     let result = mergeWith(prev, curr, (objValue, srcValue) => {
       if (Array.isArray(objValue)) {
-        return objValue.concat(srcValue);
+        return objValue.concat(srcValue)
       }
-    });
-    return result;
-  }, {});
+    })
+    return result
+  }, {})
 }
 
 export function contextDirname(url = import.meta.url) {
-  return dirname(fileURLToPath(url));
+  return dirname(fileURLToPath(url))
 }
 
 export async function importDefault(pkgPath) {
-  let mod = await import(pkgPath);
-  return mod.default;
+  let mod = await import(pkgPath)
+  return mod.default
 }
 
 export class GitIgnore {
   constructor(root) {
-    this.root = root;
-    this.ignores = [];
+    this.root = root
+    this.ignores = []
   }
 
   async collect() {
     const files = await glob(["**/.gitignore"], {
       cwd: this.root,
       dot: true,
-      deep: 3,
-    });
+      deep: 3
+    })
 
-    files.forEach((f) => this._add(f));
+    files.forEach((f) => this._add(f))
   }
 
   _add(ignoreFile) {
-    let data = fs.readFileSync(ignoreFile, "utf8");
-    let ig = ignore({ allowRelativePaths: true });
-    ig.add(data.split("\n"));
+    let data = fs.readFileSync(ignoreFile, "utf8")
+    let ig = ignore({ allowRelativePaths: true })
+    ig.add(data.split("\n"))
     this.ignores.push({
       ig,
-      dir: path.dirname(ignoreFile),
-    });
+      dir: path.dirname(ignoreFile)
+    })
   }
 
   contain(filepath) {
     return this.ignores.some(({ ig, dir }) => {
       // 去除不应该计算ignore 的文件
       if (!filepath.startsWith(dir)) {
-        return false;
+        return false
       }
 
-      return ig.ignores(path.relative(dir, filepath));
-    });
+      return ig.ignores(path.relative(dir, filepath))
+    })
   }
 }
 
 export function isDirSync(path) {
-  let stat = fs.statSync(path);
-  return stat.isDirectory();
+  let stat = fs.statSync(path)
+  return stat.isDirectory()
 }
 
 export function isDirExist(path) {
   try {
-    return isDirSync(path);
+    return isDirSync(path)
   } catch {
-    return false;
+    return false
   }
 }
 
@@ -173,173 +213,182 @@ export function isFileExist(path) {
   try {
     fs.accessSync(
       path,
-      fs.constants.W_OK | fs.constants.R_OK | fs.constants.F_OK,
-    );
-    return true;
+      fs.constants.W_OK | fs.constants.R_OK | fs.constants.F_OK
+    )
+    return true
   } catch {
-    return false;
+    return false
   }
 }
 
 export async function sleep(ms) {
   return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
+    setTimeout(resolve, ms)
+  })
 }
 
 export async function md5String(str) {
-  const hash = createHash("md5");
-  hash.update(str);
-  return hash.digest("hex");
+  const hash = createHash("md5")
+  hash.update(str)
+  return hash.digest("hex")
 }
 
 export async function md5File(filepath) {
-  const hash = createHash("md5");
-  const input = fs.createReadStream(filepath);
+  const hash = createHash("md5")
+  const input = fs.createReadStream(filepath)
   return new Promise((resolve) => {
     input.on("readable", () => {
-      const data = input.read();
+      const data = input.read()
       if (data) {
-        hash.update(data);
+        hash.update(data)
       } else {
-        resolve(hash.digest("hex"));
+        resolve(hash.digest("hex"))
       }
-    });
-  });
+    })
+  })
 }
 
 export class Downloader {
   constructor() {}
 
   showDownloadingProgress(received, total) {
-    let percentage = ((received * 100) / total).toFixed(2);
-    process.stdout.write("\r");
+    let percentage = ((received * 100) / total).toFixed(2)
+    process.stdout.write("\r")
     process.stdout.write(
       percentage +
         "% | " +
         received +
         " bytes downloaded out of " +
         total +
-        " bytes.",
-    );
+        " bytes."
+    )
   }
 
   download(url, savePath, enableGzip = false) {
-    let tmpPath = savePath + ".tmp";
-    const options = new URL(url);
-    let request = url.startsWith("https") ? https.request : http.request;
+    let tmpPath = savePath + ".tmp"
+    const options = new URL(url)
+    let request = url.startsWith("https") ? https.request : http.request
 
     return new Promise((resolve, reject) => {
       const req = request(options, (res) => {
         if (res.statusCode != 200) {
-          reject(`下载 ${url} 失败`);
-          return;
+          reject(`下载 ${url} 失败`)
+          return
         }
 
-        let total = parseInt(res.headers["content-length"]);
-        let recive = 0;
+        let total = parseInt(res.headers["content-length"])
+        let recive = 0
         res.on("data", (chunk) => {
-          recive += chunk.length;
-          this.showDownloadingProgress(recive, total);
-        });
+          recive += chunk.length
+          this.showDownloadingProgress(recive, total)
+        })
 
-        let outputFile = fs.createWriteStream(tmpPath, { flags: "w+" });
+        let outputFile = fs.createWriteStream(tmpPath, { flags: "w+" })
         if (enableGzip) {
-          let decoder = zlib.createUnzip();
-          res.pipe(decoder).pipe(outputFile);
+          let decoder = zlib.createUnzip()
+          res.pipe(decoder).pipe(outputFile)
         } else {
-          res.pipe(outputFile);
+          res.pipe(outputFile)
         }
 
-        outputFile.on("error", reject);
+        outputFile.on("error", reject)
         outputFile.on("finish", () => {
-          fs.renameSync(tmpPath, savePath);
-          process.stdout.write("\n");
-          resolve();
-        });
-      });
-      req.on("error", reject);
-      req.end();
-    });
+          fs.renameSync(tmpPath, savePath)
+          process.stdout.write("\n")
+          resolve()
+        })
+      })
+      req.on("error", reject)
+      req.end()
+    })
   }
 }
 
 export class FileLocker {
   constructor(id) {
-    this.filename = undefined;
-    this.fd = undefined;
-    this.id = id;
+    this.filename = undefined
+    this.fd = undefined
+    this.id = id
   }
   lock() {
-    this.filename = path.resolve(os.tmpdir(), "lzc-cli-file-lock", this.id);
-    ensureDir(this.filename);
+    this.filename = path.resolve(os.tmpdir(), "lzc-cli-file-lock", this.id)
+    ensureDir(this.filename)
 
     try {
-      this.fd = fs.openSync(this.filename, "wx+");
+      this.fd = fs.openSync(this.filename, "wx+")
     } catch (e) {
       if (e.code == "EEXIST" && !this.withOpen(this.filename)) {
-        logger.debug("filelock exist open with w+");
-        this.fd = fs.openSync(this.filename, "w+");
+        logger.debug("filelock exist open with w+")
+        this.fd = fs.openSync(this.filename, "w+")
       } else {
-        throw e;
+        throw e
       }
     }
   }
   unlock() {
     if (this.fd) {
-      fs.closeSync(this.fd);
-      fs.rmSync(this.filename);
-      this.fd = undefined;
-      this.filename = undefined;
+      fs.closeSync(this.fd)
+      fs.rmSync(this.filename)
+      this.fd = undefined
+      this.filename = undefined
     }
   }
   withOpen(filename) {
-    const p = spawnSync("lsof", ["-w", "-t", filename]);
+    const p = spawnSync("lsof", ["-w", "-t", filename])
     if (p.status === 0) {
-      return true;
+      return true
     } else {
-      return false;
+      return false
     }
   }
 }
 
+export function isValidAppId(appId) {
+  // 暂时去掉 - 的支持
+  // const regex = new RegExp("^[a-zA-Z0-9][a-zA-Z0-9-]{0,61}[a-zA-Z0-9]$")
+  const regex = new RegExp("^[a-z][a-z0-9]{0,61}[a-zA-Z0-9]$")
+  return regex.test(appId)
+}
+
 export function isValidPackageName(packageName) {
-  const regex = new RegExp("^(?:[a-z][a-z0-9_]*\\.)+[a-z][a-z0-9_]*$");
-  return regex.test(packageName);
+  // 暂时去掉 - 的支持
+  // const regex = new RegExp("^(?:[a-z][a-z0-9-]*\\.)+[a-z][a-z0-9-]*$")
+  const regex = new RegExp("^(?:[a-z][a-z0-9]*\\.)+[a-z][a-z0-9]*$")
+  return regex.test(packageName)
 }
 
 export function isUserApp(manifest) {
-  return !!manifest["application"]["user_app"];
+  return !!manifest["application"]["user_app"]
 }
 
 export async function tarContentDir(from, to, cwd = "./") {
   return new Promise((resolve, reject) => {
-    const dest = fs.createWriteStream(to);
+    const dest = fs.createWriteStream(to)
     tar
       .c(
         {
           cwd: cwd,
           filter: (filePath) => {
-            logger.debug(`tar gz ${filePath}`);
-            return true;
+            logger.debug(`tar gz ${filePath}`)
+            return true
           },
           sync: true,
           portable: {
             uid: 0,
-            gid: 0,
-          },
+            gid: 0
+          }
         },
-        from,
+        from
       )
       .pipe(dest)
       .on("close", () => {
-        logger.debug(`pack: ${dest.path}`);
-        resolve(dest.path);
+        logger.debug(`pack: ${dest.path}`)
+        resolve(dest.path)
       })
       .on("error", (err) => {
-        reject(err);
-      });
-  });
+        reject(err)
+      })
+  })
 }
 
 /**
@@ -350,7 +399,7 @@ export async function tarContentDir(from, to, cwd = "./") {
  */
 function isPngWithBuffer(buffer) {
   if (!buffer || buffer.length < 8) {
-    return false;
+    return false
   }
   return (
     buffer[0] === 0x89 &&
@@ -361,15 +410,43 @@ function isPngWithBuffer(buffer) {
     buffer[5] === 0x0a &&
     buffer[6] === 0x1a &&
     buffer[7] === 0x0a
-  );
+  )
 }
 
 export function isPngWithFile(filepath) {
-  if (!isFileExist(filepath)) return false;
-  const buf = fs.readFileSync(filepath);
-  return isPngWithBuffer(buf);
+  if (!isFileExist(filepath)) return false
+  const buf = fs.readFileSync(filepath)
+  return isPngWithBuffer(buf)
 }
 
 export function isDebugMode() {
-  return logger.getLevel() <= logger.levels.DEBUG;
+  return logger.getLevel() <= logger.levels.DEBUG
+}
+
+export async function resolveDomain(domain) {
+  try {
+    // Set machine's dns server as defalut dns server
+    dns.setServers(["[fc03:1136:3800::1]"])
+    const [ipv6Addresses, ipv4Addresses] = await Promise.allSettled([
+      dns.resolve6(domain),
+      dns.resolve4(domain)
+    ])
+    let resolvedAddress
+    if (
+      ipv6Addresses.status === "fulfilled" &&
+      ipv6Addresses.value.length > 0
+    ) {
+      resolvedAddress = ipv6Addresses.value[0]
+    } else if (
+      ipv4Addresses.status === "fulfilled" &&
+      ipv4Addresses.value.length > 0
+    ) {
+      resolvedAddress = ipv4Addresses.value[0]
+    } else {
+      throw new Error(`无法解析域名 ${domain}`)
+    }
+    return resolvedAddress
+  } catch (error) {
+    throw new Error(`无法解析域名 ${domain}: ${error.message}`)
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazycatcloud/lzc-cli",
-  "version": "1.2.26",
+  "version": "1.2.28",
   "description": "lazycat cloud developer kit",
   "files": [
     "template",
@@ -44,6 +44,12 @@
     "@types/command-exists": "^1.2.3",
     "prettier": "^3.3.3"
   },
+  "prettier": {
+    "bracketSameLine": true,
+    "htmlWhitespaceSensitivity": "ignore",
+    "semi": false,
+    "trailingComma": "none"
+  },
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
     "access": "public"