@lazycatcloud/lzc-cli 1.1.7 → 1.1.9

package/README.md

@@ -1,21 +1,79 @@
-## 开始使用
+# 懒猫云应用命令行工具
+```
+<command> [options]
+
+Commands:
+  lzc-cli box       盒子管理  lzc-cli app       应用管理  lzc-cli project   项目管理  lzc-cli appstore  应用商店
+Options:
+  -h, --help                                          [boolean] [default: false]
+      --version  Show version number                                   [boolean]
+      --log      log level 'trace', 'debug', 'info', 'warn', 'error'
+                                                      [string] [default: "info"]
+```
+
+## 安装
+```
+npm install -g @lazycatcloud/lzc-cli
+```
+
+## 虚拟盒子
+
+### 创建虚拟盒子
+```
+lzc-cli box create
+```
+将从 https://dl.lazycat.cloud 中下载最新的盒子系统数据，跟创建对应的 qemu 虚拟盒子。
+
+### 启动盒子
+```
+lzc-cli box start <boxname>
+# lzc-cli box start mydemobox
+```
+启动盒子成功后，就可以在 https://<mydemobox>.heiyu.space 中看到盒子的主页了。
+
+### 切换默认的盒子
+```
+lzc-cli box switch <otherBoxName>
+```
+
+### 查看本地的虚拟盒子信息
+```
+lzc-cli box info
+```
 
-### 命令行工具使用方法
+## 应用管理
 
-#### 创建项目
+### 安装应用到盒子中去
 
-```bash
-lzc-cli create a_project
+- 从 https://repo.lazycat.cloud 中安装
+```
+lzc-cli app install https://repo.lazycat.cloud/pkgs/cloud.lazycat.app.kityminder/cloud.lazycat.app.kityminder-v1.0.3.lpk
 ```
 
-#### 在本地打包镜像, 如果本地没有发布应用相关文件，会先执行 `init` 命令
+- 从本地安装
+```
+lzc-cli app install ./kityminder.lpk
+```
 
-```bash
-lzc-cli build
+### 卸载应用
+```
+lzc-cli app uninstall cloud.lazycat.app.kityminder
 ```
 
-#### 发布 app 至 app p 至 appdb
+## 项目管理
 
