@lazycatcloud/lzc-cli 1.2.26 → 1.2.28

package/lib/app/apkshell.js

@@ -0,0 +1,37 @@
+import fs from "node:fs"
+import fetch from "node-fetch"
+import logger from "loglevel"
+
+export async function triggerApk(id, name, iconPath) {
+  if (!id) {
+    logger.error("Appid 为必填项!")
+    return
+  }
+  name = name || "懒猫应用"
+  try {
+    const form = new FormData()
+    form.append("app_id", id)
+    form.append("app_name", name)
+    if (iconPath) {
+      form.append("app_icon", new Blob([fs.readFileSync(iconPath)]))
+    }
+    const resp = await fetch(
+      "https://appstore.lazycat.cloud/api/trigger_latest_for_app",
+      {
+        method: "POST",
+        body: form
+      }
+    )
+    if (resp.status == 304) {
+      // 没有修改
+      logger.info(`APK构建任务已创建成功,如需使用安卓端,请耐心等待1分钟左右`)
+    } else if (resp.status == 201) {
+      logger.info(`APK构建任务已创建成功,如需使用安卓端,请耐心等待1分钟左右`)
+    } else if (resp.status >= 400) {
+      logger.debug("请求按钮应用出错:", resp)
+      throw "请求生成应用出错!"
+    }
+  } catch (error) {
+    logger.error(error)
+  }
+}

package/lib/app/index.js

