@lazycatcloud/lzc-cli 1.1.0

package/lib/key.js

@@ -0,0 +1,112 @@
+import inquirer from "inquirer";
+import glob from "fast-glob";
+import path from "path";
+import os from "os";
+import { Client } from "ssh2";
+import process from "process";
+import fs from "fs";
+import execa from "execa";
+import API from "./api.js";
+
+const KEY_NAME = "lzc_box_key";
+
+export default class Key {
+  // 确保该秘钥可以工作
+  async ensure(host) {
+    const pairs = await this.getKeyPair();
+    await this.validationCheck(host, pairs);
+  }
+
+  async generate() {
+    const privateKeyFile = path.join(os.homedir(), "/.ssh/", KEY_NAME);
+    await execa(
+      "ssh-keygen",
+      ["-t", "ed25519", "-P", "", "-f", privateKeyFile],
+      {
+        stdio: "inherit",
+      }
+    );
+    return {
+      private: privateKeyFile,
+      public: privateKeyFile + ".pub",
+    };
+  }
+
+  async validationCheck(host, pair) {
+    const hostname = new URL(host).hostname;
+    const client = new Client();
+    return new Promise((resolve, reject) => {
+      client
+        .on("ready", () => {
+          resolve(true);
+          client.end();
+        })
+        .on("error", (err) => {
+          if (err.level == "client-authentication") {
+            inquirer
+              .prompt([
+                {
+                  name: "key",
+                  type: "confirm",
+                  message: "发布应用需要上传公钥, 确定上传?",
+                },
+              ])
+              .then(({ key }) => {
+                if (key) {
+                  const api = new API("", host);
+                  api
+                    .postPublicKey(fs.readFileSync(pair["public"]))
+                    .then(() => {
+                      resolve(true);
+                    });
+                } else {
+                  process.exit(1);
+                }
+              });
+          } else {
+            reject(err);
+          }
+        })
+        .connect({
+          host: hostname,
+          port: 2222,
+          username: "box",
+          retry: 3,
+          wait: 500,
+          authHandler: [
+            {
+              type: "publickey",
+              username: "box",
+              key: fs.readFileSync(pair["private"]),
+            },
+          ],
+        });
+    });
+  }
+
+  async getKeyPair() {
+    const results = await glob(path.join(os.homedir(), `/.ssh/${KEY_NAME}*`));
+    if (results.length != 2) {
+      // create key pair
+      const answers = await inquirer.prompt([
+        {
+          name: "generate",
+          message: "未发现ssh秘钥, 是否生成?",
+          type: "confirm",
+          default: true,
+        },
+      ]);
+
+      if (answers.generate) {
+        return await this.generate();
+      } else {
+        process.exit(1);
+      }
+    }
+
+    return {
+      private: path.join(os.homedir(), "/.ssh/", KEY_NAME),
+      public: path.join(os.homedir(), `/.ssh/${KEY_NAME}.pub`),
+    };
+  }
+}

package/lib/sdk.js

