@lazycatcloud/lzc-cli 1.1.8 → 1.1.10

package/lib/app/lpk_devshell_docker.js

@@ -0,0 +1,211 @@
+// build strategies based on lzc-build.yml devshell field
+import path from "node:path";
+import fs from "node:fs";
+import logger from "loglevel";
+
+import { DockerClient, SSHClient, connectOptions } from "../sdk.js";
+import { DockerfileParser } from "dockerfile-ast";
+import glob from "fast-glob";
+import ignore from "@balena/dockerignore";
+import { createLogUpdate } from "log-update";
+import { sdkEnv } from "../env.js";
+
+export class SdkDocker {
+  constructor() {}
+
+  // builder 需要在app 的场景下使用, 不过有两个路径要注意
+  // 一个是 docker build 时的context. 这个一般是运行cli时候的路径
+  async buildImage(tag, buildDir, contextDir) {
+    const dockerfilePath = path.join(buildDir, "Dockerfile");
+    await this.dockerRemoteBuildV2(contextDir, dockerfilePath, tag);
+  }
+
+  async collectContextFromDockerFile(contextDir, dockerfilePath) {
+    if (!fs.existsSync(dockerfilePath)) {
+      throw "未发现 Dockerfile";
+    }
+
+    let src = [path.relative(contextDir, dockerfilePath)];
+
+    // 通过 COPY 和 ADD 获取所有context中的文件
+    const ast = DockerfileParser.parse(fs.readFileSync(dockerfilePath, "utf8"));
+    for (let a of ast.getInstructions()) {
+      if (["COPY", "ADD"].includes(a.getInstruction())) {
+        const from = a.getArguments()[0].getValue().replace(/^\//, "");
+
+        const fromFullPath = path.join(contextDir, from);
+
+        if (fs.existsSync(fromFullPath)) {
+          const stat = fs.statSync(path.join(contextDir, from));
+          if (stat.isDirectory()) {
+            let files = await glob(path.join(from, "**"), {
+              cwd: contextDir,
+            });
+            src = src.concat(files);
+          } else if (stat.isFile()) {
+            src.push(from);
+          }
+        } else {
+          // try use glob
+          let files = await glob(from, {
+            cwd: contextDir,
+          });
+          src = src.concat(files);
+        }
+      }
+    }
+    // filter by dockerignore
+    const dockerIgnoreFile = path.join(contextDir, ".dockerignore");
+    //
+    if (fs.existsSync(dockerIgnoreFile)) {
+      let ig = ignore();
+      let data = fs.readFileSync(dockerIgnoreFile, "utf8");
+      ig.add(data.split("\n"));
+      src = ig.filter(src);
+    }
+    return src;
+  }
+
+  /**
+   * v2 版本会收集所有需要的context 文件,将其传入buildImage 方法中
+   * @param contextDir
+   * @param dockerfile
+   * @param tag
+   */
+  async dockerRemoteBuildV2(contextDir, dockerfile, tag) {
+    const src = await this.collectContextFromDockerFile(contextDir, dockerfile);
+    const host = new URL(sdkEnv.sdkUrl).host;
+    console.log(host);
+    const docker = await new DockerClient(host).init();
+    try {
+      return new Promise(async (resolve, reject) => {
+        let refresher = new StatusRefresher();
+
+        logger.info("开始在设备中构建镜像");
+        const stream = await docker.buildImage(
+          {
+            context: contextDir,
+            src: src,
+          },
+          {
+            dockerfile: src[0],
+            t: tag,
+            networkmode: "home-cloud",
+          }
+        );
+        docker.modem.followProgress(
+          stream,
+          (err, res) => {
+            err ? reject(err) : resolve(res);
+          },
+          (res) => {
+            if (res.status) {
+              if (res.id) {
+                if (["Downloading", "Extracting"].includes(res.status)) {
+                  refresher.updateStatus({
+                    id: res.id,
+                    content: `${res.status} ${res.progress}`,
+                  });
+                } else {
+                  refresher.updateStatus({
+                    id: res.id,
+                    content: res.status,
+                  });
+                }
+              } else {
+                process.stdout.write(res.status);
+                process.stdout.write("\n");
+              }
+            }
+
+            if (res.stream) {
+              if (res.stream.startsWith("Step")) {
+                refresher.reset();
+              }
+              process.stdout.write(res.stream);
+            }
+            if (res.error) {
+              reject(res.error);
+            }
+          }
+        );
+      });
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  async interactiveShell(appId, shell) {
+    const host = new URL(sdkEnv.sdkUrl).hostname;
+    const opts = await connectOptions(host);
+    const client = new SSHClient(opts);
+    await client.connect();
+    try {
+      const replacedAppId = appId.replaceAll(".", "_").replaceAll("-", "__");
+      const containerName = `lzc--${replacedAppId}-app-1`;
+      const stream = await client.exec(
+        `docker exec -e SHELL=${shell} -e PKGID=${appId} -ti ${containerName} /lzcapp/pkg/content/devshell/exec.sh`,
+        {
+          pty: true,
+        }
+      );
+
+      stream.setWindow(process.stdout.rows, process.stdout.columns, 0, 0);
+      process.stdin.setRawMode(true);
+      process.stdin.pipe(stream);
+
+      stream.stdout.pipe(process.stdout);
+      stream.stderr.pipe(process.stderr);
+      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);
+      });
+
+      await new Promise((resolve, reject) => {
+        stream.on("close", () => {
+          client.close();
+          resolve();
+        });
+        stream.on("error", (e) => {
+          logger.error("interactiveShell error", e);
+          reject(e);
+        });
+      });
+    } catch (e) {
+      logger.error(e);
+    } finally {
+      process.stdin.setRawMode(false);
+      client.close();
+    }
+  }
+}
+
+class StatusRefresher {
+  constructor() {
+    this.reset();
+  }
+  refresh() {
+    this.logUpdate(this.pulls.map((p) => `${p.id}: ${p.content}`).join("\n"));
+  }
+
+  reset() {
+    this.pulls = [];
+    this.logUpdate = createLogUpdate(process.stdout);
+  }
+
+  updateStatus({ id, content }) {
+    let index = this.pulls.findIndex((p) => p.id == id);
+    if (index > -1) {
+      this.pulls[index] = {
+        id: id,
+        content: content,
+      };
+    } else {
+      this.pulls.push({
+        id: id,
+        content: content,
+      });
+    }
+    this.refresh();
+  }
+}

