@lazycatcloud/lzc-cli 1.2.26 → 1.2.28

package/lib/app/lpk_devshell_docker.js

@@ -1,54 +1,54 @@
-import path from "node:path";
-import fs from "node:fs";
-import { DockerfileParser } from "dockerfile-ast";
-import glob from "fast-glob";
-import ignore from "@balena/dockerignore";
-import { tarContentDir } from "../utils.js";
+import path from "node:path"
+import fs from "node:fs"
+import { DockerfileParser } from "dockerfile-ast"
+import glob from "fast-glob"
+import ignore from "@balena/dockerignore"
+import { tarContentDir } from "../utils.js"
 
 export async function collectContextFromDockerFile(contextDir, dockerfilePath) {
   if (!fs.existsSync(dockerfilePath)) {
-    throw "未发现 Dockerfile";
+    throw "未发现 Dockerfile"
   }
 
-  let src = [];
+  let src = []
 
   // 通过 COPY 和 ADD 获取所有context中的文件
-  const ast = DockerfileParser.parse(fs.readFileSync(dockerfilePath, "utf8"));
+  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.resolve(contextDir, from);
+      const from = a.getArguments()[0].getValue().replace(/^\//, "")
+      const fromFullPath = path.resolve(contextDir, from)
 
       if (fs.existsSync(fromFullPath)) {
-        const stat = fs.statSync(fromFullPath);
+        const stat = fs.statSync(fromFullPath)
         if (stat.isDirectory()) {
           let files = await glob(path.join(from, "**"), {
-            cwd: contextDir,
-          });
-          src = src.concat(files);
+            cwd: contextDir
+          })
+          src = src.concat(files)
         } else if (stat.isFile()) {
-          src.push(from);
+          src.push(from)
         }
       } else {
         // try use glob
         let files = await glob(from, {
-          cwd: contextDir,
-        });
-        src = src.concat(files);
+          cwd: contextDir
+        })
+        src = src.concat(files)
       }
     }
   }
   // filter by dockerignore
-  const dockerIgnoreFile = path.join(contextDir, ".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);
+    let ig = ignore()
+    let data = fs.readFileSync(dockerIgnoreFile, "utf8")
+    ig.add(data.split("\n"))
+    src = ig.filter(src)
   }
 
-  const dockerfile = path.relative(contextDir, dockerfilePath);
-  src.push(dockerfile); // DON'T IGNORE DOCKERFILE
-  const output = path.join(contextDir, "lzc-build-image-context.tar");
-  return await tarContentDir(src, output, contextDir);
+  const dockerfile = path.relative(contextDir, dockerfilePath)
+  src.push(dockerfile) // DON'T IGNORE DOCKERFILE
+  const output = path.join(contextDir, "lzc-build-image-context.tar")
+  return await tarContentDir(src, output, contextDir)
 }

package/lib/app/lpk_installer.js

