@lazycatcloud/lzc-cli 1.1.8 → 1.1.9

package/lib/env.js

@@ -6,14 +6,13 @@ import {
   GLOBAL_CONFIG_DIR,
   APP_FOLDER,
 } from "./utils.js";
-import { debuglog } from "util";
 import inquirer from "inquirer";
 import chalk from "chalk";
-import { request } from "./autologin.js";
-const debug = debuglog("lib/env");
+import logger from "loglevel";
+import fetch from "node-fetch";
 
 const GLOBAL_CONFIG_NAME = "box-config.json";
-const permitGlobalEnv = [
+const allPermitEnv = [
   {
     name: "DEFAULT_BOXNAME",
     type: "input",
@@ -24,91 +23,6 @@ const permitGlobalEnv = [
   },
 ];
 
-const _permitLocalEnv = [
-  {
-    name: "APP_ID",
-    type: "input",
-    message: "应用名称",
-  },
-  {
-    name: "APP_DESCRIPTION",
-    type: "input",
-    message: "应用描述",
-  },
-  {
-    name: "BUILD_CONTEXT",
-    message: "",
-    type: "input",
-  },
-  {
-    name: "DEV_CONTEXT",
-    message: "",
-    type: "input",
-  },
-  {
-    name: "APP_VERSION",
-    message: "应用版本号",
-    type: "input",
-  },
-  {
-    name: "HTTP_SERVICE_PORT",
-    message: "服务暴露端口",
-    type: "input",
-    validate: (input) => {
-      if (!/^[^0]\d+$/.test(input)) {
-        return "端口必须为数字";
-      }
-      return true;
-    },
-  },
-];
-
-const permitLocalEnv = _permitLocalEnv.concat(permitGlobalEnv);
-
-const allPermits = _permitLocalEnv.concat(permitGlobalEnv);
-
-const controller = new AbortController();
-
-/**
- * 检查URL是否能被ping通
- * @param url 要检查的URL
- * @param suffix 可选，与URL拼接的后缀
- **/
-async function checkURL(url, suffix = "") {
-  const timeout = setTimeout(() => {
-    controller.abort();
-  }, 5000);
-
-  try {
-    const resp = await request(url + suffix, { signal: controller.signal });
-    if (resp.status != 200) {
-      // 设备可以访问 (client 有正常连接), 但是sdk 这个服务无法访问
-      throw new Error(
-        chalk.red(
-          `无法连接 sdk 服务, 请确保 ${chalk.yellow(
-            new URL(url).origin
-          )} 可以访问或者在应用商店安装 sdk`
-        )
-      );
-    }
-  } catch (error) {
-    switch (error.name) {
-      case "FetchError":
-        console.log(chalk.red("盒子入口地址有误，请核对后再试"));
-        process.exit();
-      default:
-        throw error;
-    }
-  } finally {
-    clearTimeout(timeout);
-  }
-}
-
-const allPermitEnv = permitGlobalEnv
-  .concat(permitLocalEnv)
-  .map((e) => e.name)
-  .filter((value, index, self) => self.indexOf(value) == index);
-
 class Env {
   constructor(cwd) {
     // 只加载
@@ -132,7 +46,7 @@ class Env {
       this.localEnv = JSON.parse(fs.readFileSync(this.localEnvPath));
       this.existance.local = true;
     } catch (e) {
-      debug("local env fail to fetch %s", e.message);
+      logger.debug("local env fail to fetch ", e.message);
       this.localEnv = {};
     }
 
@@ -167,7 +81,7 @@ class Env {
 
   stringify() {
     let content = "";
-    Object.keys(this.all).forEach((key) => {
+    Object.keys(this.allEnv).forEach((key) => {
       content += `${key}="${this.allEnv[key]}"\n`;
     });
     return content.trimEnd();
@@ -221,7 +135,7 @@ class Env {
       this.globalEnv = JSON.parse(fs.readFileSync(this.globalEnvPath));
       this.existance.global = true;
     } catch (e) {
-      debug("global env fail to fetch %s", e.message);
+      logger.debug("global env fail to fetch ", e.message);
       this.globalEnv = {};
     }
   }
@@ -249,10 +163,18 @@ class SDKEnv {
 
   async ensure() {
     try {
-      const resp = await request(`${this.sdkUrl}/api/v1/ping`);
-      if (resp.status != 200) throw new Error(chalk.red("debug.bridge服务未正常运行"));
+      const resp = await fetch(`${this.sdkUrl}/api/v1/ping`);
+      if (resp.status != 200)
+        throw new Error(chalk.red("debug.bridge服务未正常运行"));
     } catch (e) {
-      console.log(chalk.yellow("检测到SDK尚未安装，请将盒子开启开发者模式"));
+      logger.error(e);
+      console.log(
+        chalk.yellow(
+          `检测到SDK尚未安装，请将盒子"${env.get(
+            "DEFAULT_BOXNAME"
+          )}"开启开发者模式`
+        )
+      );
       process.exit(-1);
     }
   }
@@ -266,11 +188,7 @@ class SDKEnv {
   }
 
   buildSdkUrl(boxname) {
-    return `https://sdk.${boxname}.heiyu.space`;
-  }
-
-  async checkConnection(host) {
-    return await checkURL(host, "/api/v1/ping");
+    return `http://sdk.${boxname}.heiyu.space`;
   }
 
   /**
@@ -279,7 +197,7 @@ class SDKEnv {
    */
   async _promptAnswers() {
     const answers = await inquirer.prompt(
-      permitGlobalEnv.filter((a) => a.name == "DEFAULT_BOXNAME")
+      allPermitEnv.filter((a) => a.name == "DEFAULT_BOXNAME")
     );
     return answers["DEFAULT_BOXNAME"];
   }

package/lib/key.js

@@ -83,6 +83,7 @@ export default class Key {
               key: fs.readFileSync(pair["private"]),
             },
           ],
+          keepaliveInterval: 5000,
         });
     });
   }

package/lib/sdk.js

@@ -7,6 +7,14 @@ import { Client } from "ssh2";
 import Key from "./key.js";
 import logger from "loglevel";
 
+const sshDebug = function () {
+  if (process.env["SSH2_DEBUG"]) {
+    return logger.debug;
+  } else {
+    return function () {};
+  }
+};
+
 export async function connectOptions(host) {
   const pairs = await new Key().getKeyPair();
   return {
@@ -27,6 +35,8 @@ export async function connectOptions(host) {
         agent: process.env.SSH_AUTH_SOCK,
       },
     ],
+    keepaliveInterval: 5000, // 5s
+    debug: sshDebug(),
   };
 }
 
@@ -123,28 +133,3 @@ export class SSHClient {
     );
   }
 }