@@ -1,12 +1,12 @@
-import path from "node:path";
-import lpkCreate from "./lpk_create.js";
-import { LpkBuild } from "./lpk_build.js";
-import { AppDevShell } from "./lpk_devshell.js";
-import { LpkInstaller } from "./lpk_installer.js";
-import logger from "loglevel";
-import { sleep } from "../utils.js";
-import { DebugBridge } from "./lpk_debug_bridge.js";
-import shellApi from "../shellapi.js";
+import path from "node:path"
+import lpkCreate from "./lpk_create.js"
+import { LpkBuild } from "./lpk_build.js"
+import { AppDevShell } from "./lpk_devshell.js"
+import { LpkInstaller } from "./lpk_installer.js"
+import logger from "loglevel"
+import { sleep } from "../utils.js"
+import { DebugBridge } from "./lpk_debug_bridge.js"
+import shellApi from "../shellapi.js"
 
 export function lpkProjectCommand(program) {
   let subCommands = [
@@ -14,10 +14,10 @@ export function lpkProjectCommand(program) {
       command: "create <name>",
       desc: "创建懒猫云应用",
       handler: async ({ name }) => {
-        await shellApi.init();
+        await shellApi.init()
 
-        await lpkCreate(name);
-      },
+        await lpkCreate(name)
+      }
     },
     {
       command: "build [context]",
@@ -26,28 +26,28 @@ export function lpkProjectCommand(program) {
         args.option("o", {
           alias: "output",
           describe: "输出文件",
-          type: "string",
-        });
+          type: "string"
+        })
         args.option("f", {
           alias: "file",
           describe: "指定构建的lzc-build.yml文件",
           default: "lzc-build.yml",
-          type: "string",
-        });
+          type: "string"
+        })
       },
       handler: async ({ context, output, file }) => {
-        const lpk = await new LpkBuild(context, file).init();
+        const lpk = await new LpkBuild(context, file).init()
         // 正常的打包逻辑不需要 devshell
         lpk.onBeforeBuildPackage(async (options) => {
-          delete options["devshell"];
+          delete options["devshell"]
 
           if (output) {
-            options["lpkPath"] = output;
+            options["lpkPath"] = output
           }
-          return options;
-        });
-        await lpk.exec();
-      },
+          return options
+        })
+        await lpk.exec()
+      }
     },
     {
       command: "devshell [context]",
@@ -56,50 +56,50 @@ export function lpkProjectCommand(program) {
         args.option("f", {
           alias: "force",
           describe: "强制重新构建",
-          type: "boolean",
-        });
+          type: "boolean"
+        })
         args.option("c", {
           alias: "config",
           describe: "devshell配置文件",
           type: "string",
-          default: "lzc-build.yml",
-        });
+          default: "lzc-build.yml"
+        })
         args.option("contentdir", {
           describe: "同时打包 lzc-build.yml 中指定的 contentdir 目录",
-          type: "boolean",
-        });
+          type: "boolean"
+        })
       },
       handler: async ({ context, force, config, contentdir }) => {
-        await shellApi.init();
+        await shellApi.init()
 
-        const cwd = context ? path.resolve(context) : process.cwd();
-        const lpkBuild = await new LpkBuild(cwd, config).init();
+        const cwd = context ? path.resolve(context) : process.cwd()
+        const lpkBuild = await new LpkBuild(cwd, config).init()
         lpkBuild.onBeforeBuildPackage(async (options) => {
           // devshell 正常情况下，不需要执行 buildscript 和 contentdir 字段
-          logger.debug("devshell delete 'buildscript' field");
-          delete options["buildscript"];
+          logger.debug("devshell delete 'buildscript' field")
+          delete options["buildscript"]
 
           if (!contentdir) {
-            logger.debug("devshell delete 'contentdir' field");
-            delete options["contentdir"];
+            logger.debug("devshell delete 'contentdir' field")
+            delete options["contentdir"]
           }
-          return options;
-        });
-        const app = new AppDevShell(cwd, lpkBuild, force, config);
-        await app.init();
-        await app.build();
-        await sleep(2000);
-        await app.rsyncShell();
-      },
-    },
-  ];
+          return options
+        })
+        const app = new AppDevShell(cwd, lpkBuild, force, config)
+        await app.init()
+        await app.build()
+        await sleep(2000)
+        await app.rsyncShell()
+      }
+    }
+  ]
   program.command({
     command: "project",
     desc: "项目管理",
     builder: (args) => {
-      args.command(subCommands);
-    },
-  });
+      args.command(subCommands)
+    }
+  })
 }
 
 export function lpkAppCommand(program) {
@@ -108,34 +108,34 @@ export function lpkAppCommand(program) {
       command: "install [pkgPath]",
       desc: "部署应用至设备, pkgPath 可以为路径，或者https://,http://请求地址, 如果不填写，将默认为当前目录下的lpk",
       handler: async ({ pkgPath }) => {
-        await shellApi.init();
+        await shellApi.init()
 
-        pkgPath = pkgPath ?? process.cwd();
-        const installer = new LpkInstaller();
-        await installer.init();
-        await installer.install(pkgPath);
-      },
+        pkgPath = pkgPath ?? process.cwd()
+        const installer = new LpkInstaller()
+        await installer.init()
+        await installer.install(pkgPath)
+      }
     },
     {
       command: "uninstall <pkgId>",
       desc: "从设备中卸载某一个应用",
       handler: async ({ pkgId }) => {
-        await shellApi.init();
+        await shellApi.init()
 
-        const bridge = new DebugBridge();
-        await bridge.uninstall(pkgId);
-      },
+        const bridge = new DebugBridge()
+        await bridge.uninstall(pkgId)
+      }
     },
     {
       command: "status <pkgId>",
       desc: "获取某一个应用的状态",
       handler: async ({ pkgId }) => {
-        await shellApi.init();
+        await shellApi.init()
 
-        const bridge = new DebugBridge();
-        const status = await bridge.status(pkgId);
-        console.log(status);
-      },
+        const bridge = new DebugBridge()
+        const status = await bridge.status(pkgId)
+        console.log(status)
+      }
     },
     {
       command: "log <pkgId>",
@@ -145,21 +145,21 @@ export function lpkAppCommand(program) {
           alias: "follow",
           describe: "持续输出",
           type: "boolean",
-          default: false,
-        });
+          default: false
+        })
       },
       handler: async () => {
-        await shellApi.init();
+        await shellApi.init()
 
-        throw "还没有实现";
-      },
-    },
-  ];
+        throw "还没有实现"
+      }
+    }
+  ]
   program.command({
     command: "app",
     desc: "应用管理",
     builder: async (args) => {
-      args.command(subCommands);
-    },
-  });
+      args.command(subCommands)
+    }
+  })
 }

package/lib/app/lpk_build.js

