@lazycatcloud/lzc-cli 1.3.12 → 1.3.14

package/lib/utils.js

@@ -1,101 +1,108 @@
-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 spawn from "cross-spawn"
-import logger from "loglevel"
-import * as tar from "tar"
-import dns from "node:dns"
-import AdmZip from "adm-zip"
-import commandExists from "command-exists"
-import fetch from "node-fetch"
-import semver from "semver"
-import inquirer from "inquirer"
+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 spawn from 'cross-spawn';
+import logger from 'loglevel';
+import * as tar from 'tar';
+import dns from 'node:dns';
+import AdmZip from 'adm-zip';
+import commandExists from 'command-exists';
+import fetch from 'node-fetch';
+import semver from 'semver';
+import inquirer from 'inquirer';
+import { t } from './i18n/index.js';
 
 // lzc-cli 包的 pkgInfo 信息
-export const pkgInfo = JSON.parse(
-  fs.readFileSync(
-    path.join(contextDirname(import.meta.url), "..", "package.json")
-  )
-)
+export const pkgInfo = JSON.parse(fs.readFileSync(path.join(contextDirname(import.meta.url), '..', 'package.json')));
 
 export function checkNodejsVersion() {
-  const requiredVersion = pkgInfo.engines.node
-  if (!semver.satisfies(process.version, requiredVersion)) {
-    logger.error(
-      `检测到您当前的 nodejs 版本 ${process.version} 不匹配，lzc-cli 最低要求 nodejs 版本为 ${requiredVersion}, 请升级`
-    )
-    process.exit(1)
-  }
-
-  // 如果版本小于 21.0.0 且大于等于 16.15.0，禁用 Fetch API 实验性警告
-  if (
-    semver.lt(process.version, "21.0.0") &&
-    semver.gte(process.version, "16.15.0")
-  ) {
-    process.removeAllListeners("warning")
-  }
+	const requiredVersion = pkgInfo.engines.node;
+	if (!semver.satisfies(process.version, requiredVersion)) {
+		logger.error(
+			t('lzc_cli.lib.utils.check_nodejs_version_no_match_tips', `检测到您当前的 nodejs 版本 {{ version }} 不匹配，lzc-cli 最低要求 nodejs 版本为 {{ requiredVersion }}, 请升级`, {
+				version: process.version,
+				requiredVersion,
+			}),
+		);
+		process.exit(1);
+	}
+
+	// 如果版本小于 21.0.0 且大于等于 16.15.0，禁用 Fetch API 实验性警告
+	if (semver.lt(process.version, '21.0.0') && semver.gte(process.version, '16.15.0')) {
+		process.removeAllListeners('warning');
+	}
 }
 
 export async function getLatestVersion(controller, pkgName = pkgInfo.name) {
-  const url = `https://data.jsdelivr.com/v1/package/npm/${pkgName}`
-  try {
-    logger.debug("check latest lzc-cli version...")
-    const data = await fetch(url, {
-      signal: controller.signal
-    })
-    const content = await data.json()
-    const latestVersion = content["tags"]["latest"]
-    if (semver.lt(pkgInfo.version, latestVersion)) {
-      logger.warn(
-        `检测到 ${pkgName} 最新版本为 ${latestVersion}，使用 'npm i -g ${pkgName}@${latestVersion}' 升级到最新版本!`
-      )
-    } else {
-      logger.debug(`已经在最新版本: ${latestVersion}`)
-    }
-  } catch (err) {
-    logger.debug(`请求 ${url} 失败, error: ${err}`)
-  }
-}
-
-export const isMacOs = process.platform == "darwin"
-export const isLinux = process.platform == "linux"
-export const isWindows = process.platform == "win32"
+	const url = `https://data.jsdelivr.com/v1/package/npm/${pkgName}`;
+	try {
+		logger.debug('check latest lzc-cli version...');
+		const data = await fetch(url, {
+			signal: controller.signal,
+		});
+		const content = await data.json();
+		const latestVersion = content['tags']['latest'];
+		if (semver.lt(pkgInfo.version, latestVersion)) {
+			logger.warn(
+				t('lzc_cli.lib.utils.get_latest_version_tips', `检测到 {{ pkgName }} 最新版本为 {{ latestVersion }}，使用 'npm i -g {{ pkgName }}@{{ latestVersion }}' 升级到最新版本!`, {
+					pkgName,
+					latestVersion,
+					interpolation: { escapeValue: false }
+				}),
+			);
+		} else {
+			logger.debug(t('lzc_cli.lib.utils.get_latest_version_success_tips', `已经在最新版本: {{ latestVersion }}`, { latestVersion }));
+		}
+	} catch (err) {
+		logger.debug(
+			t('lzc_cli.lib.utils.get_latest_version_fail_tips', `请求 {{ url }} 失败, error: {{ err }}`, {
+				url,
+				err,
+				interpolation: { escapeValue: false }
+			}),
+		);
+	}
+}
+
+export const isMacOs = process.platform == 'darwin';
+export const isLinux = process.platform == 'linux';
+export const isWindows = process.platform == 'win32';
 
 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);