@@ -1,26 +1,27 @@
-import logger from "loglevel";
-import fs from "node:fs";
-import path from "node:path";
-import { loadFromYaml, Downloader } from "../utils.js";
-import { spawnSync } from "node:child_process";
-import { DebugBridge } from "./lpk_debug_bridge.js";
-import shellapi from "../shellapi.js";
+import logger from "loglevel"
+import fs from "node:fs"
+import path from "node:path"
+import { loadFromYaml, Downloader } from "../utils.js"
+import { spawnSync } from "node:child_process"
+import { DebugBridge } from "./lpk_debug_bridge.js"
+import shellapi from "../shellapi.js"
+import { triggerApk } from "./apkshell.js"
 
 // 从一个目录中找出修改时间最新的包
 function findOnceLpkByDir(dir = process.cwd()) {
   const pkg = fs
     .readdirSync(dir)
     .map((filename) => {
-      const stat = fs.statSync(path.resolve(dir, filename));
-      return { filename, mtime: stat.mtime };
+      const stat = fs.statSync(path.resolve(dir, filename))
+      return { filename, mtime: stat.mtime }
     })
     .sort((a, b) => {
-      return b.mtime - a.mtime;
+      return b.mtime - a.mtime
     })
     .find((entry) => {
-      return entry.filename.endsWith(".lpk");
-    });
-  return pkg?.filename ? path.resolve(dir, pkg.filename) : "";
+      return entry.filename.endsWith(".lpk")
+    })
+  return pkg?.filename ? path.resolve(dir, pkg.filename) : ""
 }
 
 export class LpkInstaller {
@@ -31,77 +32,86 @@ export class LpkInstaller {
   // deploy 构建和安装
   async deploy(builder) {
     if (!builder) {
-      throw "deploy 必须传递一个 builder";
+      throw "deploy 必须传递一个 builder"
     }
 
-    let manifest = await builder.getManifest();
-    let pkgPath = await builder.exec();
-    logger.info("开始部署应用");
-    const bridge = new DebugBridge();
-    await bridge.install(pkgPath, manifest["package"]);
-    const appUrl = `https://${manifest["application"]["subdomain"]}.${shellapi.boxname}.heiyu.space`;
-    logger.info(`👉 请在浏览器中访问 ${appUrl}`);
+    let pkgPath = await builder.exec()
+    logger.info("开始部署应用")
+    // FIXME: 这里是前面exec输出的pkgPath还有异步的地方没有await到,临时setTimeout处理一下,后期让@llh看一下
+    await new Promise((resolve, reject) => {
+      setTimeout(async () => {
+        await this.installFromFile(pkgPath)
+          .then(() => resolve(true))
+          .catch(reject)
+      }, 50)
+    })
   }
 
   async install(pkgPath) {
     if (pkgPath.startsWith("http")) {
-      return this.installFromUrl(pkgPath);
+      return this.installFromUrl(pkgPath)
     } else if (fs.statSync(pkgPath).isDirectory()) {
-      return this.installFromDirectory(pkgPath);
+      return this.installFromDirectory(pkgPath)
     } else {
-      return this.installFromFile(pkgPath);
+      return this.installFromFile(pkgPath)
     }
   }
 
   async installFromDirectory(dir) {
-    const lpk = findOnceLpkByDir(dir);
+    const lpk = findOnceLpkByDir(dir)
     if (lpk) {
-      logger.info(`正在安装自动扫描出来的lpk包(${lpk})`);
+      logger.info(`正在安装自动扫描出来的lpk包(${lpk})`)
     }
-    return this.installFromFile(lpk);
+    return this.installFromFile(lpk)
   }
 
   async installFromUrl(url) {
-    let downloader = new Downloader();
-    const tempDir = fs.mkdtempSync(".lzc-cli-install");
+    let downloader = new Downloader()
+    const tempDir = fs.mkdtempSync(".lzc-cli-install")
     try {
-      let pkgPath = path.join(tempDir, "a.lpk");
-      logger.debug("开始下载lpk");
-      await downloader.download(url, pkgPath);
-      logger.debug("下载完成", pkgPath);
-      await this.installFromFile(pkgPath);
+      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;
+      throw e
     } finally {
-      fs.rmSync(tempDir, { recursive: true });
+      fs.rmSync(tempDir, { recursive: true })
     }
   }
 
   async installFromFile(pkgPath) {
     if (!pkgPath) {
-      throw "install 必须指定一个 pkg 路径";
+      throw "install 必须指定一个 pkg 路径"
     }
 
     if (!fs.existsSync(pkgPath)) {
-      throw `${pkgPath} 不存在`;
+      throw `${pkgPath} 不存在`
     }
 
-    const tempDir = fs.mkdtempSync(".lzc-cli-install");
-    let manifest;
+    const tempDir = fs.mkdtempSync(".lzc-cli-install")
+    let manifest
     try {
-      spawnSync("unzip", ["-d", tempDir, pkgPath]);
-      manifest = loadFromYaml(path.join(tempDir, "manifest.yml"));
-      logger.debug("lpk manifest", manifest);
+      spawnSync("unzip", ["-d", tempDir, pkgPath])
+      manifest = loadFromYaml(path.join(tempDir, "manifest.yml"))
+      await triggerApk(
+        manifest["package"],
+        manifest["name"],
+        path.resolve(path.join(tempDir, "icon.png"))
+      )
+      logger.debug("lpk manifest", manifest)
     } finally {
-      fs.rmSync(tempDir, { recursive: true });
+      fs.rmSync(tempDir, { recursive: true })
     }
 
-    const bridge = new DebugBridge();
-    logger.info("开始安装应用");
-    await bridge.install(pkgPath, manifest["package"]);
-    logger.info(`安装成功！`);
+    const bridge = new DebugBridge()
+    logger.info("开始安装应用")
+    await bridge.install(pkgPath, manifest["package"])
+    logger.info("\n")
+    logger.info(`安装成功！`)
     logger.info(
       `👉 请在浏览器中访问 https://${manifest["application"]["subdomain"]}.${shellapi.boxname}.heiyu.space`
-    );
+    )
   }
 }