@@ -1,6 +1,6 @@
-import path from "node:path";
-import fs from "node:fs";
-import logger from "loglevel";
+import path from "node:path"
+import fs from "node:fs"
+import logger from "loglevel"
 import {
   loadFromYaml,
   isDirExist,
@@ -9,280 +9,276 @@ import {
   envTemplateFile,
   isValidPackageName,
   tarContentDir,
-  isPngWithFile,
-} from "../utils.js";
-import { spawnSync } from "child_process";
-import { LpkManifest } from "./lpk_create.js";
-import archiver from "archiver";
-import yaml from "js-yaml";
+  isPngWithFile
+} from "../utils.js"
+import { spawnSync } from "child_process"
+import { LpkManifest } from "./lpk_create.js"
+import archiver from "archiver"
+import yaml from "js-yaml"
 
-const isMacos = process.platform == "darwin";
+const isMacos = process.platform == "darwin"
 
 async function archiveFolderTo(appDir, out, format = "zip") {
   return new Promise(async (resolve, reject) => {
     if (!fs.existsSync(appDir)) {
-      reject(new Error(`${appDir} 文件夹不存在`));
-      return;
+      reject(new Error(`${appDir} 文件夹不存在`))
+      return
     }
 
-    logger.debug("start archive app ...");
-    const output = fs.createWriteStream(out);
-    const archive = archiver(format);
+    logger.debug("start archive app ...")
+    const output = fs.createWriteStream(out)
+    const archive = archiver(format)
 
     archive.on("error", (e) => {
-      reject(e);
-      logger.error(e);
-    });
+      reject(e)
+      logger.error(e)
+    })
     archive.on("end", () => {
-      resolve(output);
-    });
-    archive.pipe(output);
+      resolve(output)
+    })
+    archive.pipe(output)
 
-    archive.directory(appDir, false);
-    archive.finalize();
-  });
+    archive.directory(appDir, false)
+    archive.finalize()
+  })
 }
 
 async function fetchIconTo(options, cwd, destDir) {
   if (!options["icon"]) {
-    logger.warn("图标icon 没有指定");
-    return;
+    logger.warn("图标icon 没有指定")
+    return
   }
 
-  let iconPath = options["icon"];
+  let iconPath = options["icon"]
   if (path.extname(iconPath) !== ".png") {
-    logger.warn("图标icon 不是一个 .png 文件");
-    return;
+    logger.warn("图标icon 不是一个 .png 文件")
+    return
   }
 
   if (!path.isAbsolute(iconPath)) {
-    iconPath = path.resolve(cwd, iconPath);
+    iconPath = path.resolve(cwd, iconPath)
   }
 
   if (!isFileExist(iconPath)) {
-    logger.warn(`图标icon ${iconPath} 不存在`);
-    return;
+    logger.warn(`图标icon ${iconPath} 不存在`)
+    return
   }
 
   if (!isPngWithFile(iconPath)) {
-    logger.warn(`图标icon ${iconPath} 验证失败(不是一个png格式)`);
-    return;
+    logger.warn(`图标icon ${iconPath} 验证失败(不是一个png格式)`)
+    return
   } else {
-    logger.debug(`图标icon ${iconPath} 验证成功(png格式)`);
+    logger.debug(`图标icon ${iconPath} 验证成功(png格式)`)
   }
 
-  fs.copyFileSync(iconPath, path.join(destDir, "icon.png"));
-  return;
+  fs.copyFileSync(iconPath, path.join(destDir, "icon.png"))
+  return
 }
 
 // 提供一些方便的环境变量，可以在 lzc-build.yml 中直接使用
 // - LocalIP 本地局域网ip
 function localIp() {
-  const regex = /inet6 (fc03:1136:[0-9a-fA-F:]+)[?:\/ ]/;
+  const regex = /inet6 (fc03:1136:[0-9a-fA-F:]+)[?:\/ ]/
 
-  let output = "";
+  let output = ""
   if (isMacos) {
     const result = spawnSync("sh", ["-c", "ifconfig"], {
-      encoding: "utf-8",
-    });
+      encoding: "utf-8"
+    })
     if (result.status != 0 || result.error) {
-      logger.debug("macos get current ip is error", result.error);
-      return "";
+      logger.debug("macos get current ip is error", result.error)
+      return ""
     }
