@lazycatcloud/lzc-cli 1.1.12 → 1.2.0

package/lib/box/schemes/vm_box_system_debian.json

@@ -1,47 +0,0 @@
-{
-  "name": "home-cloud",
-  "uuid": "047dac31-b75b-46ed-aedb-a31fa46a6503",
-  "memory": 4096,
-  "kernel": "debian",
-  "uefi": true,
-  "path": "${HOME}/.cache/box-emulator",
-  "volume": {
-    "config": "/etc/home-cloud"
-  },
-  "disks": [
-    {
-      "id": "system",
-      "size": "8G",
-      "system": true,
-      "partitions": [
-        {
-          "fs_type": "vfat",
-          "size": "100M",
-          "mount_point": "/boot/ESP"
-        },
-        {
-          "fs_type": "ext4",
-          "size": "4G",
-          "mount_point": "/"
-        },
-        {
-          "fs_type": "ext4",
-          "size": "full",
-          "mount_point": "/mnt"
-        }
-      ]
-    },
-    {
-      "id": "data1",
-      "size": "64G",
-      "system": false,
-      "partitions": []
-    },
-    {
-      "id": "data2",
-      "size": "64G",
-      "rebuild": false,
-      "partitions": []
-    }
-  ]
-}

package/lib/docker/promise.js

@@ -1,91 +0,0 @@
-import Docker from "dockerode";
-
-var wrappedProto = Docker.prototype;
-
-function denodeify(func) {
-  return function (...args) {
-    return new Promise((resolve, reject) => {
-      let input = [...args, (err, val) => (err ? reject(err) : resolve(val))];
-      func.apply(this, input);
-    });
-  };
-}
-
-function proxyPromise(method) {
-  var promisey = denodeify(method);
-  return function () {
-    return promisey.apply(this.$subject, arguments);
-  };
-}
-
-function promiseObj(target, input) {
-  for (var key in input) {
-    if (typeof input[key] !== "function") continue;
-    target[key] = proxyPromise(input[key]);
-  }
-  return target;
-}
-
-function PromiseProxy(subject) {
-  var result = Object.create(subject);
-  result.$subject = subject;
-  return promiseObj(result, subject);
-}
-
-function ContainerProxy(subject) {
-  var result = PromiseProxy(subject);
-  var exec = result.exec;
-  result.exec = function () {
-    return exec.apply(this, arguments).then(function (exec) {
-      return PromiseProxy(exec);
-    });
-  };
-  return result;
-}
-
-function DockerProxy(options) {
-  this.$subject = new Docker(options);
-}
-
-promiseObj(DockerProxy.prototype, wrappedProto);
-
-// sadly we need to wrap run directly as a promise to consolidate both
-// of the resulting arguments.
-DockerProxy.prototype.run = function (image, command, stream) {
-  var subject = this.$subject;
-  return new Promise(function (accept, reject) {
-    subject.run(image, command, stream, function (err, result, container) {
-      if (err) return reject(err);
-      accept({
-        result: result,
-        // re-wrap
-        container: ContainerProxy(container),
-      });
-    });
-  });
-};
-
-// We also have wrap createContainer manually as it returns
-DockerProxy.prototype.createContainer = function (opts) {
-  var subject = this.$subject;
-  return new Promise(function (accept, reject) {
-    subject.createContainer(opts, function (err, container) {
-      if (err) return reject(err);
-      accept(ContainerProxy(container));
-    });
-  });
-};
-
-DockerProxy.prototype.getImage = function (id) {
-  return PromiseProxy(this.$subject.getImage(id));
-};
-
-DockerProxy.prototype.getContainer = function (id) {
-  return ContainerProxy(this.$subject.getContainer(id));
-};
-
-DockerProxy.prototype.getVolume = function (name) {
-  return PromiseProxy(this.$subject.getVolume(name));
-};
-
-export default DockerProxy;

package/lib/docker-compose.js