package/lib/app/lpk_installer.js

@@ -3,8 +3,9 @@ import { sdkEnv } from "../env.js";
 import logger from "loglevel";
 import fs from "node:fs";
 import path from "node:path";
-import { dockerPullLzcAppsImage } from "../sdk.js";
 import Key from "../key.js";
+import { loadFromYaml, Downloader, sleep } from "../utils.js";
+import { spawnSync } from "node:child_process";
 
 export class LpkInstaller {
   constructor() {}
@@ -16,9 +17,6 @@ export class LpkInstaller {
     // 2. pull 镜像需要ssh key
     const k = new Key();
     await k.ensure(sdkEnv.sdkUrl);
-
-    const host = new URL(sdkEnv.sdkUrl).hostname;
-    await dockerPullLzcAppsImage(host);
   }
 
   async deploy(builder) {
@@ -29,39 +27,78 @@ export class LpkInstaller {
     let manifest = await builder.getManifest();
     let api = new BoxAPI(manifest["package"], sdkEnv.sdkUrl);
 
+    let pkgPath = await builder.exec("");
+    logger.info("开始部署应用");
+    await api.install(pkgPath);
+
+    // 新安装的应用默认为休眠的状态，需要先等容器创建成功，等成为 paused 后 resume 下
+    await api.checkStatus(true);
+
+    await sleep(2000);
+    logger.info(
+      `👉 请在浏览器中访问 ${sdkEnv.sdkUrl.replace(
+        /sdk/,
+        manifest["application"]["subdomain"]
+      )}`
+    );
+  }
+
+  async install(pkgUrl) {
+    if (pkgUrl.startsWith("http")) {
+      return this.installFromUrl(pkgUrl);
+    } else {
+      return this.installFromFile(pkgUrl);
+    }
+  }
+
+  async installFromUrl(url) {
+    let downloader = new Downloader();
+    const tempDir = fs.mkdtempSync(".lzc-cli-install");
     try {
-      let pkgPath = await builder.exec("");
-      logger.info("开始部署应用");
-      await api.install(pkgPath);
-      await api.checkStatus();
-      logger.info(
-        `请在浏览器中访问 ${sdkEnv.sdkUrl.replace(
-          /sdk/,
-          manifest["application"]["subdomain"]
-        )}`
-      );
+      let pkgPath = path.join(tempDir, "a.lpk");
+      logger.debug("开始下载lpk");
+      await downloader.download(url, pkgPath);
+      logger.debug("下载完成", pkgPath);
+      await this.installFromFile(pkgPath);
     } catch (e) {
       throw e;
+    } finally {
+      fs.rmSync(tempDir, { recursive: true });
     }
   }
 
-  async install(pkgPath) {
+  async installFromFile(pkgPath) {
     if (!pkgPath) {
       throw "install 必须指定一个 pkg 路径";
     }
-    let pkgNameParts = path.basename(pkgPath).split("-v");
-    if (pkgNameParts.length < 2) {
-      throw "lpk 文件名不合法：应该使用 $appid-$version.lpk 的格式（如 xxx-v0.0.1.lpk）"
+
+    if (!fs.existsSync(pkgPath)) {
+      throw `${pkgPath} 不存在`;
     }
-    let pkgName = pkgNameParts[0]
-    let api = new BoxAPI(pkgName, sdkEnv.sdkUrl);
+
+    const tempDir = fs.mkdtempSync(".lzc-cli-install");
+    let pkgName;
+    let manifest;
     try {
-      logger.info("开始安装应用");
-      await api.install(pkgPath);
-      await api.checkStatus();
-      logger.info(`安装成功！`);
-    } catch (e) {
-      throw e;
+      spawnSync("unzip", ["-d", tempDir, pkgPath]);
+
+      manifest = loadFromYaml(path.join(tempDir, "manifest.yml"));
+      logger.debug("lpk manifest", manifest);
+
+      pkgName = manifest.package;
+    } finally {
+      fs.rmSync(tempDir, { recursive: true });
     }
+
+    let api = new BoxAPI(pkgName, sdkEnv.sdkUrl);
+    logger.info("开始安装应用");
+    await api.install(pkgPath);
+    logger.info(`安装成功！`);
+    logger.info(
+      `👉 请在浏览器中访问 ${sdkEnv.sdkUrl.replace(
+        /sdk/,
+        manifest["application"]["subdomain"]
+      )}`
+    );
   }
 }

package/lib/app/lpk_log.js

@@ -0,0 +1,68 @@
+import { readFileSync } from "fs";
+import { Client } from "ssh2";
+import os from "os";
+import path from "path";
+import process from "process";
+import { sdkEnv } from "../env.js";
+import { SSHClient, connectOptions } from "../sdk.js";
+import logger from "loglevel";
+
+function StreamPromise(stream) {
+  let data = "";
+  return new Promise((resolve, reject) => {
+    stream
+      .on("data", (d) => {
+        data = d;
+      })
+      .on("close", (code, signal) => {
+        resolve(String(data));
+      })
+      .stderr.on("data", (data) => {
+        reject(String(data));
+      });
+  });
+}
+
+export class LpkLogger {
+  constructor() {}
+
+  async init() {
+    await sdkEnv.ensure();
+  }
+
+  async start(project, follow = false) {
+    const host = new URL(sdkEnv.sdkUrl).hostname;
+    const opts = await connectOptions(host);
+    const client = new SSHClient(opts);
+    await client.connect();
+    try {
+      const replacedAppId = project.replaceAll(".", "_").replaceAll("-", "__");
+      const findStream = await client.exec(
+        `docker-compose ls | grep ${replacedAppId} | head -n 1`
+      );
+      const result = await StreamPromise(findStream);
+      if (result == "") {
+        throw `${project} 服务没有找到`;
+      }
+
+      const name = result.split(" ")[0];
+      const _f = follow ? "-f " : " ";
+      const stream = await client.exec(`docker-compose -p ${name} logs ${_f}`, {
+        pty: true,
+      });
+      await 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) {
+      logger.error(e);
+    } finally {
+      client.close();
+    }
+  }
+}

package/lib/app/lpk_status.js

@@ -0,0 +1,18 @@
+import BoxAPI from "../api.js";
+import { sdkEnv } from "../env.js";
+import logger from "loglevel";
+
+export class LpkStatuser {
+  constructor() {}
+
+  async init() {
+    // 1. 确保 sdk 已经安装
+    await sdkEnv.ensure();
+  }
+
+  async status(pkgId) {
+    let api = new BoxAPI(pkgId, sdkEnv.sdkUrl);
+    let { status } = await api.status();
+    logger.info(status);
+  }
+}

package/lib/app/lpk_uninstall.js

@@ -0,0 +1,19 @@
+import BoxAPI from "../api.js";
+import { sdkEnv } from "../env.js";
+import logger from "loglevel";
+
+export class LpkUninstaller {
+  constructor() {}
+
+  async init() {
+    // 1. 确保 sdk 已经安装
+    await sdkEnv.ensure();
+  }
+
+  async uninstall(pkgId) {
+    logger.info(`开始卸载${pkgId}`);
+    let api = new BoxAPI(pkgId, sdkEnv.sdkUrl);
+    await api.uninstall();
+    logger.info(`卸载成功！`);
+  }
+}

package/lib/appstore/index.js

@@ -0,0 +1,37 @@
+import { Publish } from "./publish.js";
+import { reLogin } from "./login.js";
+
+export function appstoreCommand(program) {
+  let subCommands = [
+    {
+      command: "login",
+      desc: "登录",
+      handler: async () => {
+        await reLogin();
+      },
+    },
+    {
+      command: "publish <pkgPath>",
+      desc: "发布到商店",
+      builder: (args) => {
+        args.option("c", {
+          alias: "changelog",
+          describe: "更改日志",
+          type: "string",
+        });
+      },
+      handler: async ({ pkgPath, changelog }) => {
+        const p = new Publish();
+        await p.publish(pkgPath, changelog);
+      },
+    },
+  ];
+
+  program.command({
+    command: "appstore",
+    desc: "应用商店",
+    builder: (args) => {
+      args.command(subCommands);
+    },
+  });
+}