-    output = result.stdout;
+    output = result.stdout
   } else {
     const result = spawnSync("ip", ["addr", "show", "heiyu-0"], {
-      encoding: "utf-8",
-    });
+      encoding: "utf-8"
+    })
     if (result.status !== 0 || result.error) {
-      logger.debug("run ip addr show heiyu-0 failed", result.error);
-      return "";
+      logger.debug("run ip addr show heiyu-0 failed", result.error)
+      return ""
     }
-    output = result.stdout;
+    output = result.stdout
   }
-  const match = output.match(regex);
+  const match = output.match(regex)
   if (match) {
-    return `[${match[1]}]`;
+    return `[${match[1]}]`
   } else {
-    logger.debug("get LocalIP environment error", output.stderr);
-    return "";
+    logger.debug("get LocalIP environment error", output.stderr)
+    return ""
   }
 }
 function convenientEnv() {
   return Object.assign(
     {},
     {
-      LocalIP: localIp(),
+      LocalIP: localIp()
     },
     process.env
-  );
+  )
 }
 
 export class LpkBuild {
   constructor(cwd, buildConfigFile) {
-    this.pwd = cwd ?? process.cwd();
+    this.pwd = cwd ?? process.cwd()
 
-    this.optionsFilePath = path.join(this.pwd, buildConfigFile);
-    this.options = loadFromYaml(this.optionsFilePath);
+    this.optionsFilePath = path.join(this.pwd, buildConfigFile)
+    this.options = loadFromYaml(this.optionsFilePath)
 
     this.manifestFilePath = this.options["manifest"]
       ? path.join(this.pwd, this.options["manifest"])
-      : path.join(this.pwd, "lzc-manifest.yml");
-    this.manifest = null;
+      : path.join(this.pwd, "lzc-manifest.yml")
+    this.manifest = null
 
-    this.beforeBuildPackageFn = [];
-    this.beforeDumpYamlFn = [];
-    this.beforeTarContentFn = [];
-    this.beforeDumpLpkFn = [fetchIconTo];
+    this.beforeBuildPackageFn = []
+    this.beforeDumpYamlFn = []
+    this.beforeTarContentFn = []
+    this.beforeDumpLpkFn = [fetchIconTo]
   }
 
   // init 时替换 lzc-build.yml 中的模板字段
   async init() {
-    const manifest = await this.getManifest();
-    const primitive = convenientEnv();
+    const manifest = await this.getManifest()
+    const primitive = convenientEnv()
     this.options = yaml.load(
       await envTemplateFile(
         this.optionsFilePath,
         Object.assign({}, primitive, manifest)
       )
-    );
-    return this;
+    )
+    return this
   }
 
   // onBeforeDumpYaml
   // fn: function(manifest, options) => manifest
   onBeforeDumpYaml(fn) {
-    this.beforeDumpYamlFn.push(fn);
+    this.beforeDumpYamlFn.push(fn)
   }
   // onBeforeTarContent
   // fn: function(contentdir, options) => void
   onBeforeTarContent(fn) {
-    this.beforeTarContentFn.push(fn);
+    this.beforeTarContentFn.push(fn)
   }
   // onBeforeBuildPackage
   // fn: function(options) => options
   onBeforeBuildPackage(fn) {
-    this.beforeBuildPackageFn.push(fn);
+    this.beforeBuildPackageFn.push(fn)
   }
 
   // onBeforeDumpLpk
   // fn: function(options, cwd, dir) => void
   onBeforeDumpLpk(fn) {
-    this.beforeDumpLpkFn.push(fn);
+    this.beforeDumpLpkFn.push(fn)
   }
 
   async getManifest() {
     if (this.manifest) {
-      return this.manifest;
+      return this.manifest
     }
 
-    let lpkM = new LpkManifest();
-    await lpkM.init(this.manifestFilePath);
-    this.manifest = lpkM.manifest;
+    let lpkM = new LpkManifest()
+    await lpkM.init(this.manifestFilePath)
+    this.manifest = lpkM.manifest
 
     if (!isValidPackageName(this.manifest["package"])) {
-      throw `${this.manifest["package"]} 含有非法字符，请使用正确的包名格式(java的包名格式)，如：cloud.lazycat.apps.video`;
+      throw `${this.manifest["package"]} 含有非法字符，请使用正确的包名格式(java的包名格式)，如：cloud.lazycat.apps.video`
     }
-    return this.manifest;
+    return this.manifest
   }
 
   async exec() {
     if (this.beforeBuildPackageFn.length > 0) {
       this.options = await this.beforeBuildPackageFn.reduce(
         async (prev, curr) => {
-          return await curr(await prev);
+          return await curr(await prev)
         },
         this.options
-      );
+      )
     }
 
     if (this.options["buildscript"]) {
       let p = spawnSync("sh", ["-c", this.options["buildscript"]], {
         cwd: this.pwd,
-        stdio: "inherit",
-      });
+        stdio: "inherit"
+      })
       if (p.status != 0) {
-        throw `构建失败`;
+        throw `构建失败`
       }
     } else {
-      logger.warn("跳过执行 buildscript");
+      logger.warn("跳过执行 buildscript")
     }
 
     // 输出路径