package/lib/appstore/index.js

@@ -1,7 +1,7 @@
-import { Publish } from "./publish.js";
-import { PrePublish } from "./prePublish.js";
-import { reLogin } from "./login.js";
-import fs from "node:fs";
+import { Publish } from "./publish.js"
+import { PrePublish } from "./prePublish.js"
+import { reLogin } from "./login.js"
+import fs from "node:fs"
 
 export function appstoreCommand(program) {
   let subCommands = [
@@ -9,8 +9,8 @@ export function appstoreCommand(program) {
       command: "login",
       desc: "登录",
       handler: async () => {
-        await reLogin();
-      },
+        await reLogin()
+      }
     },
     {
       command: "pre-publish <pkgPath>",
@@ -19,26 +19,26 @@ export function appstoreCommand(program) {
         args.option("c", {
           alias: "changelog",
           describe: "更改日志",
-          type: "string",
-        });
+          type: "string"
+        })
         args.option("F", {
           alias: "file",
           describe: "更改日志文件",
-          type: "string",
-        });
+          type: "string"
+        })
         args.option("G", {
           alias: "gid",
           describe: "内测组ID",
-          type: "string",
-        });
+          type: "string"
+        })
       },
       handler: async ({ pkgPath, changelog, file, gid }) => {
-        const p = new PrePublish();
+        const p = new PrePublish()
         if (!changelog && file) {
-          changelog = fs.readFileSync(file, "utf8");
+          changelog = fs.readFileSync(file, "utf8")
         }
-        await p.publish(pkgPath, changelog, gid);
-      },
+        await p.publish(pkgPath, changelog, gid)
+      }
     },
     {
       command: "publish <pkgPath>",
@@ -47,29 +47,29 @@ export function appstoreCommand(program) {
         args.option("c", {
           alias: "changelog",
           describe: "更改日志",
-          type: "string",
-        });
+          type: "string"
+        })
         args.option("F", {
           alias: "file",
           describe: "更改日志文件",
-          type: "string",
-        });
+          type: "string"
+        })
       },
       handler: async ({ pkgPath, changelog, file }) => {
-        const p = new Publish();
+        const p = new Publish()
         if (!changelog && file) {
-          changelog = fs.readFileSync(file, "utf8");
+          changelog = fs.readFileSync(file, "utf8")
         }
-        await p.publish(pkgPath, changelog);
-      },
-    },
-  ];
+        await p.publish(pkgPath, changelog)
+      }
+    }
+  ]
 
   program.command({
     command: "appstore",
     desc: "应用商店",
     builder: (args) => {
-      args.command(subCommands);
-    },
-  });
+      args.command(subCommands)
+    }
+  })
 }

package/lib/appstore/login.js

@@ -1,145 +1,145 @@
-import fetch from "node-fetch";
-import path from "path";
-import logger from "loglevel";
-import env from "../env.js";
-import inquirer from "inquirer";
-import FormData from "form-data";
+import fetch from "node-fetch"
+import path from "path"
+import logger from "loglevel"
+import env from "../env.js"
+import inquirer from "inquirer"
+import FormData from "form-data"
 