@@ -0,0 +1,129 @@
+import ssh from "docker-modem/lib/ssh.js";
+// import Docker from "./docker/promise.js";
+import Docker from "dockerode";
+import path from "path";
+import os from "os";
+import process from "process";
+import fs from "fs";
+import { Client } from "ssh2";
+import chalk from "chalk";
+import glob from "fast-glob";
+import execa from "execa";
+import API from "./api.js";
+import Key from "./key.js";
+
+async function connectOptions(host) {
+  const pairs = await new Key().getKeyPair();
+  return {
+    host: host,
+    port: 2222,
+    username: "box",
+    retry: 3,
+    wait: 500,
+    authHandler: [
+      {
+        type: "publickey",
+        username: "box",
+        key: fs.readFileSync(pairs["private"]),
+      },
+      {
+        type: "agent",
+        username: "box",
+        agent: process.env.SSH_AUTH_SOCK,
+      },
+    ],
+  };
+}
+
+export class DockerClient {
+  constructor(host) {
+    this.host = host;
+  }
+
+  async init() {
+    this.docker = new Docker({
+      protocal: "http",
+      agent: ssh(await connectOptions(this.host)),
+    });
+
+    const host = this.host;
+
+    async function onUncaughtException(e) {
+      if (e.code == "ECONNREFUSED") {
+        console.log(
+          chalk.red(`无法连接 sdk 服务, 请确保 ${chalk.yellow(host)} 可以访问`)
+        );
+        process.exit(1);
+      } else {
+        throw e;
+      }
+    }
+    process.on("uncaughtException", onUncaughtException);
+    await this.docker.ping();
+    process.off("uncaughtException", onUncaughtException);
+    return this.docker;
+  }
+}
+
+export class SSHClient {
+  // arg can be a simple host name or a ssh connectOptions
+  constructor(arg) {
+    if (typeof arg == "string") {
+      this.opts = connectOptions(arg);
+    } else {
+      this.opts = arg;
+    }
+    this.con = new Client();
+  }
+
+  connect() {
+    return new Promise((resolve, reject) => {
+      this.con
+        .on("ready", () => resolve(this.con))
+        .on("error", (err) => {
+          reject(err);
+        })
+        .on("close", () => resolve(null))
+        .connect(this.opts);
+    });
+  }
+
+  close() {
+    this.con.end();
+  }
+
+  exec(command, options = {}) {
+    return new Promise((resolve, reject) => {
+      this.con.exec(command, options, (err, chan) => {
+        if (err) return reject(err);
+        resolve(chan);
+      });
+    });
+  }
+
+  async shell() {
+    this.con.shell(
+      {
+        term: process.env.TERM,
+        rows: process.stdout.rows,
+        cols: process.stdout.columns,
+      },
+      (err, stream) => {
+        if (err) throw err;
+
+        stream.on("close", () => {
+          process.exit();
+        });
+        process.stdin.setRawMode(true);
+        process.stdin.pipe(stream);
+
+        // Connect remote output to local stdout
+        stream.pipe(process.stdout);
+        process.stdout.on("resize", () => {
+          // Let the remote end know when the local terminal has been resized
+          stream.setWindow(process.stdout.rows, process.stdout.columns, 0, 0);
+        });
+      }
+    );
+  }
+}

package/lib/utils.js