-    let packName = this.options["lpkPath"];
-    const pkgout = path.resolve(this.pwd, this.options["pkgout"]);
+    let packName = this.options["lpkPath"]
+    const pkgout = path.resolve(this.pwd, this.options["pkgout"])
     if (!packName && !isDirExist(pkgout)) {
-      throw `${pkgout} 不存在`;
+      throw `${pkgout} 不存在`
     }
 
-    const tempDir = fs.mkdtempSync(".lzc-cli-build");
-    let contentdir = this.options["contentdir"];
+    const tempDir = fs.mkdtempSync(".lzc-cli-build")
+    let contentdir = this.options["contentdir"]
     try {
       if (contentdir) {
-        contentdir = path.resolve(this.pwd, contentdir);
+        contentdir = path.resolve(this.pwd, contentdir)
         if (!isDirExist(contentdir)) {
-          throw `${contentdir} 不存在`;
+          throw `${contentdir} 不存在`
         }
       } else {
-        logger.warn("跳过拷贝 contentdir 内容");
+        logger.warn("跳过拷贝 contentdir 内容")
         // 当没有指定的 contentdir 的时候，也生成一个空的文件夹
         // 原因是：可能其他地方会复制内容进来，像 devshell 中的会在打包的时候，将ssh key拷贝进来
-        contentdir = fs.mkdtempSync(path.join(tempDir, "fake-contentdir"));
+        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, this.options);
-          return _prev;
-        }, contentdir);
+          let _prev = await prev
+          await curr(_prev, this.options)
+          return _prev
+        }, contentdir)
       }
-      await tarContentDir(
-        ["./"],
-        path.join(tempDir, "content.tar"),
-        contentdir
-      );
+      await tarContentDir(["./"], path.join(tempDir, "content.tar"), contentdir)
 
       // 如果是临时的 contentdir, 目录在打包完成后删除
       if (!this.options["contentdir"]) {
-        fs.rmSync(contentdir, { recursive: true });
+        fs.rmSync(contentdir, { recursive: true })
       }
 
       // 开始生成 manifest.yml
-      let manifest = await this.getManifest();
+      let manifest = await this.getManifest()
       if (process.env.LZC_VERSION) {
-        manifest.version = 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);
+          return await curr(await prev, this.options)
+        }, manifest)
       }
-      logger.debug("manifest\n", manifest);
-      dumpToYaml(manifest, path.join(tempDir, "manifest.yml"));
+      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;
-        }, {});
+          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}`);
+      const lpkPath = await archiveFolderTo(tempDir, packName)
+      logger.info(`输出lpk包 ${lpkPath.path}`)
 
-      return lpkPath.path;
+      return lpkPath.path
     } finally {
-      fs.rmSync(tempDir, { recursive: true });
+      fs.rmSync(tempDir, { recursive: true })
     }
   }
 }