-
-export async function dockerPullLzcAppsImage(host) {
-  logger.warn("* 更新lzcapp镜像, 未来可能会移除此操作");
-  const opts = await connectOptions(host);
-  const client = new SSHClient(opts);
-  await client.connect();
-  try {
-    const stream = await client.exec(
-      "docker pull registry.lazycat.cloud/lzc/lzcapp:0.1"
-    );
-
-    return new Promise((resolve, reject) => {
-      stream.stdout.pipe(process.stdout);
-      stream.stderr.pipe(process.stdout);
-      stream.on("close", () => {
-        client.close();
-        resolve();
-      });
-      stream.on("error", (e) => reject(e));
-    });
-  } catch (e) {
-    client.close();
-    throw e;
-  }
-}

package/lib/utils.js

@@ -1,26 +1,23 @@
 import path from "path";
 import fs from "fs";
-import { mkdtemp } from "fs/promises";
 import os from "os";
-import chalk from "chalk";
-import archiver from "archiver";
 import glob from "fast-glob";
 import yaml from "js-yaml";
 import mergeWith from "lodash.mergewith";
-import isArray from "lodash.isarray";
-import { request } from "./autologin.js";
 import { dirname } from "path";
 import { fileURLToPath } from "url";
 import ignore from "ignore";