-const accountServerUrl = "https://account.lazycat.cloud";
+const accountServerUrl = "https://account.lazycat.cloud"
 
 function join(...params) {
-  var x = path.join(...params);
-  return x;
+  var x = path.join(...params)
+  return x
 }
 
 function login(username, password) {
-  const form = new FormData();
-  form.append("username", username);
-  form.append("password", password);
+  const form = new FormData()
+  form.append("username", username)
+  form.append("password", password)
 
   return fetch(join(accountServerUrl, "/api/login/signin"), {
     method: "POST",
     headers: {
-      "content-type": `multipart/form-data; boundary=${form.getBoundary()}`,
+      "content-type": `multipart/form-data; boundary=${form.getBoundary()}`
     },
-    body: form,
+    body: form
   })
     .then(async (res) => {
-      let bodyText = await res.text();
-      let body = JSON.parse(bodyText);
+      let bodyText = await res.text()
+      let body = JSON.parse(bodyText)
       if (body.success) {
-        return Promise.resolve(body.data);
+        return Promise.resolve(body.data)
       }
-      return Promise.reject(body.message);
+      return Promise.reject(body.message)
     })
     .then((data) => {
-      env.set({ token: data.token }, true);
-      logger.info("登录成功!");
-    });
+      env.set({ token: data.token }, true)
+      logger.info("登录成功!")
+    })
 }
 
 async function isLogin() {
   try {
-    let token = env.get("token");
+    let token = env.get("token")
     if (!token) {
-      return false;
+      return false
     }
     return fetch(join(accountServerUrl, "/api/user/current"), {
       method: "GET",
       headers: {
-        "X-User-Token": token,
-      },
+        "X-User-Token": token
+      }
     }).then(async (res) => {
-      let bodyText = await res.text();
-      let body = JSON.parse(bodyText);
+      let bodyText = await res.text()
+      let body = JSON.parse(bodyText)
       if (body.success) {
-        return token;
+        return token
       }
-      logger.debug(body.message);
-      return false;
-    });
+      logger.debug(body.message)
+      return false
+    })
   } catch (e) {
-    logger.trace(e);
-    return false;
+    logger.trace(e)
+    return false
   }
 }
 
 async function askUserInfo() {
-  const noEmpty = (value) => value != "";
+  const noEmpty = (value) => value != ""
   return await inquirer.prompt([
     {
       type: "input",
       name: "username",
       message: "请输入登录用户名",
-      validate: noEmpty,
+      validate: noEmpty
     },
     {
       type: "password",
       mask: "*",
       name: "password",
       message: "请输入登录密码",
-      validate: noEmpty,
-    },
-  ]);
+      validate: noEmpty
+    }
+  ])
 }
 
 async function interactiveLogin() {
   try {
-    let info = await askUserInfo();
-    await login(info.username, info.password);
+    let info = await askUserInfo()
+    await login(info.username, info.password)
   } catch (e) {
-    logger.debug("login error: ", e);
-    logger.info("帐号或者密码错误，请重新输入!");
-    return interactiveLogin();
+    logger.debug("login error: ", e)
+    logger.info("帐号或者密码错误，请重新输入!")
+    return interactiveLogin()
   }
 }
 
 export async function reLogin() {
-  let token = await isLogin();
+  let token = await isLogin()
   if (token) {
     const questions = [
       {
         name: "relogin",
         type: "input",
         default: "n",
-        message: "检测到已经登录，是否重新登录(y/n):",
-      },
-    ];
-    const answers = await inquirer.prompt(questions);
+        message: "检测到已经登录，是否重新登录(y/n):"
+      }
+    ]
+    const answers = await inquirer.prompt(questions)
     if (answers.relogin.toLowerCase() === "n") {
-      logger.info(`token: ${token}`);
-      return;
+      logger.info(`token: ${token}`)
+      return
     }
   }
-  await interactiveLogin();
+  await interactiveLogin()
 }
 
 export async function autoLogin() {
-  let token = await isLogin();
+  let token = await isLogin()
   if (token) {
-    logger.debug("appstore 已经登录");
-    return;
+    logger.debug("appstore 已经登录")
+    return
   }
 
-  logger.debug("token错误，尝试自动登录");
-  await interactiveLogin();
+  logger.debug("token错误，尝试自动登录")
+  await interactiveLogin()
 }
 
 export async function request(url, options = {}) {
-  await autoLogin();
+  await autoLogin()
 
-  const token = env.get("token");
+  const token = env.get("token")
 
   let headers = {
     "X-User-Token": token,
-    cookie: `userToken=${token}`,
-  };
+    cookie: `userToken=${token}`
+  }
   if (options.headers) {
-    headers = Object.assign({}, options.headers, headers);
+    headers = Object.assign({}, options.headers, headers)
   }
 
-  options = Object.assign({}, options, { headers });
-  logger.trace(`fetch ${url}`, options);
+  options = Object.assign({}, options, { headers })
+  logger.trace(`fetch ${url}`, options)
 
-  return fetch(url, options);
+  return fetch(url, options)
 }