@lazycatcloud/lzc-cli 1.1.4 → 1.1.7

package/cmds/app.js

@@ -14,10 +14,6 @@ import BoxAPI from "../lib/api.js";
 import Archiver from "../lib/archiver.js";
 import Key from "../lib/key.js";
 
-import { debuglog } from "util";
-
-const debug = debuglog("cmd/app");
-
 // this set of api target box
 class App {
   constructor(context) {
@@ -113,7 +109,7 @@ class App {
     try {
       const out = await archiveFolder(dir);
       console.log(chalk.green("开始部署应用"));
-      await api.install(out.path);
+      await api.applyZip(out.path);
       await api.checkStatus();
 
       console.log(

package/cmds/dev.js

@@ -4,6 +4,9 @@ import chalk from "chalk";
 import Dev from "../lib/dev.js";
 import env, { sdkEnv } from "../lib/env.js";
 import BoxAPI from "../lib/api.js";
+import { dockerPullLzcAppsImage } from "../lib/sdk.js";
+import Key from "../lib/key.js";
+import logger from "loglevel";
 
 // this set of api target box
 class Develop {
@@ -24,8 +27,14 @@ class Develop {
   async devShell({ build }) {
     let appdev = new Dev(env.get("APP_ID"), this.appPath);
 
+    await sdkEnv.ensure();
+
+    // 确保 sdk 能通过公钥正常访问
+    await new Key().ensure(sdkEnv.sdkUrl);
+
     if (build) {
       appdev.reset();
+      await dockerPullLzcAppsImage(sdkEnv.sdkHostName);
     }
 
     // 当如果已经连接。直接连接ssh
@@ -40,16 +49,15 @@ class Develop {
 
     // 重新部署dev app container
     try {
-      await sdkEnv.ensure();
       const { APP_ID: appId } = await env.ensure([{ name: "APP_ID" }]);
 
-      console.debug(sdkEnv.sdkUrl);
+      logger.debug(sdkEnv.sdkUrl);
       const api = new BoxAPI(appId, sdkEnv.sdkUrl);
 
       let out = await appdev.fakeApp("shell");
 
-      console.debug("设置端口转发");
-      await api.install(out.path, { build: true });
+      logger.debug("设置端口转发");
+      await api.applyZip(out.path, { build: true });
       await api.checkStatus();
 
       await appdev.shell();

package/lib/api.js

@@ -1,7 +1,8 @@
-import fetch from "node-fetch";
 import ora from "ora";
 import chalk from "chalk";
 import fs from "fs";
+import { request } from "./autologin.js";
+
 //
 // sdk 提供的API
 export default class API {
@@ -9,13 +10,26 @@ 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()}`,
+      {
+        method: "POST",
+        body: fs.createReadStream(zipPath),
+      }
+    );
+    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) {
-    let searchParams = new URLSearchParams(params);
-    const resp = await fetch(
-      `${this.host}/api/v1/app/applyZip?${searchParams.toString()}`,
+    const resp = await request(
+      `${this.host}/api/v1/app/install`,
       {
         method: "POST",
         body: fs.createReadStream(zipPath),
@@ -28,13 +42,13 @@ export default class API {
   }
 
   async uninstall() {
-    return await fetch(`${this.host}/api/v1/app/uninstall?id=${this.appId}`, {
+    return await request(`${this.host}/api/v1/app/uninstall?id=${this.appId}`, {
       method: "DELETE",
     });
   }
 
   async status() {
-    const resp = await fetch(`${this.host}/api/v1/app/status?id=${this.appId}`);
+    const resp = await request(`${this.host}/api/v1/app/status?id=${this.appId}`);
     if (resp.status == 200) {
       const status = await resp.json();
       return status;
@@ -46,7 +60,7 @@ export default class API {
   }
 
   async postPublicKey(key) {
-    const resp = await fetch(`${this.host}/api/v1/register`, {
+    const resp = await request(`${this.host}/api/v1/register`, {
       method: "POST",
       body: key,
     });

package/lib/app/index.js

@@ -0,0 +1,92 @@
+import path from "node:path";
+import lpkCreate, { LpkManifest } from "./lpk_create.js";
+import { LpkBuild } from "./lpk_build.js";
+import { AppDevShell } from "./lpk_devshell.js";
+import { LpkInstaller } from "./lpk_installer.js";
+import fs from "node:fs";
+import { APP_FOLDER } from "../utils.js";
+
+export function lpkProjectCommand(program) {
+  let subCommands = [
+    {
+      command: "create <name>",
+      desc: "创建懒猫云应用",
+      handler: async ({ name }) => {
+        await lpkCreate({ name });
+      },
+    },
+    {
+      command: "build [context]",
+      desc: "构建",
+      builder: (args) => {
+        args.option("o", {
+          alias: "output",
+          describe: "输出文件夹",
+          type: "string",
+        });
+      },
+      handler: async ({ context, output }) => {
+        const lpk = new LpkBuild();
+        await lpk.init();
+        // 正常的打包逻辑不需要 devshell
+        lpk.onBeforeBuildPackage(async (options) => {
+          delete options["devshell"];
+          if (output) {
+            options["pkgout"] = output;
+          }
+          return options;
+        });
+        await lpk.exec();
+      },
+    },
+    {
+      command: "devshell [context]",
+      desc: "进入盒子的开发环境",
+      builder: (args) => {
+        args.option("b", {
+          alias: "build",
+          describe: "重新构建环境",
+          type: "boolean",
+          default: false,
+        });
+      },
+      handler: async ({ context, build }) => {
+        const app = new AppDevShell(context);
+        await app.init();
+        if (build) {
+          await app.shellWithBuild();
+        } else {
+          await app.shell();
+        }
+      },
+    },
+  ];
+  program.command({
+    command: "project",
+    desc: "项目管理",
+    builder: (args) => {
+      args.command(subCommands);
+    },
+  });
+}
+
+export function lpkAppCommand(program) {
+  let subCommands = [
+    {
+      command: "install <pkgPath>",
+      desc: "部署应用至设备",
+      handler: async ({ pkgPath }) => {
+        const installer = new LpkInstaller();
+        await installer.init();
+        await installer.install(pkgPath);
+      },
+    },
+  ];
+  program.command({
+    command: "app",
+    desc: "应用管理",
+    builder: (args) => {
+      args.command(subCommands);
+    },
+  });
+}

package/lib/app/lpk_build.js

@@ -0,0 +1,229 @@
+import tar from "tar";
+import path from "node:path";
+import fs from "node:fs";
+import logger from "loglevel";
+import {
+  loadFromYaml,
+  isDirExist,
+  isFileExist,
+  dumpToYaml,
+  envTemplateFile,
+} from "../utils.js";
+import { spawnSync } from "child_process";
+import { LpkManifest } from "./lpk_create.js";
+import archiver from "archiver";
+import yaml from "js-yaml";
+
+async function tarContentDir(from, to, cwd = "./") {
+  const dest = fs.createWriteStream(to);
+  tar
+    .c(
+      {
+        cwd: cwd,
+        filter: (filePath, stat) => {
+          logger.debug(`tar gz ${filePath}`);
+          return true;
+        },
+        sync: true,
+        portable: {
+          uid: 0,
+          gid: 0,
+        },
+      },
+      [from]
+    )
+    .pipe(dest);
+  logger.debug(`pack: ${dest.path}`);
+  return dest.path;
+}
+
+async function archiveFolderTo(appDir, out, format = "zip") {
+  return new Promise(async (resolve, reject) => {
+    if (!fs.existsSync(appDir)) {
+      reject(new Error(`${appDir} 文件夹不存在`));
+      return;
+    }
+
+    logger.debug("start archive app ...");
+    const output = fs.createWriteStream(out);
+    const archive = archiver(format);
+
+    archive.on("error", (e) => {
+      reject(e);
+      logger.error(e);
+    });
+    archive.on("end", () => {
+      resolve(output);
+    });
+    archive.pipe(output);
+
+    archive.directory(appDir, false);
+    archive.finalize();
+  });
+}
+
+async function fetchIconTo(options, cwd, destDir) {
+  if (!options["icon"]) {
+    logger.warn("图标icon 没有指定");
+    return;
+  }
+
+  let iconPath = options["icon"];
+  if (path.extname(iconPath) !== ".png") {
+    logger.warn("图标icon 不是一个 .png 文件");
+    return;
+  }
+
+  if (!path.isAbsolute(iconPath)) {
+    iconPath = path.resolve(cwd, iconPath);
+  }
+
+  if (!isFileExist(iconPath)) {
+    logger.warn(`图标icon ${iconPath} 不存在`);
+    return;
+  }
+
+  fs.copyFileSync(iconPath, path.join(destDir, "icon.png"));
+  return;
+}
+
+export class LpkBuild {
+  constructor(cwd) {
+    this.pwd = cwd ?? process.cwd();
+
+    this.optionsFilePath = path.join(this.pwd, "lzc-build.yml");
+    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;
+
+    this.beforeBuildPackageFn = [];
+    this.beforeDumpYamlFn = [];
+    this.beforeTarContentFn = [];
+    this.beforeDumpLpkFn = [fetchIconTo];
+  }
+
+  // init 时替换 lzc-build.yml 中的模板字段
+  async init() {
+    const manifest = await this.getManifest();
+    this.options = yaml.load(
+      await envTemplateFile(this.optionsFilePath, manifest)
+    );
+  }
+
+  // onBeforeDumpYaml
+  // fn: function(manifest, options) => manifest
+  onBeforeDumpYaml(fn) {
+    this.beforeDumpYamlFn.push(fn);
+  }
+  // onBeforeTarContent
+  // fn: function(contentdir) => void
+  onBeforeTarContent(fn) {
+    this.beforeTarContentFn.push(fn);
+  }
+  // onBeforeBuildPackage
+  // fn: function(options) => options
+  onBeforeBuildPackage(fn) {
+    this.beforeBuildPackageFn.push(fn);
+  }
+
+  // onBeforeDumpLpk
+  // fn: function(options, cwd, dir) => void
+  onBeforeDumpLpk(fn) {
+    this.beforeDumpLpkFn.push(fn);
+  }
+
+  async getManifest() {
+    if (this.manifest) {
+      return this.manifest;
+    }
+
+    let lpkM = new LpkManifest();
+    await lpkM.init(this.manifestFilePath);
+    this.manifest = lpkM.manifest;
+    return this.manifest;
+  }
+
+  async exec(prefix = "") {
+    if (this.beforeBuildPackageFn.length > 0) {
+      this.options = await this.beforeBuildPackageFn.reduce(
+        async (prev, curr) => {
+          return await curr(await prev);
+        },
+        this.options
+      );
+    }
+
+    if (this.options["buildscript"]) {
+      let p = spawnSync("sh", ["-c", this.options["buildscript"]], {
+        cwd: this.pwd,
+        stdio: "inherit",
+      });
+      if (p.status != 0) {
+        throw `构建失败`;
+      }
+    } else {
+      logger.warn("跳过执行 buildscript");
+    }
+
+    const pkgout = path.resolve(this.pwd, this.options["pkgout"]);
+    if (!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} 不存在`;
+      }
+    } 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}`);
+
+    // remove temp file
+    fs.rmSync(tempDir, { recursive: true });
+
+    return lpkPath.path;
+  }
+}

package/lib/app/lpk_create.js

@@ -0,0 +1,201 @@
+import logger from "loglevel";
+import inquirer from "inquirer";
+import {
+  contextDirname,
+  createTemplateFile,
+  loadFromYaml,
+  envTemplateFile,
+  ensureDir,
+  dumpToYaml,
+} from "../utils.js";
+import path from "node:path";
+import Generator, { TemplateConfig } from "../generator.js";
+import fs from "fs";
+import yaml from "js-yaml";
+let fsPromises = fs.promises;
+import { parse2CorrectName } from "../utils.js";
+
+export class LpkManifest {
+  constructor(defaultAppID) {
+    this.pwd = contextDirname(import.meta.url);
+    this.manifest = {};
+    this.defaultAppID = defaultAppID;
+  }
+
+  async init(manifestFilePath) {
+    if (manifestFilePath) {
+      this.manifest = loadFromYaml(manifestFilePath);
+    } else {
+      let templatePath = path.join(
+        this.pwd,
+        "../../template/_lpk/manifest.yml.in"
+      );
+      let answer = await this.askLpkInfo();
+      this.manifest = yaml.load(await envTemplateFile(templatePath, answer));
+    }
+  }
+
+  async create(outputDir) {
+    let outputFilePath = path.join(outputDir, "manifest.yml");
+    logger.info(`创建文件 ${outputFilePath}`);
+    ensureDir(outputFilePath);
+    return fsPromises
+      .access(outputFilePath, fs.constants.F_OK | fs.constants.W_OK)
+      .then(
+        async () => {
+          const questions = [
+            {
+              name: "override",
+              type: "input",
+              default: "n",
+              message: "manifest.yml已经存在，是否覆盖(y/n): ",
+            },
+          ];
+          const answers = await inquirer.prompt(questions);
+          if (answers.override.toLowerCase() === "y") {
+            return dumpToYaml(this.manifest, outputFilePath);
+          }
+        },
+        () => {
+          return dumpToYaml(this.manifest, outputFilePath);
+        }
+      );
+  }
+
+  async askLpkInfo() {
+    const noEmpty = (value) => value != "";
+    return await inquirer.prompt([
+      {
+        type: "input",
+        name: "package",
+        message: "请输入应用ID",
+        default: this.defaultAppID,
+        validate: noEmpty,
+      },
+      {
+        type: "input",
+        name: "version",
+        message: "请输入应用版本信息",
+        default: "0.0.1",
+        validate: noEmpty,
+      },
+      {
+        type: "input",
+        name: "subdomain",
+        message: "请输入应用子域名",
+        default: (answers) => {
+          return answers["package"].trim();
+        },
+        validate: (input) => {
+          if (!/^([a-z]|[0-9]|[\-])+$/.test(input)) {
+            return "应用名称只能包含(减号，小写字母，数字)，请重新输入";
+          }
+          return true;
+        },
+      },
+      {
+        type: "input",
+        name: "name",
+        message: "请输入应用名称",
+        default: (answers) => {
+          const p = answers["package"];
+          return `${p}-懒猫云`;
+        },
+        validate: noEmpty,
+      },
+      {
+        type: "input",
+        name: "description",
+        message: "应用简单的描述信息",
+      },
+      {
+        type: "input",
+        name: "homepage",
+        message: "应用主页地址",
+      },
+      {
+        type: "input",
+        name: "author",
+        message: "应用作者",
+      },
+    ]);
+  }
+}
+
+export class TemplateInit {
+  constructor(context) {
+    this.context = context;
+    this.type = context.type;
+  }
+
+  async create() {
+    if (!this.type) {
+      this.type = await chooseTemplate();
+    }
+    let lpkManifest = new LpkManifest(path.basename(this.context.cwd));
+    await lpkManifest.init();
+    await lpkManifest.create(this.context.cwd);
+  }
+}
+
+export async function chooseTemplate() {
+  return (
+    await inquirer.prompt([
+      {
+        name: "type",
+        message: "选择项目构建模板",
+        type: "list",
+        choices: ["vue", "golang", "ionic_vue3"],
+      },
+    ])
+  )["type"];
+}
+
+// 创建一个应用
+// - 先选择模板信息（vue, golang, vue3)
+// - 根据 lpk manifest 模板中所需要的字段填充manifest
+// - 将 .lazycat 生成（包含 manifest, 项目文件）
+// - 调用模板的hook
+class LpkCreate {
+  constructor({ name }) {
+    this.name = name;
+  }
+
+  async exec() {
+    const type = await chooseTemplate();
+    const template = new TemplateInit({
+      cwd: path.join(process.cwd(), this.name),
+      type: type,
+    });
+    if (TemplateConfig[type]) {
+      await template.create();
+      logger.info(`初始化项目 ${this.name}`);
+      await Generator().generate(type, this.name);
+      logger.info("设置懒猫云应用");
+      await TemplateConfig[type].after(this.name);
+    }
+  }
+}
+
+export default async (context) => {
+  context.name = parse2CorrectName(context.name);
+  await fsPromises.access(process.cwd() + "/" + context.name).then(
+    async () => {
+      const questions = [
+        {
+          name: "override",
+          type: "input",
+          default: "n",
+          message: "项目已存在，是否覆盖(y/n): ",
+        },
+      ];
+      const answers = await inquirer.prompt(questions);
+      if (answers.override.toLowerCase() === "y") {
+        return new LpkCreate(context).exec();
+      }
+    },
+    () => {
+      return new LpkCreate(context).exec();
+    }
+  );
+};