@@ -0,0 +1,349 @@
+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 envsub from "envsub";
+import yaml from "js-yaml";
+import mergeWith from "lodash.mergewith";
+import isArray from "lodash.isarray";
+import fetch from "node-fetch";
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+import ignore from "ignore";
+
+const controller = new AbortController();
+const META_MARK = "x-lazycat-app";
+const APP_FOLDER = ".lazycat";
+const APP_CONFIG_FILE = "app-config";
+const APP_SDK_HOSTNAME = "box";
+
+export const envsubstr = async (templateContents, args) => {
+  const parse = await importDefault("envsub/js/envsub-parser.js");
+  return parse(templateContents, args);
+};
+
+// commander passes the Command object itself as options,
+// extract only actual options into a fresh object.
+async function checkURL(url) {
+  const timeout = setTimeout(() => {
+    controller.abort();
+  }, 5000);
+
+  try {
+    const resp = await fetch(url, { signal: controller.signal });
+    if (resp.status != 200) {
+      throw new Error(chalk.red(
+        `无法连接 sdk 服务, 请确保 ${chalk.yellow(
+          new URL(url).origin
+        )} 可以访问或者在应用商店安装 sdk`
+      ));
+    }
+  } catch (error) {
+    throw error;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+function ensureDir(filePath) {
+  const dirPath = path.dirname(filePath);
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+function loadFromYaml(file) {
+  return yaml.load(fs.readFileSync(file, "utf8"));
+}
+
+function dumpToYaml(template, target) {
+  fs.writeFileSync(
+    target,
+    yaml.dump(template, {
+      styles: {
+        "!!null": "empty", // dump null as ""
+      },
+    })
+  );
+}
+
+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) {
+  return Object.keys(object).map((key) => {
+    return {
+      name: key,
+      value: object[key].toString(),
+    };
+  });
+}
+
+function getMetaInfo(composeFile) {
+  const doc = yaml.load(fs.readFileSync(composeFile, "utf8"));
+  return doc[META_MARK];
+}
+
+async function convertTemplateFile(templateFile, outputFile, env) {
+  const template = yaml.load(fs.readFileSync(templateFile, "utf8"));
+  //   const meta = template[META_MARK];
+  //   if (
+  //     meta &&
+  //     Array.isArray(meta["permissions"]) &&
+  //     meta["permissions"].includes("lzcapis")
+  //   ) {
+  //     template[META_MARK]["ingress"].push({
+  //       service: "lazycat-apis-sidecar",
+  //       port: 8888,
+  //       subdomain: "${APP_NAME}",
+  //       path: "/lzcapis/",
+  //       auth: "oidc",
+  //       authcallback: "/lzcapis/oidc-callback",
+  //     });
+  //     template["services"]["lazycat-apis-sidecar"] = {
+  //       image: "registry.linakesi.com/lazycat-apis-sidecar",
+  //       // volumes_from: ["${APP_NAME}:rw"],
+  //       volumes: ["lzcapis-lzcapp:/lzcapp"],
+  //       command: [
+  //         "--client-id=${LAZYCAT_AUTH_OIDC_CLIENT_ID}",
+  //         "--client-secret=${LAZYCAT_AUTH_OIDC_CLIENT_SECRET}",
+  //         "--client-url=https://${LAZYCAT_APP_ORIGIN}/lzcapis/",
+  //         "--issuer=${LAZYCAT_AUTH_OIDC_ISSUER_URL}",
+  //         "--prefix=lzcapis",
+  //         "--fs-root=/lzcapp/documents",
+  //       ],
+  //     };
+  //   }
+  //
+  const options = {
+    envs: toPair(env),
+    syntax: "default",
+    protect: false,
+  };
+  const output = await envsubstr(
+    yaml.dump(template, {
+      styles: {
+        "!!null": "empty", // dump null as ""
+      },
+    }),
+    { options }
+  );
+
+  fs.writeFileSync(outputFile, output);
+}
+
+// this will copy current app to a tmp dir
+async function copyDotAppDir(from, to, opts = {}) {
+  const {
+    include = [],
+    ignore = ["app-config", "output", "box-config.json"],
+    env = {},
+  } = opts;
+  try {
+    if (fs.existsSync(to)) {
+      fs.rmSync(to, { recursive: true });
+    }
+    const _files = await glob(["*"].concat(include), {
+      cwd: from,
+      dot: true,
+      ignore: ignore,
+    });
+    for (let f of _files) {
+      let needConvert = false;
+      let templateFile = path.join(from, f);
+      let outputFile = path.join(to, f);
+      if (f.endsWith(".in")) {
+        outputFile = outputFile.replace(/.in$/, "");
+        needConvert = true;
+      }
+      ensureDir(outputFile);
+      if (needConvert) {
+        await convertTemplateFile(templateFile, outputFile, env);
+      } else {
+        fs.copyFileSync(templateFile, outputFile);
+      }
+    }
+    return to;
+  } catch (e) {
+    console.log(e);
+    return "";
+  }
+}
+
+// override yaml, notice this will change target file
+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)) {
+        return objValue.concat(srcValue);
+      }
+    }
+  );
+
+  fs.writeFileSync(
+    target,
+    yaml.dump(merged, {
+      styles: {
+        "!!null": "empty", // dump null as ""
+      },
+    })
+  );
+}
+
+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() {
+  return dirname(fileURLToPath(import.meta.url));
+}
+
+async function importDefault(pkgPath) {
+  let mod = await import(pkgPath);
+  return mod.default;
+}
+
+class GitIgnore {
+  constructor() {
+    this.ig = ignore({ allowRelativePaths: true });
+  }
+
+  // 扫面一个指定的文件夹, 将.gitignore中的规则添加到this.gitignore
+  scan(dir) {
+    try {
+      let data = fs.readFileSync(path.join(dir, ".gitignore"), "utf8");
+      this.ig.add(data.split("\n"));
+    } catch {
+      // if not exist .gitignore
+    }
+  }
+
+  contain(filepath) {
+    return this.ig.ignores(filepath);
+  }
+
+  // node.js fs.readdir的封装，会自动扫描.gitignore并过滤
+  async readdir(dir, callback) {
+    await this.scan(dir);
+
+    if (this.ig.ignores(dir)) {
+      return callback("", []);
+    }
+
+    return fs.readdir(dir, { withFileTypes: true }, (err, files) => {
+      if (err) {
+        return callback(err, []);
+      }
+
+      let validFiles = files.filter((f) => !this.ig.ignores(f.name));
+      return callback(err, validFiles);
+    });
+  }
+}
+
+function isDirSync(path) {
+  let stat = fs.statSync(path);
+  return stat.isDirectory();
+}
+
+function isFileExist(path) {
+  try {
+    fs.accessSync(
+      path,
+      fs.constants.W_OK | fs.constants.R_OK | fs.constants.F_OK
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function urlHostname(url) {
+  let u = new URL(url);
+  return u.hostname;
+}
+
+export {
+  ensureDir,
+  copyDotAppDir,
+  isValidApp,
+  getMetaInfo,
+  findAppRootPath,
+  archiveFolder,
+  mergeYaml,
+  checkURL,
+  loadFromYaml,
+  dumpToYaml,
+  importDefault,
+  APP_FOLDER,
+  APP_CONFIG_FILE,
+  APP_SDK_HOSTNAME,
+  META_MARK,
+  toPair,
+  contextDirname,
+  isDirSync,
+  GitIgnore,
+  isFileExist,
+  urlHostname,
+};

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@lazycatcloud/lzc-cli",
+  "version": "1.1.0",
+  "description": "lazycat cloud developer kit",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "files": [
+    "template",
+    "scripts",
+    "lib"
+  ],
+  "bin": {
+    "lzc-cli": "./scripts/cli.js"
+  },
+  "type": "module",
+  "keywords": [
+    "lazycat cloud sdk"
+  ],
+  "author": "zac zeng",
+  "license": "ISC",
+  "dependencies": {
+    "@balena/dockerignore": "^1.0.2",
+    "archiver": "^5.3.0",
+    "chalk": "^4.1.2",
+    "commander": "^8.3.0",
+    "dockerfile-ast": "^0.4.1",
+    "dockerode": "^3.3.1",
+    "ejs": "^3.1.6",
+    "envsub": "^4.0.7",
+    "execa": "^5.1.1",
+    "fast-glob": "^3.2.7",
+    "form-data": "^4.0.0",
+    "ignore": "^5.2.0",
+    "inquirer": "^8.2.0",
+    "isbinaryfile": "^4.0.8",
+    "js-yaml": "^4.1.0",
+    "lodash.get": "^4.4.2",
+    "lodash.isarray": "^4.0.0",
+    "lodash.merge": "^4.6.2",
+    "lodash.mergewith": "^4.6.2",
+    "log-update": "^5.0.0",
+    "minimist": "^1.2.5",
+    "node-fetch": "^2.6.6",
+    "ora": "^6.0.1",
+    "semver": "^7.3.5",
+    "ssh2": "^1.5.0",
+    "ssh2-promise": "^1.0.2"
+  },
+  "devDependencies": {
+    "prettier": "^2.5.0"
+  }
+}