@@ -1,50 +0,0 @@
-import yaml from "js-yaml";
-import fs from "fs";
-import mergeWith from "lodash.mergewith";
-
-export function load(filePath) {
-  return yaml.load(fs.readFileSync(filePath, "utf8"));
-}
-
-// 用于合并多个 DockerCompose 文件
-export default class DockerCompose {
-  constructor(basefile) {
-    this.basefile = basefile;
-    this.obj = load(basefile);
-  }
-  // 直接修改 yaml 内容
-  pipe(cb) {
-    cb.apply(this, [this.obj]);
-    return this;
-  }
-
-  // mergeFile({file: ""}) or merge({content: ""})
-  merge(context) {
-    let newObj;
-    if (context.file) {
-      newObj = load(context.file);
-    }
-    if (context.content) {
-      newObj = yaml.load(context.content);
-    }
-
-    this.obj = mergeWith(this.obj, newObj, (objValue, srcValue) => {
-      if (Array.isArray(objValue)) {
-        return objValue.concat(srcValue);
-      }
-    });
-    return this;
-  }
-
-  // to: optional
-  save(to) {
-    fs.writeFileSync(
-      to || this.basefile,
-      yaml.dump(this.obj, {
-        styles: {
-          "!!null": "empty", // dump null as ""
-        },
-      })
-    );
-  }
-}

package/lib/git/git-commit.sh

@@ -1,7 +0,0 @@
-# executed under appdb
-
-# git fetch origin
-# git reset --hard
-#
-git add ${APP_ID}
-git commit -m "[lzc-cli publish] bump ${APP_ID} version to ${APP_VERSION}"

package/lib/git/git-reset.sh

@@ -1,15 +0,0 @@
-#!/bin/bash
-
-FOLDER="$APPDB_DIR"
-
-if [ ! -d "$FOLDER" ] ; then
-  git clone --depth 1 git@gitee.com:lazycatcloud/appdb.git $FOLDER
-fi
-#
-cd $FOLDER
-#
-git fetch && git reset --hard origin/v0.1
-#
-#
-
-

package/lib/key.js

@@ -1,102 +0,0 @@
-import inquirer from "inquirer";
-import glob from "fast-glob";
-import path from "path";
-import { Client } from "ssh2";
-import process from "process";
-import fs from "fs";
-import execa from "execa";
-import API from "./api.js";
-import { ensureDir } from "./utils.js";
-import os from "os";
-
-const KEY_NAME = "id_ed25519";
-const SSH_CONFIG_DIR = path.join(os.homedir(), ".ssh");
-
-export default class Key {
-  // 确保该秘钥可以工作
-  async ensure(host) {
-    const pairs = await this.getKeyPair();
-    await this.validationCheck(host, pairs);
-  }
-
-  async generate() {
-    const privateKeyFile = path.join(SSH_CONFIG_DIR, KEY_NAME);
-    ensureDir(privateKeyFile);
-    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"]),
-            },
-          ],
-          keepaliveInterval: 60000, // 60s
-        });
-    });
-  }
-
-  async getKeyPair() {
-    const privateKey = path.join(SSH_CONFIG_DIR, KEY_NAME);
-    const publicKey = path.join(SSH_CONFIG_DIR, `${KEY_NAME}.pub`);
-    if (fs.existsSync(privateKey) && fs.existsSync(publicKey)) {
-      return {
-        private: privateKey,
-        public: publicKey,
-      };
-    }
-    return await this.generate();
-  }
-}

package/lib/sdk.js

@@ -1,135 +0,0 @@
-import ssh from "docker-modem/lib/ssh.js";
-// import Docker from "./docker/promise.js";
-import Docker from "dockerode";
-import process from "process";
-import fs from "fs";
-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 {
-    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,
-      },
-    ],
-    keepaliveInterval: 60000, // 60s
-    debug: sshDebug(),
-  };
-}
-
-export class DockerClient {
-  constructor(host) {
-    this.host = host;
-  }
-
-  async init() {
-    this.docker = !!this.host
-      ? new Docker({
-          protocal: "ssh",
-          agent: ssh(await connectOptions(this.host)),
-        })
-      : new Docker();
-
-    const host = this.host;
-
-    async function onUncaughtException(e) {
-      if (e.code == "ECONNREFUSED") {
-        logger.error(`无法连接 sdk 服务, 请确保 ${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) => {
-          logger.error("ssh client ", 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);
-        });
-      }
-    );
-  }
-}