-```bash
-lzc-cli publish
+### 初始化懒猫云应用
+```
+lzc-cli project create yourappname
+```
+
+### 构建 lpk 包
+```
+lzc-cli project build -o yourappname.lpk
+```
+
+### 盒子内开发
+```
+lzc-cli project devshell -b
 ```
+`-b` 表示是否重新构建盒子中项目环境。

package/lib/api.js

@@ -1,7 +1,8 @@
 import ora from "ora";
 import chalk from "chalk";
 import fs from "fs";
-import { request } from "./autologin.js";
+import logger from "loglevel";
+import fetch from "node-fetch";
 
 //
 // sdk 提供的API
@@ -10,10 +11,12 @@ export default class API {
     this.appId = appId;
     this.host = host;
   }
-  async applyZip(zipPath, params) {
-    let searchParams = new URLSearchParams(params);
-    const resp = await request(
-      `${this.host}/api/v1/app/applyZip?${searchParams.toString()}`,
+  async install(zipPath) {
+    if (!fs.existsSync(zipPath)) {
+      throw `${zipPath} 不存在`;
+    }
+    const resp = await fetch(
+      `${this.host}/api/v1/app/install?id=${this.appId}`,
       {
         method: "POST",
         body: fs.createReadStream(zipPath),
@@ -22,33 +25,65 @@ export default class API {
     if (resp.status != 200) {
       throw chalk.red(await resp.text());
     }
-    // update
   }
-  // applyZip api 支持以下query
-  // build boolean 是否构建app容器
-  // pull boolean 是否从docker.io拉取image
-  async install(zipPath, params) {
-    const resp = await request(
-      `${this.host}/api/v1/app/install`,
+
+  async uninstall() {
+    return await fetch(`${this.host}/api/v1/app/uninstall?id=${this.appId}`, {
+      method: "DELETE",
+    });
+  }
+
+  async resume() {
+    const resp = await fetch(
+      `${this.host}/api/v1/app/resume?id=${this.appId}`,
       {
         method: "POST",
-        body: fs.createReadStream(zipPath),
       }
     );
     if (resp.status != 200) {
-      throw chalk.red(await resp.text());
+      const text = await resp.text();
+      throw text;
     }
-    // update
   }
 
-  async uninstall() {
-    return await request(`${this.host}/api/v1/app/uninstall?id=${this.appId}`, {
-      method: "DELETE",
-    });
+  async hasMount() {
+    const resp = await fetch(
+      `${this.host}/api/v1/app/hasMount?id=${this.appId}`,
+      {
+        method: "GET",
+      }
+    );
+    if (resp.status == 200) {
+      return true;
+    } else {
+      const text = await resp.text();
+      if (text) {
+        logger.debug("hasMount request failed", text);
+      }
+      return false;
+    }
+  }
+
+  async isDevshell() {
+    const resp = await fetch(
+      `${this.host}/api/v1/app/isDevshell?id=${this.appId}`,
+      {
+        method: "GET",
+      }
+    );
+    if (resp.status == 200) {
+      return true;
+    } else {
+      const text = await resp.text();
+      if (text) {
+        logger.debug("isDevshell request failed", text);
+      }
+      return false;
+    }
   }
 
   async status() {
-    const resp = await request(`${this.host}/api/v1/app/status?id=${this.appId}`);
+    const resp = await fetch(`${this.host}/api/v1/app/status?id=${this.appId}`);
     if (resp.status == 200) {
       const status = await resp.json();
       return status;
@@ -60,7 +95,7 @@ export default class API {
   }
 
   async postPublicKey(key) {
-    const resp = await request(`${this.host}/api/v1/register`, {
+    const resp = await fetch(`${this.host}/api/v1/register`, {
       method: "POST",
       body: key,
     });
@@ -69,7 +104,7 @@ export default class API {
     }
   }
 
-  async checkStatus() {
+  async checkStatus(resume = false) {
     const spinner = ora().start();
     let { status, info } = await this.status();
     spinner.text = "部署进度 " + status;
@@ -80,12 +115,17 @@ export default class API {
         break;
       case "error":
         spinner.stop();
-        console.log(status, info);
+        logger.error("应用状态错误，请在盒子中查看对应的错误信息");
         throw info?.msg;
       default:
         try {
-          await desireStatusTimer((result) => {
+          await desireStatusTimer(async (result) => {
             spinner.text = "部署进度 " + result.status;
+
+            if (result.status == "paused" && resume) {
+              await this.resume();
+            }
+
             return result.status === "running";
           }, this.status.bind(this));
         } catch (error) {
@@ -100,33 +140,28 @@ export default class API {
 }
 
 export function desireStatusTimer(desireCheckFn, getStatusFn) {
-  const step = 2000;
+  let errorCount = 0;
   return new Promise((resolve, reject) => {
     function schedule(timeout) {
       setTimeout(async () => {
+        const answer = await getStatusFn();
         try {
-          const answer = await getStatusFn();
           if (answer) {
             if (answer.status == "error") {
-              timeout += step;
-              if (timeout > 1000 * 10) {
-                reject(new Error(answer.error));
-                return;
-              }
-              schedule(timeout);
-            } else if (desireCheckFn(answer)) {
+              throw new Error(answer.error);
+            } else if (await desireCheckFn(answer)) {
               resolve(answer);
             } else {
               schedule(1000);
             }
           }
         } catch (e) {
-          timeout += step;
-          if (timeout > 1000 * 10) {
+          errorCount += 1;
+          if (errorCount >= 3) {
             reject(e);
             return;
           }
-          schedule(timeout);
+          schedule(1000);
         }
       }, timeout);
     }

package/lib/app/index.js

@@ -1,10 +1,11 @@
 import path from "node:path";
-import lpkCreate, { LpkManifest } from "./lpk_create.js";
+import lpkCreate from "./lpk_create.js";
 import { LpkBuild } from "./lpk_build.js";
-import { AppDevShell } from "./lpk_devshell.js";
+import { AppDevShell, fallbackToRsync } from "./lpk_devshell.js";
 import { LpkInstaller } from "./lpk_installer.js";
-import fs from "node:fs";
-import { APP_FOLDER } from "../utils.js";
+import { LpkUninstaller } from "./lpk_uninstall.js";
+import { LpkStatuser } from "./lpk_status.js";
+import { LpkLogger } from "./lpk_log.js";
 
 export function lpkProjectCommand(program) {
   let subCommands = [
@@ -12,7 +13,7 @@ export function lpkProjectCommand(program) {
       command: "create <name>",
       desc: "创建懒猫云应用",
       handler: async ({ name }) => {
-        await lpkCreate({ name });
+        await lpkCreate(name);
       },
     },
     {
@@ -21,18 +22,23 @@ export function lpkProjectCommand(program) {
       builder: (args) => {
         args.option("o", {
           alias: "output",
-          describe: "输出文件夹",
+          describe: "输出文件",
+          type: "string",
+        });
+        args.option("f", {
+          alias: "file",
+          describe: "指定构建的lzc-build.yml文件",
           type: "string",
         });
       },
-      handler: async ({ context, output }) => {
-        const lpk = new LpkBuild();
-        await lpk.init();
+      handler: async ({ context, output, file }) => {
+        const lpk = await new LpkBuild(context, file).init();
         // 正常的打包逻辑不需要 devshell
         lpk.onBeforeBuildPackage(async (options) => {
           delete options["devshell"];
+
           if (output) {
-            options["pkgout"] = output;
+            options["lpkPath"] = output;
           }
           return options;
         });
@@ -43,20 +49,35 @@ export function lpkProjectCommand(program) {
       command: "devshell [context]",
       desc: "进入盒子的开发环境",
       builder: (args) => {
-        args.option("b", {
-          alias: "build",
-          describe: "重新构建环境",
+        args.option("r", {
+          alias: "rsync",
+          deprecate: true,
+          type: "boolean",
+          default: fallbackToRsync(),
+        });
+        const shell = process.env.SHELL
+          ? path.basename(process.env.SHELL)
+          : "sh";
+        args.option("s", {
+          alias: "shell",
+          describe: "指定你最喜欢的shell",
+          type: "string",
+          default: shell,
+        });
+        args.option("f", {
+          alias: "force",
+          describe: "强制重新构建",
           type: "boolean",
-          default: false,
         });
       },
-      handler: async ({ context, build }) => {
-        const app = new AppDevShell(context);
+      handler: async ({ context, shell, rsync, force }) => {
+        const app = new AppDevShell(context, undefined, rsync, force);
         await app.init();
-        if (build) {
-          await app.shellWithBuild();
+        await app.build();
+        if (rsync) {
+          await app.rsyncShell(shell);
         } else {
-          await app.shell();
+          await app.sshfsShell(shell);
         }
       },
     },
@@ -73,12 +94,47 @@ export function lpkProjectCommand(program) {
 export function lpkAppCommand(program) {
   let subCommands = [
     {
-      command: "install <pkgPath>",
-      desc: "部署应用至设备",
-      handler: async ({ pkgPath }) => {
+      command: "install <pkgUrl>",
+      desc: "部署应用至设备, pkgUrl 可以为路径，或者https://,http://请求地址",
+      handler: async ({ pkgUrl }) => {
         const installer = new LpkInstaller();
         await installer.init();
-        await installer.install(pkgPath);
+        await installer.install(pkgUrl);
+      },
+    },
+    {
+      command: "uninstall <pkgId>",
+      desc: "从设备中卸载某一个应用",
+      handler: async ({ pkgId }) => {
+        const uninstaller = new LpkUninstaller();
+        await uninstaller.init();
+        await uninstaller.uninstall(pkgId);
+      },
+    },
+    {
+      command: "status <pkgId>",
+      desc: "获取某一个应用的状态",
+      handler: async ({ pkgId }) => {
+        const statuser = new LpkStatuser();
+        await statuser.init();
+        await statuser.status(pkgId);
+      },
+    },
+    {
+      command: "log <pkgId>",
+      desc: "查看某一个app的日志",
+      builder: (args) => {
+        args.option("f", {
+          alias: "follow",
+          describe: "持续输出",
+          type: "boolean",
+          default: false,
+        });
+      },
+      handler: async ({ pkgId, follow }) => {
+        const log = new LpkLogger();
+        await log.init();
+        await log.start(pkgId, follow);
       },
     },
   ];

package/lib/app/lpk_build.js

@@ -87,11 +87,35 @@ async function fetchIconTo(options, cwd, destDir) {
   return;
 }
 
+// 提供一些方便的环境变量，可以在 lzc-build.yml 中直接使用
+// - LocalIP 本地局域网ip
+function localIp() {
+  const output = spawnSync("ip", ["route", "get", "1.1.1.1"], {
+    encoding: "utf-8",
+  });
+  const match = output.stdout.match(/src\ (.+)\ uid/i);
+  if (match) {
+    return match[1];
+  } else {
+    logger.debug("get LocalIP environment error", output.stderr);
+    return "";
+  }
+}
+function convenientEnv() {
+  return Object.assign(
+    {},
+    {
+      LocalIP: localIp(),
+    },
+    process.env
+  );
+}
+
 export class LpkBuild {
-  constructor(cwd) {
+  constructor(cwd, lzcBuild = "lzc-build.yml") {
     this.pwd = cwd ?? process.cwd();
 
-    this.optionsFilePath = path.join(this.pwd, "lzc-build.yml");
+    this.optionsFilePath = path.join(this.pwd, lzcBuild);
     this.options = loadFromYaml(this.optionsFilePath);
 
     this.manifestFilePath = this.options["manifest"]
@@ -108,9 +132,14 @@ export class LpkBuild {
   // init 时替换 lzc-build.yml 中的模板字段
   async init() {
     const manifest = await this.getManifest();
+    const primitive = convenientEnv();
     this.options = yaml.load(
-      await envTemplateFile(this.optionsFilePath, manifest)
+      await envTemplateFile(
+        this.optionsFilePath,
+        Object.assign({}, primitive, manifest)
+      )
     );
+    return this;
   }
 
   // onBeforeDumpYaml
@@ -119,7 +148,7 @@ export class LpkBuild {
     this.beforeDumpYamlFn.push(fn);
   }
   // onBeforeTarContent
-  // fn: function(contentdir) => void
+  // fn: function(contentdir, options) => void
   onBeforeTarContent(fn) {
     this.beforeTarContentFn.push(fn);
   }
@@ -146,7 +175,7 @@ export class LpkBuild {
     return this.manifest;
   }
 
-  async exec(prefix = "") {
+  async exec() {
     if (this.beforeBuildPackageFn.length > 0) {
       this.options = await this.beforeBuildPackageFn.reduce(
         async (prev, curr) => {
@@ -168,62 +197,77 @@ export class LpkBuild {
       logger.warn("跳过执行 buildscript");
     }
 
+    // 输出路径
+    let packName = this.options["lpkPath"];
     const pkgout = path.resolve(this.pwd, this.options["pkgout"]);
-    if (!isDirExist(pkgout)) {
+    if (!packName && !isDirExist(pkgout)) {
       throw `${pkgout} 不存在`;
     }
 
     const tempDir = fs.mkdtempSync(".lzc-cli-build");
-
     let contentdir = this.options["contentdir"];
-    if (contentdir) {
-      contentdir = path.isAbsolute(contentdir)
-        ? contentdir
-        : path.join(this.pwd, contentdir);
-      if (!isDirExist(contentdir)) {
-        throw `${contentdir} 不存在`;
+    try {
+      if (contentdir) {
+        contentdir = path.resolve(this.pwd, contentdir);
+        if (!isDirExist(contentdir)) {
+          throw `${contentdir} 不存在`;
+        }
+      } else {
+        logger.warn("跳过拷贝 contentdir 内容");
+        // 当没有指定的 contentdir 的时候，也生成一个空的文件夹
+        // 原因是：可能其他地方会复制内容进来，像 devshell 中的会在打包的时候，将ssh key拷贝进来
+        contentdir = fs.mkdtempSync(path.join(tempDir, "fake-contentdir"));
       }
-    } else {
-      logger.warn("跳过拷贝 contentdir 内容");
-      // 当没有指定的 contentdir 的时候，也生成一个空的文件夹
-      // 原因是：可能其他地方会复制内容进来，像 devshell 中的会在打包的时候，将ssh key拷贝进来
-      contentdir = fs.mkdtempSync(path.join(tempDir, "fake-contentdir"));
-    }
 
-    // 开始打包 contentdir
-    if (this.beforeTarContentFn.length > 0) {
-      await this.beforeTarContentFn.reduce(async (prev, curr) => {
-        let _prev = await prev;
-        await curr(_prev);
-        return _prev;
-      }, contentdir);
-    }
-    tarContentDir("./", path.join(tempDir, "content.tar"), contentdir);
-
-    // 开始生成 manifest.yml
-    let manifest = await this.getManifest();
-    if (this.beforeDumpYamlFn.length > 0) {
-      manifest = await this.beforeDumpYamlFn.reduce(async (prev, curr) => {
-        return await curr(await prev, this.options);
-      }, manifest);
-    }
-    logger.debug("manifest\n", manifest);
-    dumpToYaml(manifest, path.join(tempDir, "manifest.yml"));
-
-    // 打包 lpk
-    if (this.beforeDumpLpkFn.length > 0) {
-      await this.beforeDumpLpkFn.reduce(async (prev, curr) => {
-        await curr(this.options, this.pwd, tempDir);
-        return prev;
-      }, {});
-    }
-    const packName = `${prefix}${manifest.package}-v${manifest.version}.lpk`;
-    const lpkPath = await archiveFolderTo(tempDir, path.join(pkgout, packName));
-    logger.info(`输出lpk包 ${lpkPath.path}`);
+      // 开始打包 contentdir
+      if (this.beforeTarContentFn.length > 0) {
+        await this.beforeTarContentFn.reduce(async (prev, curr) => {
+          let _prev = await prev;
+          await curr(_prev, this.options);
+          return _prev;
+        }, contentdir);
+      }
+      tarContentDir("./", path.join(tempDir, "content.tar"), contentdir);
+
+      // 如果是临时的 contentdir, 目录在打包完成后删除
+      if (!this.options["contentdir"]) {
+        fs.rmSync(contentdir, { recursive: true });
+      }
 
-    // remove temp file
-    fs.rmSync(tempDir, { recursive: true });
+      // 开始生成 manifest.yml
+      let manifest = await this.getManifest();
+      if (process.env.LZC_VERSION) {
+        manifest.version = process.env.LZC_VERSION;
+      }
+      if (this.beforeDumpYamlFn.length > 0) {
+        manifest = await this.beforeDumpYamlFn.reduce(async (prev, curr) => {
+          return await curr(await prev, this.options);
+        }, manifest);
+      }
+      logger.debug("manifest\n", manifest);
+      dumpToYaml(manifest, path.join(tempDir, "manifest.yml"));
 
-    return lpkPath.path;
+      // 打包 lpk
+      if (this.beforeDumpLpkFn.length > 0) {
+        await this.beforeDumpLpkFn.reduce(async (prev, curr) => {
+          await curr(this.options, this.pwd, tempDir);
+          return prev;
+        }, {});
+      }
+
+      if (!packName) {
+        packName = path.resolve(
+          pkgout,
+          `${manifest.package}-v${manifest.version}.lpk`
+        );
+      }
+
+      const lpkPath = await archiveFolderTo(tempDir, packName);
+      logger.info(`输出lpk包 ${lpkPath.path}`);
+
+      return lpkPath.path;
+    } finally {
+      fs.rmSync(tempDir, { recursive: true });
+    }
   }
 }