@lazycatcloud/lzc-cli 1.1.1 → 1.1.2

package/lib/env.js

@@ -1,46 +1,182 @@
 import path from "path";
 import fs from "fs";
-import os from "os";
-import { ensureDir, APP_CONFIG_FILE, GLOBAL_CONFIG_DIR } from "./utils.js";
+import {
+  ensureDir,
+  APP_CONFIG_FILE,
+  GLOBAL_CONFIG_DIR,
+  APP_FOLDER,
+  findAppIsInstalled,
+  checkSDKInstallStatus,
+  InstallSDK,
+} from "./utils.js";
+import { debuglog } from "util";
+import inquirer from "inquirer";
+import chalk from "chalk";
+import fetch from "node-fetch";
+const debug = debuglog("lib/env");
 
 const GLOBAL_CONFIG_NAME = "box-config.json";
+const permitGlobalEnv = [
+  {
+    name: "DEFAULT_BOXNAME",
+    type: "input",
+    message: "默认的懒猫云盒子名称",
+    validate: (input) => {
+      return input != "";
+    },
+  },
+];
 
-const permitVars = [
-  "APP_ID",
-  "APP_NAME",
-  "APP_IMAGE_NAME",
-  "BUILD_CONTEXT",
-  "HTTP_SERVICE_PORT",
-  "DEV_PORT",
-  "DEV_CMD",
-  "SDK_URL",
+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 permitGlobalVars = ["SDK_URL"];
+const permitLocalEnv = _permitLocalEnv.concat(permitGlobalEnv);
 
-class Env {
-  constructor(cwd) {
-    this.envPath = path.join(cwd, APP_CONFIG_FILE);
-    this.globalEnvPath = path.join(
-      GLOBAL_CONFIG_DIR,
-      GLOBAL_CONFIG_NAME
-    );
-    this.load();
+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 fetch(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();
+      case "AbortError":
+        console.log(chalk.red(`请求 ${url} 超时, 请确保懒猫云客户端已连接`));
+        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);
 
-  load() {
+class Env {
+  constructor(cwd) {
+    // 只加载
+    this.existance = {
+      global: false,
+      local: false,
+    };
     this.allEnv = {};
-    this.env = {};
-    this.globalEnv = {};
 
-    if (fs.existsSync(this.envPath)) {
-      this.env = JSON.parse(fs.readFileSync(this.envPath));
-    }
+    this._loadGlobalEnv();
+    this._updateAllEnv();
+  }
 
-    if (fs.existsSync(this.globalEnvPath)) {
-      this.globalEnv = JSON.parse(fs.readFileSync(this.globalEnvPath));
+  /**
+   * 加载应用环境变量.
+   * @param {string} cwd 当前路径
+   */
+  load(cwd) {
+    this.localEnvPath = path.join(cwd, APP_FOLDER, APP_CONFIG_FILE);
+    try {
+      this.localEnv = JSON.parse(fs.readFileSync(this.localEnvPath));
+      this.existance.local = true;
+    } catch (e) {
+      debug("local env fail to fetch %s", e.message);
+      this.localEnv = {};
     }
-    this.updateAllEnv();
+
+    this._updateAllEnv();
+  }
+
+  /**
+   * 确保字段存在, 如果不存在会要求用户输入
+   * @param pairs {array} 需要询问的环境变量, 同 inquirer.prompt 参数
+   * @param global {boolean} 是否设置为全局变量, 默认为 false
+   */
+  async ensure(pairs, global = false) {
+    let willAskPairs = [];
+
+    pairs.forEach((pair) => {
+      if (this.allEnv.hasOwnProperty(pair.name)) return;
+      let found = allPermits.find((p) => p.name == pair.name);
+      if (found) {
+        willAskPairs.push(Object.assign({}, found, pair));
+      }
+    });
+
+    const pair = await inquirer.prompt(willAskPairs);
+    let pairNames = pairs.map((a) => a.name);
+    this.set(pair, global);
+    return Object.fromEntries(
+      Object.entries(this.allEnv).filter(([name, _]) => {
+        return pairNames.includes(name);
+      })
+    );
+  }
+
+  stringify() {
+    let content = "";
+    Object.keys(this.all).forEach((key) => {
+      content += `${key}="${this.allEnv[key]}"\n`;
+    });
+    return content.trimEnd();
   }
 
   get isEnvExist() {
@@ -49,12 +185,20 @@ class Env {
 
   get all() {
     return Object.keys(this.allEnv).reduce((p, c) => {
-      if (permitVars.includes(c)) p[c] = this.allEnv[c];
+      if (allPermitEnv.includes(c)) p[c] = this.allEnv[c];
       return p;
     }, {});
   }
 
-  hasKey(key) {
+  get localEnvExist() {
+    return this.existance.local;
+  }
+
+  get globalEnvExist() {
+    return this.existance.global;
+  }
+
+  has(key) {
     return Object.keys(this.allEnv).indexOf(key) > -1;
   }
 
@@ -62,42 +206,117 @@ class Env {
     return this.allEnv[key];
   }
 
-  updateAllEnv() {
-    this.allEnv = Object.assign({}, this.globalEnv, this.env);
+  set(pairs, global = false) {
+    const configPath = global ? this.globalEnvPath : this.localEnvPath;
+    let envs = global ? this.globalEnv : this.localEnv;
+    ensureDir(configPath);
+
+    Object.assign(envs, pairs);
+    fs.writeFileSync(configPath, JSON.stringify(envs, null, "  "));
+    return this._updateAllEnv();
   }
 
-  setGlobal(pairs = {}) {
-    const configPath = this.globalEnvPath;
-    if (Object.keys(pairs).some((k) => permitGlobalVars.indexOf(k) < 0)) {
-      return;
+  _updateAllEnv() {
+    return (this.allEnv = Object.assign({}, this.globalEnv, this.localEnv));
+  }
+
+  _loadGlobalEnv() {
+    this.globalEnvPath = path.join(GLOBAL_CONFIG_DIR, GLOBAL_CONFIG_NAME);
+
+    try {
+      this.globalEnv = JSON.parse(fs.readFileSync(this.globalEnvPath));
+      this.existance.global = true;
+    } catch (e) {
+      debug("global env fail to fetch %s", e.message);
+      this.globalEnv = {};
     }
+  }
+}
 
-    ensureDir(configPath);
-    Object.assign(this.globalEnv, pairs);
-    fs.writeFileSync(configPath, JSON.stringify(this.globalEnv, null, "  "));
-    this.updateAllEnv();
+const env = new Env();
+
+// 用于处理 SDK_URL 这个特殊的环境变量
+// SDK_URL 根据默认的盒子名称生成，如果没有指定默认的盒子名称将会
+// 询问用户输入对应的盒子名称。
+class SDKEnv {
+  get sdkUrl() {
+    if (env.has("DEFAULT_BOXNAME")) {
+      return this.buildSdkUrl(env.get("DEFAULT_BOXNAME"));
+    }
+    return "";
+  }
+
+  async ensure() {
+    if (this.sdkUrl) {
+      try {
+        // 另一种是SDK尚未安装，不过会被catch捕获掉，并安装sdk
+        await this.checkConnection(this.sdkUrl);
+      } catch (e) {
+        // sdk未安装
+        await this.installSDK(this.sdkUrl);
+      }
+    } else {
+      await this.setDefaultBoxName();
+    }
   }
 
-  set(pairs = {}) {
-    if (Object.keys(pairs).some((k) => permitVars.indexOf(k) < 0)) {
-      return;
+  async setDefaultBoxName(boxname = "", ensureSDK = true) {
+    if (!boxname) {
+      boxname = await this._promptAnswers();
     }
+    let url = this.buildSdkUrl(boxname);
 
-    ensureDir(this.envPath);
-    Object.assign(this.env, pairs);
-    fs.writeFileSync(this.envPath, JSON.stringify(this.env, null, "  "));
-    this.updateAllEnv();
+    if (ensureSDK) {
+      await this.installSDK(url);
+    }
+
+    env.set({ DEFAULT_BOXNAME: boxname, SDK_URL: url }, true);
   }
 
-  stringify() {
-    let content = "";
-    Object.keys(this.all).forEach((key) => {
-      content += `${key}="${this.allEnv[key]}"\n`;
-    });
-    return content.trimEnd();
+  buildSdkUrl(boxname) {
+    return `https://sdk.${boxname}.heiyu.space`;
   }
-}
 
-export default function (cwd) {
-  return new Env(cwd);
+  async checkConnection(host) {
+    return await checkURL(host, "/api/v1/ping");
+  }
+
+  /**
+   * 确保sdk已安装
+   * @param need_answer {boolean} 是否需要询问用户地址
+   */
+  async installSDK(sdkURL) {
+    // 无法直接从环境变量拿到SDK_URL，就让用户输入
+    debug(sdkURL);
+
+    let boxURL = sdkURL.replace("sdk.", "");
+
+    try {
+      if (await findAppIsInstalled(boxURL, "sdk")) {
+        return;
+      }
+
+      console.log(chalk.yellow("检测到SDK尚未安装，开始安装SDK"));
+      await InstallSDK(boxURL);
+      console.log(chalk.green("SDK安装完成，开始部署SDK"));
+
+      await checkSDKInstallStatus(boxURL);
+    } catch (e) {
+      throw e;
+    }
+  }
+
+  /**
+   * 提示用户回答问题
+   *
+   */
+  async _promptAnswers() {
+    const answers = await inquirer.prompt(
+      permitGlobalEnv.filter((a) => a.name == "DEFAULT_BOXNAME")
+    );
+    return answers["DEFAULT_BOXNAME"];
+  }
 }
+
+export const sdkEnv = new SDKEnv();
+export default env;

package/lib/generator.js

@@ -9,6 +9,37 @@ import chalk from "chalk";
 const __dirname = contextDirname();
 
 export const TemplateConfig = {
+  ionic_vue3: {
+    template: "ionic_vue3",
+    defaultEnvs: {
+      HTTP_SERVICE_PORT: "8080",
+      BUILD_CONTEXT: ".lazycat/release",
+    },
+    after: async function (name) {
+      console.log(chalk.green("开始安装依赖"));
+
+      const subprocess = execa("npm", ["install"], {
+        cwd: path.join(process.cwd(), name),
+        stdio: "inherit",
+      });
+      await subprocess;
+      console.log(
+        chalk.green(
+          `
+✨ 懒猫云应用 ${name} 已创建:
+  ${chalk.yellow(`cd ${name}`)}
+  ${chalk.yellow(`npm run dev`)}
+将应用部署至设备中:
+  ${chalk.yellow(`lzc-cli deploy`)}
+生成android代码:
+  ${chalk.yellow(`npm run build_android`)}
+生成ios代码:
+  ${chalk.yellow(`npm run build_ios`)}
+   `.trim()
+        )
+      );
+    },
+  },
   vue: {
     template: "vue",
     defaultEnvs: {

package/lib/git/git-commit.sh

@@ -0,0 +1,7 @@
+# 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

@@ -0,0 +1,15 @@
+#!/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

@@ -6,9 +6,11 @@ import process from "process";
 import fs from "fs";
 import execa from "execa";
 import API from "./api.js";
-import { GLOBAL_CONFIG_DIR } from "./utils.js";
+import { ensureDir } from "./utils.js";
+import os from "os";
 
-const KEY_NAME = "lzc_box_key";
+const KEY_NAME = "id_ed25519";
+const SSH_CONFIG_DIR = path.join(os.homedir(), ".ssh");
 
 export default class Key {
   // 确保该秘钥可以工作
@@ -18,7 +20,8 @@ export default class Key {
   }
 
   async generate() {
-    const privateKeyFile = path.join(GLOBAL_CONFIG_DIR, KEY_NAME);
+    const privateKeyFile = path.join(SSH_CONFIG_DIR, KEY_NAME);
+    ensureDir(privateKeyFile);
     await execa(
       "ssh-keygen",
       ["-t", "ed25519", "-P", "", "-f", privateKeyFile],
@@ -85,14 +88,14 @@ export default class Key {
   }
 
   async getKeyPair() {
-    const results = await glob(path.join(GLOBAL_CONFIG_DIR, `/${KEY_NAME}*`));
-    if (results.length != 2) {
-      return await this.generate();
+    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 {
-      private: path.join(GLOBAL_CONFIG_DIR, KEY_NAME),
-      public: path.join(GLOBAL_CONFIG_DIR, `${KEY_NAME}.pub`),
-    };
+    return await this.generate();
   }
 }

package/lib/sdk.js

@@ -1,18 +1,13 @@
 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) {
+export async function connectOptions(host) {
   const pairs = await new Key().getKeyPair();
   return {
     host: host,
@@ -41,10 +36,12 @@ export class DockerClient {
   }
 
   async init() {
-    this.docker = new Docker({
-      protocal: "http",
-      agent: ssh(await connectOptions(this.host)),
-    });
+    this.docker = !!this.host
+      ? new Docker({
+          protocal: "http",
+          agent: ssh(await connectOptions(this.host)),
+        })
+      : new Docker();
 
     const host = this.host;