-import ora from "ora";
-import { desireStatusTimer } from "../lib/api.js";
-import { warn } from "console";
-import { createHash } from "node:crypto";
-
-const META_MARK = "x-lazycat-app";
-const APP_FOLDER = ".lazycat";
-const APP_CONFIG_FILE = "app-config";
-const APP_SDK_HOSTNAME = "box";
+import { createHash, randomBytes } 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";
+
+export const APP_FOLDER = ".lazycat";
+export const APP_CONFIG_FILE = "app-config";
+export const APP_SDK_HOSTNAME = "box";
 export const GLOBAL_CONFIG_DIR = path.join(os.homedir(), "/.config/lazycat");
 
 export const envsubstr = async (templateContents, args) => {
@@ -33,7 +30,7 @@ export const envsubstr = async (templateContents, args) => {
  * @param filePath {string} 如果为文件路径 确保其文件夹存在; 如果为文件夹, 则确保该文件夹存在
  *
  */
-function ensureDir(filePath) {
+export function ensureDir(filePath) {
   let dirPath;
   if (filePath.endsWith("/")) {
     dirPath = filePath;
@@ -45,11 +42,11 @@ function ensureDir(filePath) {
   }
 }
 
-function loadFromYaml(file) {
+export function loadFromYaml(file) {
   return yaml.load(fs.readFileSync(file, "utf8"));
 }
 
-function dumpToYaml(template, target) {
+export function dumpToYaml(template, target) {
   fs.writeFileSync(
     target,
     yaml.dump(template, {
@@ -60,42 +57,10 @@ function dumpToYaml(template, target) {
   );
 }
 
-function isValidApp(appDir) {
-  function doCheck(next = true) {
-    const files = ["docker-compose.yml", "docker-compose.yml.in"];
-    for (let f of files) {
-      const composeFile = path.join(appDir, f);
-      if (fs.existsSync(composeFile)) {
-        const doc = yaml.load(fs.readFileSync(composeFile, "utf8"));
-        if (doc[META_MARK]) {
-          return { appDir, isTemplate: f == "docker-compose.yml.in" };
-        }
-      }
-    }
-    if (next) {
-      appDir = path.join(appDir, APP_FOLDER);
-      return doCheck(false);
-    }
-    return { appDir: false, isTemplate: false };
-  }
-  return doCheck();
-}
-
-// find any valid app path till root folder
-function findAppRootPath(aPath) {
-  const sep = "/";
-  const folders = aPath.split(sep);
-  for (let i = folders.length; i >= 0; i--) {
-    if (folders[i] == APP_FOLDER) {
-      return folders.slice(0, i + 1).join(sep);
-    }
-  }
-  return false;
-}
-
-function toPair(object) {
+export function toPair(object) {
   return Object.keys(object).map((key) => {
     let value = object[key] ? object[key].toString() : "";
+    key = key.replaceAll("-", "_");
     return {
       name: key,
       value,
@@ -103,12 +68,7 @@ function toPair(object) {
   });
 }
 
-function getMetaInfo(composeFile) {
-  const doc = yaml.load(fs.readFileSync(composeFile, "utf8"));
-  return doc[META_MARK];
-}
-
-async function envTemplateFile(templateFile, env) {
+export async function envTemplateFile(templateFile, env) {
   const template = yaml.load(fs.readFileSync(templateFile, "utf8"));
   const options = {
     envs: toPair(env),
@@ -125,12 +85,12 @@ async function envTemplateFile(templateFile, env) {
   );
 }
 
-async function createTemplateFile(templateFile, outputFile, env) {
+export async function createTemplateFile(templateFile, outputFile, env) {
   let output = await envTemplateFile(templateFile, env);
   fs.writeFileSync(outputFile, output);
 }
 
-async function createTemplateFileCommon(templateFile, outputFile, env) {
+export async function createTemplateFileCommon(templateFile, outputFile, env) {
   const template = yaml.load(fs.readFileSync(templateFile, "utf8"));
   const options = {
     envs: toPair(env),
@@ -143,8 +103,17 @@ async function createTemplateFileCommon(templateFile, outputFile, env) {
   fs.writeFileSync(outputFile, output);
 }
 
+export async function envsubstrDefault(templateContents, env) {
+  const options = {
+    envs: toPair(env),
+    syntax: "default",
+    protect: false,
+  };
+  return envsubstr(templateContents, { options });
+}
+
 // this will copy current app to a tmp dir
-async function copyDotAppDir(from, to, opts = {}) {
+export async function copyDotAppDir(from, to, opts = {}) {
   const {
     include = [],
     ignore = ["app-config", "output", "box-config.json"],
@@ -181,7 +150,7 @@ async function copyDotAppDir(from, to, opts = {}) {
   }
 }
 
-function mergeYamlInMemory(args) {
+export function mergeYamlInMemory(args) {
   if (args.length == 0) {
     return {};
   } else if (args.length == 1) {
@@ -189,7 +158,7 @@ function mergeYamlInMemory(args) {
   }
   return args.reduce((prev, curr) => {
     let result = mergeWith(prev, curr, (objValue, srcValue) => {
-      if (isArray(objValue)) {
+      if (Array.isArray(objValue)) {
         return objValue.concat(srcValue);
       }
     });
@@ -198,14 +167,14 @@ function mergeYamlInMemory(args) {
 }
 
 // override yaml, notice this will change target file
-function mergeYaml(target, source) {
+export function mergeYaml(target, source) {
   const targetContent = yaml.load(fs.readFileSync(target, "utf8"));
   const sourceContent = yaml.load(fs.readFileSync(source, "utf8"));
   const merged = mergeWith(
     targetContent,
     sourceContent,
     (objValue, srcValue) => {
-      if (isArray(objValue)) {
+      if (Array.isArray(objValue)) {
         return objValue.concat(srcValue);
       }
     }
@@ -213,44 +182,16 @@ function mergeYaml(target, source) {
   dumpToYaml(merged, target);
 }
 
-function archiveFolder(appDir, format = "zip") {
-  return new Promise(async (resolve, reject) => {
-    if (!fs.existsSync(appDir)) {
-      reject(new Error("folder does not exist"));
-      return;
-    }
-
-    const tempDir = await mkdtemp(path.join(os.tmpdir(), "hc-"));
-    const out = path.join(tempDir, "app." + format);
-
-    // console.log(chalk.green("start archive app ..."));
-    const output = fs.createWriteStream(out);
-    const archive = archiver(format);
-
-    archive.on("error", (e) => {
-      reject(e);
-      // console.log(e);
-    });
-    archive.on("end", () => {
-      resolve(output);
-    });
-    archive.pipe(output);
-
-    archive.directory(appDir, false);
-    archive.finalize();
-  });
-}
-
-function contextDirname(url = import.meta.url) {
+export function contextDirname(url = import.meta.url) {
   return dirname(fileURLToPath(url));
 }
 
-async function importDefault(pkgPath) {
+export async function importDefault(pkgPath) {
   let mod = await import(pkgPath);
   return mod.default;
 }
 
-class GitIgnore {
+export class GitIgnore {
   constructor(root) {
     this.root = root;
     this.ignores = [];
@@ -288,12 +229,12 @@ class GitIgnore {
   }
 }
 
-function isDirSync(path) {
+export function isDirSync(path) {
   let stat = fs.statSync(path);
   return stat.isDirectory();
 }
 
-function isDirExist(path) {
+export function isDirExist(path) {
   try {
     return isDirSync(path);
   } catch {
@@ -301,7 +242,7 @@ function isDirExist(path) {
   }
 }
 
-function isFileExist(path) {
+export function isFileExist(path) {
   try {
     fs.accessSync(
       path,
@@ -313,56 +254,139 @@ function isFileExist(path) {
   }
 }
 
-function urlHostname(url) {
+export function urlHostname(url) {
   let u = new URL(url);
   return u.hostname;
 }
 
 // REVIEW: 用户输入的app-id 空格替换为减号并且转换为全小写。
 // 这会影响默认的app-name，因为app-name的默认值依赖app-id，但是如果特定输入了app-name则正常
-function parse2CorrectName(name) {
+export function parse2CorrectName(name) {
   return name.replaceAll(" ", "-").toLowerCase();
 }
 
-async function sleep(ms) {
+export async function sleep(ms) {
   return new Promise((resolve) => {
     setTimeout(resolve, ms);
   });
 }
 
-async function md5String(str) {
+export async function md5String(str) {
   const hash = createHash("md5");
   hash.update(str);
   return hash.digest("hex");
 }
 
-export {
-  ensureDir,
-  copyDotAppDir,
-  isValidApp,
-  getMetaInfo,
-  findAppRootPath,
-  archiveFolder,
-  mergeYaml,
-  mergeYamlInMemory,
-  loadFromYaml,
-  dumpToYaml,
-  importDefault,
-  APP_FOLDER,
-  APP_CONFIG_FILE,
-  APP_SDK_HOSTNAME,
-  META_MARK,
-  toPair,
-  contextDirname,
-  isDirSync,
-  isDirExist,
-  GitIgnore,
-  isFileExist,
-  urlHostname,
-  envTemplateFile,
-  createTemplateFile,
-  parse2CorrectName,
-  sleep,
-  md5String,
-  createTemplateFileCommon
-};
+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"));
+      }
+    });
+  });
+}
+
+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();
+    });
+  }
+}
+
+export function randomString(length = 4) {
+  return randomBytes(length).toString("hex");
+}
+
+export class FileLocker {
+  constructor(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);
+
+    try {
+      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+");
+      } else {
+        throw e;
+      }
+    }
+  }
+  unlock() {
+    if (this.fd) {
+      fs.closeSync(this.fd);
+      fs.rmSync(this.filename);
+      this.fd = undefined;
+      this.filename = undefined;
+    }
+  }
+  withOpen(filename) {
+    const p = spawnSync("lsof", ["-w", "-t", filename]);
+    if (p.status === 0) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+}