+};
 
 // 比较当前的版本和want的大小，如果
 //  - 当前版本大于指定的版本 => 1
 //  - 当前版本等于指定的版本 => 0
 //  - 当前版本小于指定的版本 => -1
 export function compareVersions(want, current = pkgInfo.version) {
-  const wantArrs = want.split(".")
-  const currArrs = current.split(".")
+	const wantArrs = want.split('.');
+	const currArrs = current.split('.');
 
-  // Compare each part
-  for (let i = 0; i < Math.max(wantArrs.length, currArrs.length); i++) {
-    // Convert to integers, default to 0 if part doesn't exist
-    const w = parseInt(wantArrs[i] || 0)
-    const c = parseInt(currArrs[i] || 0)
+	// Compare each part
+	for (let i = 0; i < Math.max(wantArrs.length, currArrs.length); i++) {
+		// Convert to integers, default to 0 if part doesn't exist
+		const w = parseInt(wantArrs[i] || 0);
+		const c = parseInt(currArrs[i] || 0);
 
-    if (c > w) return 1
-    if (c < w) return -1
-  }
+		if (c > w) return 1;
+		if (c < w) return -1;
+	}
 
-  return 0 // Versions are equal
+	return 0; // Versions are equal
 }
 
 /**
@@ -104,354 +111,348 @@ export function compareVersions(want, current = pkgInfo.version) {
  *
  */
 export function ensureDir(filePath) {
-  let dirPath
-  if (filePath.endsWith("/")) {
-    dirPath = filePath
-  } else {
-    dirPath = path.dirname(filePath)
-  }
-  if (!fs.existsSync(dirPath)) {
-    fs.mkdirSync(dirPath, { recursive: true })
-  }
+	let dirPath;
+	if (filePath.endsWith('/')) {
+		dirPath = filePath;
+	} else {
+		dirPath = path.dirname(filePath);
+	}
+	if (!fs.existsSync(dirPath)) {
+		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
+	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 t('lzc_cli.lib.utils.ensure_directory_exists_fail', `创建文件夹{{ filePath }}错误: {{ err }}`, {
+				filePath,
+				err,
+				interpolation: { escapeValue: false }
+			});
+		}
+	}
+	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
+	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
-  }
-  const output = await envsubstr(fs.readFileSync(templateFile, "utf-8"), {
-    options
-  })
-  fs.writeFileSync(outputFile, output)
+	const options = {
+		envs: toPair(env),
+		syntax: 'default',
+		protect: false,
+	};
+	const output = await envsubstr(fs.readFileSync(templateFile, 'utf-8'), {
+		options,
+	});
+	fs.writeFileSync(outputFile, output);
 }
 
 export function loadFromYaml(file) {
-  return yaml.load(fs.readFileSync(file, "utf8"))
+	return yaml.load(fs.readFileSync(file, 'utf8'));
 }
 
 // lzc-manifest.yml 要支持模板，目前无法直接用yaml库解释，手动读出必要字段
 export function fakeLoadManifestYml(file) {
-  const res = fs.readFileSync(file, "utf8")
-  let obj = {
-    application: {
-      subdomain: undefined
-    }
-  }
-
-  res.split("\n").forEach((v) => {
-    let line = v.trim()
-    const arr = line.split(":")
-    if (arr.length != 2) {
-      return
-    }
-    let [key, value] = arr
-    value = value.trim()
-    if (!obj.package && key == "package") {
-      obj.package = value
-    }
-    if (!obj.application.subdomain && key == "subdomain") {
-      obj.application.subdomain = value
-    }
-    if (!obj.version && key == "version") {
-      obj.version = value
-    }
-  })
-  return obj
+	const res = fs.readFileSync(file, 'utf8');
+	let obj = {
+		application: {
+			subdomain: undefined,
+		},
+	};
+
+	res.split('\n').forEach((v) => {
+		let line = v.trim();
+		const arr = line.split(':');
+		if (arr.length != 2) {
+			return;
+		}
+		let [key, value] = arr;
+		value = value.trim();
+		if (!obj.package && key == 'package') {
+			obj.package = value;
+		}
+		if (!obj.application.subdomain && key == 'subdomain') {
+			obj.application.subdomain = value;
+		}
+		if (!obj.version && key == 'version') {
+			obj.version = value;
+		}
+	});
+	return obj;
 }
 
 export function dumpToYaml(template, target) {
-  fs.writeFileSync(
-    target,
-    yaml.dump(template, {
-      styles: {
-        "!!null": "empty" // dump null as ""
-      }
-    })
-  )
+	fs.writeFileSync(
+		target,
+		yaml.dump(template, {
+			styles: {
+				'!!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, "_")
-    return {
-      name: key,
-      value
-    }
-  })
+	return Object.keys(object).map((key) => {
+		let value = object[key] ? object[key].toString() : '';
+		key = key.replace(/-/g, '_');
+		return {
+			name: key,
+			value,
+		};
+	});
 }
 
 export async function envTemplateFile(templateFile, env) {
-  const template = yaml.load(fs.readFileSync(templateFile, "utf8"))
-  const options = {
-    envs: toPair(env),
-    syntax: "default",
-    protect: false
-  }
-  return await envsubstr(
-    yaml.dump(template, {
-      styles: {
-        "!!null": "empty" // dump null as ""
-      }
-    }),
-    { options }
-  )
+	const template = yaml.load(fs.readFileSync(templateFile, 'utf8'));
+	const options = {
+		envs: toPair(env),
+		syntax: 'default',
+		protect: false,
+	};
+	return await envsubstr(
+		yaml.dump(template, {
+			styles: {
+				'!!null': 'empty', // dump null as ""
+			},
+		}),
+		{ options },
+	);
 }
 
 export function mergeYamlInMemory(args) {
-  if (args.length == 0) {
-    return {}
-  } else if (args.length == 1) {
-    return args[0]
-  }
-  return args.reduce((prev, curr) => {
-    let result = mergeWith(prev, curr, (objValue, srcValue) => {
-      if (Array.isArray(objValue)) {
-        return objValue.concat(srcValue)
-      }
-    })
-    return result
-  }, {})
+	if (args.length == 0) {
+		return {};
+	} else if (args.length == 1) {
+		return args[0];
+	}
+	return args.reduce((prev, curr) => {
+		let result = mergeWith(prev, curr, (objValue, srcValue) => {
+			if (Array.isArray(objValue)) {
+				return objValue.concat(srcValue);
+			}
+		});
+		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 = []
-  }
-
-  async collect() {
-    const files = await glob(["**/.gitignore"], {
-      cwd: this.root,
-      dot: true,
-      deep: 3
-    })
-
-    files.forEach((f) => this._add(f))
-  }
-
-  _add(ignoreFile) {
-    let data = fs.readFileSync(ignoreFile, "utf8")
-    let ig = ignore({ allowRelativePaths: true })
-    ig.add(data.split("\n"))
-    this.ignores.push({
-      ig,
-      dir: path.dirname(ignoreFile)
-    })
-  }
-
-  contain(filepath) {
-    return this.ignores.some(({ ig, dir }) => {
-      // 去除不应该计算ignore 的文件
-      if (!filepath.startsWith(dir)) {
-        return false
-      }
-
-      return ig.ignores(path.relative(dir, filepath))
-    })
-  }
+	constructor(root) {
+		this.root = root;
+		this.ignores = [];
+	}
+
+	async collect() {
+		const files = await glob(['**/.gitignore'], {
+			cwd: this.root,
+			dot: true,
+			deep: 3,
+		});
+
+		files.forEach((f) => this._add(f));
+	}
+
+	_add(ignoreFile) {
+		let data = fs.readFileSync(ignoreFile, 'utf8');
+		let ig = ignore({ allowRelativePaths: true });
+		ig.add(data.split('\n'));
+		this.ignores.push({
+			ig,
+			dir: path.dirname(ignoreFile),
+		});
+	}
+
+	contain(filepath) {
+		return this.ignores.some(({ ig, dir }) => {
+			// 去除不应该计算ignore 的文件
+			if (!filepath.startsWith(dir)) {
+				return false;
+			}
+
+			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)
-  } catch {
-    return false
-  }
+	try {
+		return isDirSync(path);
+	} catch {
+		return false;
+	}
 }
 
 export function isFileExist(path) {
-  try {
-    fs.accessSync(path, fs.constants.R_OK | fs.constants.F_OK)
-    return true
-  } catch (err) {
-    logger.debug(`access ${path} error: ${err}`)
-    return false
-  }
+	try {
+		fs.accessSync(path, fs.constants.R_OK | fs.constants.F_OK);
+		return true;
+	} catch (err) {
+		logger.debug(`access ${path} error: ${err}`);
+		return false;
+	}
 }
 
 export async function sleep(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms)
-  })
+	return new Promise((resolve) => {
+		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)
-  return new Promise((resolve) => {
-    input.on("readable", () => {
-      const data = input.read()
-      if (data) {
-        hash.update(data)
-      } else {
-        resolve(hash.digest("hex"))
-      }
-    })
-  })
+	const hash = createHash('md5');
+	const input = fs.createReadStream(filepath);
+	return new Promise((resolve) => {
+		input.on('readable', () => {
+			const data = input.read();
+			if (data) {
+				hash.update(data);
+			} else {
+				resolve(hash.digest('hex'));
+			}
+		});
+	});
 }
 
 export class Downloader {
-  constructor() {}
-
-  showDownloadingProgress(received, total) {
-    let percentage = ((received * 100) / total).toFixed(2)
-    process.stdout.write("\r")
-    process.stdout.write(
-      percentage +
-        "% | " +
-        received +
-        " bytes downloaded out of " +
-        total +
-        " bytes."
-    )
-  }
-
-  download(url, savePath, enableGzip = false) {
-    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
-        }
-
-        let total = parseInt(res.headers["content-length"])
-        let recive = 0
-        res.on("data", (chunk) => {
-          recive += chunk.length
-          this.showDownloadingProgress(recive, total)
-        })
-
-        let outputFile = fs.createWriteStream(tmpPath, { flags: "w+" })
-        if (enableGzip) {
-          let decoder = zlib.createUnzip()
-          res.pipe(decoder).pipe(outputFile)
-        } else {
-          res.pipe(outputFile)
-        }
-
-        outputFile.on("error", reject)
-        outputFile.on("finish", () => {
-          fs.renameSync(tmpPath, savePath)
-          process.stdout.write("\n")
-          resolve()
-        })
-      })
-      req.on("error", reject)
-      req.end()
-    })
-  }
+	constructor() { }
+
+	showDownloadingProgress(received, total) {
+		let percentage = ((received * 100) / total).toFixed(2);
+		process.stdout.write('\r');
+		process.stdout.write(percentage + '% | ' + received + ' bytes downloaded out of ' + total + ' bytes.');
+	}
+
+	download(url, savePath, enableGzip = false) {
+		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(`download ${url} fail`);
+					return;
+				}
+
+				let total = parseInt(res.headers['content-length']);
+				let recive = 0;
+				res.on('data', (chunk) => {
+					recive += chunk.length;
+					this.showDownloadingProgress(recive, total);
+				});
+
+				let outputFile = fs.createWriteStream(tmpPath, { flags: 'w+' });
+				if (enableGzip) {
+					let decoder = zlib.createUnzip();
+					res.pipe(decoder).pipe(outputFile);
+				} else {
+					res.pipe(outputFile);
+				}
+
+				outputFile.on('error', reject);
+				outputFile.on('finish', () => {
+					fs.renameSync(tmpPath, savePath);
+					process.stdout.write('\n');
+					resolve();
+				});
+			});
+			req.on('error', reject);
+			req.end();
+		});
+	}
 }
 
 export function isValidAppId(appId) {
-  const regex = new RegExp("^(?!-)(?!.*--)[a-z][a-z0-9]*([-][a-z0-9]+)*$")
-  return regex.test(appId)
+	const regex = new RegExp('^(?!-)(?!.*--)[a-z][a-z0-9]*([-][a-z0-9]+)*$');
+	return regex.test(appId);
 }
 
 export function isValidPackageName(packageName) {
-  const regex = new RegExp(
-    "^[a-z][a-z0-9]*([-][a-z0-9]+)*(?:\\.[a-z][a-z0-9]*([-][a-z0-9]+)*)*$"
-  )
-  return regex.test(packageName)
+	const regex = new RegExp('^[a-z][a-z0-9]*([-][a-z0-9]+)*(?:\\.[a-z][a-z0-9]*([-][a-z0-9]+)*)*$');
+	return regex.test(packageName);
 }
 
 export function isUserApp(manifest) {
-  return !!manifest["application"]["user_app"]
-}
-
-export async function tarContentDir(from, to, cwd = "./") {
-  return new Promise((resolve, reject) => {
-    const dest = fs.createWriteStream(to)
-    tar
-      .c(
-        {
-          cwd: cwd,
-          filter: (filePath) => {
-            logger.debug(`tar gz ${filePath}`)
-            return true
-          },
-          sync: true,
-          portable: {
-            uid: 0,
-            gid: 0
-          }
-        },
-        from
-      )
-      .pipe(dest)
-      .on("close", () => {
-        logger.debug(`pack: ${dest.path}`)
-        resolve(dest.path)
-      })
-      .on("error", (err) => {
-        reject(err)
-      })
-  })
+	return !!manifest['application']['user_app'];
+}
+
+export async function tarContentDir(from, to, cwd = './') {
+	return new Promise((resolve, reject) => {
+		const dest = fs.createWriteStream(to);
+		tar.c(
+			{
+				cwd: cwd,
+				filter: (filePath) => {
+					logger.debug(`tar gz ${filePath}`);
+					return true;
+				},
+				sync: true,
+				portable: {
+					uid: 0,
+					gid: 0,
+				},
+			},
+			from,
+		)
+			.pipe(dest)
+			.on('close', () => {
+				logger.debug(`pack: ${dest.path}`);
+				resolve(dest.path);
+			})
+			.on('error', (err) => {
+				reject(err);
+			});
+	});
 }
 
 /**
@@ -461,228 +462,214 @@ export async function tarContentDir(from, to, cwd = "./") {
  * @returns {boolean}
  */
 function isPngWithBuffer(buffer) {
-  if (!buffer || buffer.length < 8) {
-    return false
-  }
-  return (
-    buffer[0] === 0x89 &&
-    buffer[1] === 0x50 &&
-    buffer[2] === 0x4e &&
-    buffer[3] === 0x47 &&
-    buffer[4] === 0x0d &&
-    buffer[5] === 0x0a &&
-    buffer[6] === 0x1a &&
-    buffer[7] === 0x0a
-  )
+	if (!buffer || buffer.length < 8) {
+		return false;
+	}
+	return (
+		buffer[0] === 0x89 && buffer[1] === 0x50 && buffer[2] === 0x4e && buffer[3] === 0x47 && buffer[4] === 0x0d && 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 function isTraceMode() {
-  return logger.getLevel() <= logger.levels.TRACE
+	return logger.getLevel() <= logger.levels.TRACE;
 }
 
 // 没有直接使用 dns/promise，因为这个 dns/promise 是在 15.0.0 后加入，如果低版本
 // 会直接报错，连版本检测都到不了(包导入的太前面了)
 async function __resolveDomain(domain, ipv6 = false) {
-  return new Promise((resolve, reject) => {
-    const callback = function (err, addresses) {
-      if (addresses && addresses.length > 0) {
-        resolve(addresses[0])
-      } else {
-        logger.trace("dns resolve error: ", err)
-        reject(err)
-      }
-    }
-    if (ipv6) {
-      dns.resolve6(domain, callback)
-    } else {
-      dns.resolve4(domain, callback)
-    }
-  })
+	return new Promise((resolve, reject) => {
+		const callback = function (err, addresses) {
+			if (addresses && addresses.length > 0) {
+				resolve(addresses[0]);
+			} else {
+				logger.trace('dns resolve error: ', err);
+				reject(err);
+			}
+		};
+		if (ipv6) {
+			dns.resolve6(domain, callback);
+		} else {
+			dns.resolve4(domain, callback);
+		}
+	});
 }
 
 export async function resolveDomain(domain, quiet = false) {
-  try {
-    // Set machine's dns server as defalut dns server
-    dns.setServers(["[fc03:1136:3800::1]"])
-    const [ipv6Addresses, ipv4Addresses] = await Promise.allSettled([
-      __resolveDomain(domain, true),
-      __resolveDomain(domain, false)
-    ])
-    if (ipv6Addresses.status == "fulfilled") {
-      return ipv6Addresses.value
-    } else if (ipv4Addresses.status == "fulfilled") {
-      return ipv4Addresses.value
-    } else {
-      throw ipv6Addresses.reason
-    }
-  } catch (error) {
-    if (!quiet) {
-      logger.error(`无法解析域名 ${domain}: `, error)
-    }
-    throw error
-  }
+	try {
+		// Set machine's dns server as defalut dns server
+		dns.setServers(['[fc03:1136:3800::1]']);
+		const [ipv6Addresses, ipv4Addresses] = await Promise.allSettled([__resolveDomain(domain, true), __resolveDomain(domain, false)]);
+		if (ipv6Addresses.status == 'fulfilled') {
+			return ipv6Addresses.value;
+		} else if (ipv4Addresses.status == 'fulfilled') {
+			return ipv4Addresses.value;
+		} else {
+			throw ipv6Addresses.reason;
+		}
+	} catch (error) {
+		if (!quiet) {
+			logger.error(t('lzc_cli.lib.utils.resolve_domain_fail_tips', `无法解析域名 {{ domain }}: `, { domain, interpolation: { escapeValue: false } }), error);
+		}
+		throw error;
+	}
 }
 
 export function unzipSync(zipPath, destPath, entries = []) {
-  if (!isFileExist(zipPath)) {
-    throw `${zipPath} 找不到该文件`
-  }
-
-  // 确保目标目录存在
-  fs.mkdirSync(destPath, { recursive: true })
-  // 创建 zip 实例
-  const zip = new AdmZip(zipPath)
-
-  if (entries.length > 0) {
-    entries.forEach((entry) => {
-      try {
-        zip.extractEntryTo(entry, destPath, false, true)
-      } catch {
-        logger.debug(`压缩包中没有找到 ${entry} 文件`)
-      }
-    })
-  } else {
-    // 同步解压所有文件
-    zip.extractAllTo(destPath, true)
-  }
+	if (!isFileExist(zipPath)) {
+		throw t('lzc_cli.lib.utils.unzip_sync_not_exist_fail', `{{ zipPath }} 找不到该文件`, { zipPath, interpolation: { escapeValue: false } });
+	}
+
+	// 确保目标目录存在
+	fs.mkdirSync(destPath, { recursive: true });
+	// 创建 zip 实例
+	const zip = new AdmZip(zipPath);
+
+	if (entries.length > 0) {
+		entries.forEach((entry) => {
+			try {
+				zip.extractEntryTo(entry, destPath, false, true);
+			} catch {
+				logger.debug(t('lzc_cli.lib.utils.unzip_sync_not_exist_file_log', `压缩包中没有找到 {{ entry }} 文件`, { entry, interpolation: { escapeValue: false } }));
+			}
+		});
+	} else {
+		// 同步解压所有文件
+		zip.extractAllTo(destPath, true);
+	}
 }
 
 export async function selectSshPublicKey(avaiableKeys) {
-  const keyNames = avaiableKeys.map((k) => k.path)
-  const selected = (
-    await inquirer.prompt([
-      {
-        name: "type",
-        message: "选择使用的公钥",
-        type: "list",
-        choices: keyNames
-      }
-    ])
-  )["type"]
-  return {
-    path: selected,
-    content: fs.readFileSync(selected, "utf8")
-  }
+	const keyNames = avaiableKeys.map((k) => k.path);
+	const selected = (
+		await inquirer.prompt([
+			{
+				name: 'type',
+				message: t('lzc_cli.lib.utils.select_ssh_public_key_prompt', '选择使用的公钥'),
+				type: 'list',
+				choices: keyNames,
+			},
+		])
+	)['type'];
+	return {
+		path: selected,
+		content: fs.readFileSync(selected, 'utf8'),
+	};
 }
 
 export function findSshPublicKey() {
-  // 获取用户 HOME 目录
-  let homeDir
-  switch (process.platform) {
-    case "win32":
-      // Windows: 通常是 C:\Users\username
-      homeDir = process.env.USERPROFILE || os.homedir()
-      break
-    case "darwin":
-    case "linux":
-      // macOS 和 Linux: 通常是 /Users/username 或 /home/username
-      homeDir = process.env.HOME || os.homedir()
-      break
-    default:
-      throw new Error("Unsupported operating system")
-  }
-
-  const sshDir = path.join(homeDir, ".ssh")
-
-  // 检查 .ssh 目录是否存在
-  try {
-    const dirStat = fs.statSync(sshDir)
-    if (!dirStat.isDirectory()) {
-      throw new Error(
-        ".ssh 目前存在，但不是一个正常的目录，请确保 ssh 已经安装，以及 ssh-keygen 生成公钥"
-      )
-    }
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      throw new Error(
-        ".ssh 目录不存在, 请确保 ssh 已经安装，以及 ssh-keygen 生成公钥"
-      )
-    }
-    throw error
-  }
-
-  let avaiableKeys = []
-  try {
-    // 获取 .ssh 目录下所有文件
-    const files = fs.readdirSync(sshDir)
-    files.forEach((keyName) => {
-      if (keyName.endsWith(".pub")) {
-        const keyPath = path.join(sshDir, keyName)
-        // 验证文件是否可读
-        try {
-          fs.accessSync(keyPath, fs.constants.R_OK)
-          avaiableKeys.push({
-            keyName,
-            path: keyPath
-          })
-        } catch (error) {
-          console.warn(`Found ${keyName} but cannot read it:`, error.message)
-        }
-      }
-    })
-
-    if (avaiableKeys.length == 0) {
-      throw new Error(
-        ".ssh 目录没有没有找到任何 .pub 公钥. 请使用 ssh-keygen 生成"
-      )
-    } else {
-      return avaiableKeys
-    }
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      throw new Error("不能查询 .ssh 目录")
-    }
-    throw error
-  }
+	// 获取用户 HOME 目录
+	let homeDir;
+	switch (process.platform) {
+		case 'win32':
+			// Windows: 通常是 C:\Users\username
+			homeDir = process.env.USERPROFILE || os.homedir();
+			break;
+		case 'darwin':
+		case 'linux':
+			// macOS 和 Linux: 通常是 /Users/username 或 /home/username
+			homeDir = process.env.HOME || os.homedir();
+			break;
+		default:
+			throw new Error('Unsupported operating system');
+	}
+
+	const sshDir = path.join(homeDir, '.ssh');
+
+	// 检查 .ssh 目录是否存在
+	try {
+		const dirStat = fs.statSync(sshDir);
+		if (!dirStat.isDirectory()) {
+			throw new Error(t('lzc_cli.lib.utils.find_ssh_public_key_not_is_dir_fail', '.ssh 目前存在，但不是一个正常的目录，请确保 ssh 已经安装，以及 ssh-keygen 生成公钥'));
+		}
+	} catch (error) {
+		if (error.code === 'ENOENT') {
+			throw new Error(t('lzc_cli.lib.utils.find_ssh_public_key_dir_not_exist_fail', '.ssh 目录不存在, 请确保 ssh 已经安装，以及 ssh-keygen 生成公钥'));
+		}
+		throw error;
+	}
+
+	let avaiableKeys = [];
+	try {
+		// 获取 .ssh 目录下所有文件
+		const files = fs.readdirSync(sshDir);
+		files.forEach((keyName) => {
+			if (keyName.endsWith('.pub')) {
+				const keyPath = path.join(sshDir, keyName);
+				// 验证文件是否可读
+				try {
+					fs.accessSync(keyPath, fs.constants.R_OK);
+					avaiableKeys.push({
+						keyName,
+						path: keyPath,
+					});
+				} catch (error) {
+					console.warn(`Found ${keyName} but cannot read it:`, error.message);
+				}
+			}
+		});
+
+		if (avaiableKeys.length == 0) {
+			throw new Error(t('lzc_cli.lib.utils.find_ssh_public_key_files_not_exits_fail', '.ssh 目录没有没有找到任何 .pub 公钥. 请使用 ssh-keygen 生成'));
+		} else {
+			return avaiableKeys;
+		}
+	} catch (error) {
+		if (error.code === 'ENOENT') {
+			throw new Error(t('lzc_cli.lib.utils.find_ssh_public_key_dir_info_get_fail', '不能查询 .ssh 目录'));
+		}
+		throw error;
+	}
 }
 
 export function checkRsync() {
-  return new Promise((resolve, reject) => {
-    if (isLinux || isMacOs) {
-      // 检查rsync工具是否存在:提示用户
-      const rsyncExisted = commandExists.sync("rsync")
-      if (!rsyncExisted) {
-        reject("请检查 rsync 是否安装，路径是否正确!")
-      }
-
-      const check = spawn.sync("rsync", ["--version"], {
-        shell: true,
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"]
-      })
-      logger.debug(`执行命令 rsync --version`)
-      if (check.status == 0) {
-        const versionMatch = check.stdout.match(
-          /rsync\s+version\s+(\d+\.\d+\.\d+)/i
-        )
-        if (!versionMatch || compareVersions("3.2.0", versionMatch[1]) < 0) {
-          reject(`当前rsync版本为:${versionMatch[1]}, 要求rsync版本为: 3.2.0+`)
-        }
-        logger.debug(`当前rsync版本为:${versionMatch[1]}`)
-      } else {
-        reject("请检查 rsync 安装是否正确，指定 rsync --version 错误")
-      }
-    }
-    resolve()
-  })
+	return new Promise((resolve, reject) => {
+		if (isLinux || isMacOs) {
+			// 检查rsync工具是否存在:提示用户
+			const rsyncExisted = commandExists.sync('rsync');
+			if (!rsyncExisted) {
+				reject(t('lzc_cli.lib.utils.check_rsync_not_install_fail', '请检查 rsync 是否安装，路径是否正确!'));
+			}
+
+			const check = spawn.sync('rsync', ['--version'], {
+				shell: true,
+				encoding: 'utf-8',
+				stdio: ['pipe', 'pipe', 'pipe'],
+			});
+			logger.debug(t('lzc_cli.lib.utils.check_rsync_exec_version_log', `执行命令 rsync --version`));
+			if (check.status == 0) {
+				const versionMatch = check.stdout.match(/rsync\s+version\s+(\d+\.\d+\.\d+)/i);
+				if (!versionMatch || compareVersions('3.2.0', versionMatch[1]) < 0) {
+					reject(
+						t('lzc_cli.lib.utils.check_rsync_version_no_match_fail', `当前 rsync 版本为:{{ versionMatch }}, 要求 rsync 版本为: 3.2.0+`, {
+							versionMatch: versionMatch[1],
+						}),
+					);
+				}
+				logger.debug(t('lzc_cli.lib.utils.check_rsync_version_print_log', `当前 rsync 版本为:{{ versionMatch }}`, { versionMatch: versionMatch[1] }));
+			} else {
+				reject(t('lzc_cli.lib.utils.check_rsync_version_fail', '请检查 rsync 安装是否正确，指定 rsync --version 错误'));
+			}
+		}
+		resolve();
+	});
 }
 
 export function getLanguageForLocale(locale) {
-  locale = locale.replace("_", "-")
-  try {
-    let l = new Intl.Locale(locale)
-    return l.language
-  } catch (error) {
-    return locale
-  }
+	locale = locale.replace('_', '-');
+	try {
+		let l = new Intl.Locale(locale);
+		return l.language;
+	} catch (error) {
+		return locale;
+	}
 }