@lazycatcloud/lzc-cli 1.1.3 → 1.1.6

package/lib/archiver.js

@@ -94,54 +94,12 @@ class Archiver {
   }
 
   async finalize(zip = true) {
-    // await this._changeContent();
     if (zip) {
       return await archiveFolder(this.tmpDir);
     } else {
       return this.tmpDir;
     }
   }
-  //
-  //     permissions:
-  //     - lzcapis
-  // need REMOVE deprecated
-  async _changeContent() {
-    let base = new DockerCompose(path.join(this.tmpDir, "docker-compose.yml"));
-    base
-      .pipe((template) => {
-        const meta = template[META_MARK];
-        if (
-          meta &&
-          Array.isArray(meta["permissions"]) &&
-          meta["permissions"].includes("lzcapis")
-        ) {
-          template[META_MARK]["ingress"].push({
-            service: "lazycat-apis-sidecar",
-            port: 8888,
-            subdomain: env.get("APP_ID"),
-            path: "/lzcapis/",
-            auth: "oidc",
-            authcallback: "/lzcapis/oidc-callback",
-          });
-          template["services"]["lazycat-apis-sidecar"] = {
-            image: "registry.lazycat.cloud/lazycat-apis-sidecar",
-            pull_policy: "always",
-            // volumes_from: ["${APP_NAME}:rw"],
-            volumes: ["lzcapis-lzcapp:/lzcapp"],
-            command: [
-              "--client-id=${LAZYCAT_AUTH_OIDC_CLIENT_ID}",
-              "--client-secret=${LAZYCAT_AUTH_OIDC_CLIENT_SECRET}",
-              "--client-url=https://${LAZYCAT_APP_ORIGIN}/lzcapis/",
-              "--issuer=${LAZYCAT_AUTH_OIDC_ISSUER_URL}",
-              "--prefix=lzcapis",
-              "--fs-root=/lzcapp/documents",
-            ],
-          };
-          template["volumes"]["lzcapis-lzcapp"] = null;
-        }
-      })
-      .save();
-  }
 }
 
 export default Archiver;

package/lib/autologin.js

@@ -0,0 +1,84 @@
+import fetch from "node-fetch";
+
+// autologin.js 提供一个封装好的 fetch request 请求方法，通过这个中间件，可以不用考虑
+// auth:auto 所做的授权验证。
+let AutoLoginToken = "";
+let AutoLoginFailed = false;
+
+function fetchTokenAction(url) {
+  return fetch(url).then(async (res) => {
+    const body = await res.text();
+    const token = body.match(/name=\"token\" value=\"(.*?)\"/i)[1];
+    const action = body.match(/action=\"(.*?)\"/i)[1];
+
+    return { token, action };
+  });
+}
+
+function fetchTokenActionAndRedirect(dataToken, dataAction) {
+  return fetch(dataAction, {
+    method: "POST",
+    body: `token=${dataToken}`,
+    redirect: "follow",
+    headers: {
+      accept:
+        "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9",
+      "accept-language": "en-US,en;q=0.9,zh-CN;q=0.8,zh;q=0.7",
+      "content-type": "application/x-www-form-urlencoded",
+    },
+  }).then(async (res) => {
+    let body = await res.text();
+    const token = body.match(/name=\"token\" value=\"(.*?)\"/i)[1];
+    const action = body.match(/action=\"(.*?)\"/i)[1];
+    const redirect = body.match(/name=\"redirect\" value=\"(.*?)\"/i)[1];
+
+    return { token, action, redirect };
+  });
+}
+
+export async function request(url, options = {}) {
+  if (AutoLoginFailed) {
+    return fetch(url, options);
+  }
+
+  await tryAuthLogin(url);
+
+  if (!AutoLoginToken) {
+    return fetch(url, options);
+  }
+
+  let headers = { cookie: `HC-Auth-Token=${AutoLoginToken}` };
+  if (options.headers) {
+    headers = Object.assign({}, options.headers, headers);
+  }
+
+  options = Object.assign({}, options, { headers });
+  return fetch(url, options);
+}
+
+export async function tryAuthLogin(url) {
+  if (!url.startsWith("http")) {
+    url = "https://" + url;
+  }
+
+  try {
+    if (!AutoLoginToken) {
+      let _url = new URL(url);
+      let u = _url.host.split(".").reverse().slice(0, 3).reverse().join(".");
+
+      console.log(`${u} 尝试自动登录...`);
+
+      let data = await fetchTokenAction(`${_url.protocol}//${u}`);
+      let data2 = await fetchTokenActionAndRedirect(data.token, data.action);
+
+      AutoLoginToken = data2.token;
+      console.log(`自动登录成功！`);
+      return AutoLoginToken;
+    }
+  } catch (e) {
+    console.error(e);
+    console.log(`尝试自动登录失败，正在使用默认的登录方式...`);
+    AutoLoginFailed = true;
+    return "";
+  }
+}

package/lib/box/check_qemu.js

@@ -0,0 +1,50 @@
+// 检测当前系统是否安装 qemu 软件
+import commandExist from "command-exists";
+import chalk from "chalk";
+import os from "node:os";
+
+function linuxPlatform(pkg) {
+  let r = os.release();
+  if (r.search(/arch/gi) > -1) {
+    return `sudo pacman -S ${pkg}`;
+  } else if (r.search(/debian/gi) > -1) {
+    return `sudo apt install ${pkg}`;
+  } else {
+    return ``;
+  }
+}
+
+function platformPackage(pkg) {
+  let cmd = "";
+  switch (os.platform()) {
+    case "darwin":
+      cmd = `brew install ${pkg}`;
+      break;
+    case "linux":
+      cmd = linuxPlatform(pkg);
+      break;
+  }
+  return `${pkg}包没有发现，请先通过系统包管理器安装。\n${cmd}`;
+}
+
+export class CheckQemu {
+  constructor() {
+    this.commands = ["qemu-img", "qemu-system-x86_64"];
+  }
+
+  async init() {
+    for (let cmd of this.commands) {
+      if (!commandExist.sync(cmd)) {
+        let cmdErr = chalk.red(`${cmd} 命令没有发现`);
+        let pkgTips = chalk.blue(platformPackage("qemu"));
+        let tips = `${cmdErr}
+
+${pkgTips}
+
+查看更多信息 https://www.qemu.org/download/
+`;
+        throw tips;
+      }
+    }
+  }
+}

package/lib/box/hportal.js

@@ -1,4 +1,5 @@
 import fetch from "node-fetch";
+import logger from "loglevel";
 
 export class HportalManager {
   constructor(apiHost) {
@@ -58,11 +59,16 @@ export class HportalManager {
   async boxs(boxName, defaultBoxName = "") {
     let url = this.apiHost + "/admin/boxes";
 
-    let origin;
+    let origin = [];
     try {
       const resp = await fetch(url);
       if (resp.status == 200) {
         origin = await resp.json();
+      } else {
+        logger.debug(
+          `status: ${resp.status}, url: ${resp.url}, text: ${resp.statusText}`
+        );
+        return [];
       }
     } catch {
       return [];
@@ -101,6 +107,7 @@ export function showBoxInfo(vmInfos, rmInfos) {
 
   if (boxIds.length == 0) {
     console.log("没有找到任何盒子，创建一个吧!");
+    return;
   }
 
   let result = [];

package/lib/box/index.js

@@ -6,8 +6,10 @@ import { QemuVM, QemuResource } from "./qemu_vm_mgr.js";
 import { contextDirname } from "../utils.js";
 import env, { sdkEnv } from "../env.js";
 import { HportalManager, showBoxInfo } from "./hportal.js";
+import { CheckQemu } from "./check_qemu.js";
+import logger from "loglevel";
 
-async function initQemuVM() {
+async function initQemuVM(ensureResources = false) {
   let defaultSchemeFile = path.join(
     contextDirname(),
     "box",
@@ -24,9 +26,13 @@ async function initQemuVM() {
     scheme.path = path.join(contextDirname(), "box-emulator", scheme.path);
   }
 
-  // 使用本地网络 api 调试 new QemuResource(scheme.path, "http://127.0.0.1");
-  let resource = new QemuResource(scheme.path);
-  await resource.init();
+  fs.mkdirSync(scheme.path, { recursive: true });
+
+  if (ensureResources) {
+    // 使用本地网络 api 调试 new QemuResource(scheme.path, "http://127.0.0.1");
+    let resource = new QemuResource(scheme.path);
+    await resource.init();
+  }
 
   let m = new QemuVM(scheme);
   return m;
@@ -44,22 +50,36 @@ export function boxCommand(box) {
       command: "create",
       desc: "创建一个虚拟盒子，并注册运行",
       handler: async () => {
-        let m = await initQemuVM();
-        let { boxName, boxId, user, password } = await m.createVM();
+        let cq = new CheckQemu();
+        await cq.init();
+
+        let boxId;
+        let m = await initQemuVM(true);
+        let answer = await m.askBoxInfo();
+
+        try {
+          // 创建盒子阶段，如果出错，将直接删除所有的资源。
+          boxId = await m.createVM(answer);
+        } catch (error) {
+          logger.error(error);
+          await m.cleanVM(answer.boxName);
+          return;
+        }
+
         // 如果没有指定默认的盒子名称将会将第一个盒子作为默认的盒子
         let defaultBoxName = env.get("DEFAULT_BOXNAME");
         if (!defaultBoxName) {
           // 新创建的盒子在初始化的时候，盒子里面需要安装hc的组件，需要一点时间，
           // 所以这里并不对sdk url进行校验是否有效
-          await sdkEnv.setDefaultBoxName(boxName, false);
+          await sdkEnv.setDefaultBoxName(answer.boxName, false);
         }
 
         let h = await initHportal();
-        console.log("添加盒子到 Hportal ......");
-        await h.addBox(boxName);
-        console.log("正在使用管理员帐号密码登录中......");
-        await h.loginBox(boxId, user, password);
-        console.log("登录成功！");
+        logger.debug("添加盒子到 Hportal ......");
+        await h.addBox(answer.boxName);
+        logger.debug("正在使用管理员帐号密码登录中......");
+        await h.loginBox(boxId, answer.adminName, answer.adminPass);
+        logger.debug("登录成功！");
       },
     },
     {
@@ -69,7 +89,7 @@ export function boxCommand(box) {
         let m = await initQemuVM();
         let boxid = await m.runVM(boxName);
         if (boxid) {
-          console.log("盒子ID: ", boxid);
+          logger.info("盒子ID: ", boxid);
         }
       },
     },
@@ -107,8 +127,8 @@ export function boxCommand(box) {
         let rmInfos = await rm.boxs(boxName, defaultBoxName);
 
         // 过滤条件不满足
-        if (vmInfos.length == 0 && rmInfos == 0 && boxName != "") {
-          console.log(`${boxName} 盒子不存在`);
+        if (vmInfos.length == 0 && rmInfos == 0 && boxName) {
+          logger.info(`${boxName} 盒子不存在`);
           let allVmInfos = await m.infoVM("", defaultBoxName);
           let allRmInfos = await rm.boxs("", defaultBoxName);
           showBoxInfo(allVmInfos, allRmInfos);

package/lib/box/qemu_vm_mgr.js

@@ -5,9 +5,12 @@ import path from "node:path";
 import inquirer from "inquirer";
 import https from "node:https";
 import http from "node:http";
-import lz4 from "lz4";
 import process from "node:process";
 import net from "node:net";
+import fetch from "node-fetch";
+import zlib from "node:zlib";
+import os from "node:os";
+import logger from "loglevel";
 
 async function getFreePort() {
   return new Promise((resolve, reject) => {
@@ -37,8 +40,8 @@ export class QemuResource {
    * downloadUrl system-disk 下载路径
    */
   constructor(
-    diskDir = "~/.local/share/lazycat/box-emulator",
-    downloadUrl = "https://dl.lazycat.cloud/sdk/vm"
+    diskDir = "~/.cache/box-emulator",
+    downloadUrl = "https://dl.lazycat.cloud/sdk"
   ) {
     this.diskDir = diskDir;
     this.downloadUrl = downloadUrl;
@@ -46,32 +49,96 @@ export class QemuResource {
 
   async init() {
     fs.mkdirSync(this.diskDir, { recursive: true });
-    await this.ensureSystemDisk();
+    let shouldUpdate = await this.shouldUpdate();
+    if (shouldUpdate) {
+      let answer = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "yesorno",
+          message: `检测到盒子系统具有更新，是否需要重新下载盒子系统镜像？`,
+          default: true,
+        },
+      ]);
+      if (!answer.yesorno) {
+        shouldUpdate = false;
+      }
+    }
+    await this.ensureSystemDisk(shouldUpdate);
+  }
+
+  /**
+   * 根据下载到的 md5 和本地缓存的 md5 进行比较，如果不一样，则代表具有更新，
+   * 然后提示用户是否更新。
+   * 如果在获取 md5 的过程中，发生网络错误，则跳过更新检查。
+   * 目前的更新，只是使用 md5 来判断是否需要重新下载 md5, 并不会使用 md5 来判断所下载的数据是否正确。
+   */
+  async shouldUpdate() {
+    let oldMd5Path = path.join(this.diskDir, "disk-system.qcow2.md5");
+
+    // 如果不存在 md5 文件，直接返回需要更新
+    try {
+      fs.accessSync(oldMd5Path);
+    } catch {
+      return true;
+    }
+
+    // 拉取最新的 md5
+    let newMd5;
+    try {
+      let url = `${this.downloadUrl}/vm/disk-system.qcow2.md5`;
+      let res = await fetch(url);
+      if (res.status !== 200) {
+        return false;
+      }
+      newMd5 = await res.text();
+    } catch {
+      return false;
+    }
+
+    let oldMd5 = fs.readFileSync(oldMd5Path, { encoding: "utf-8" });
+    return oldMd5 !== newMd5;
   }
 
   /**
    * 确保 qemu 系统盘的镜像存在，如果不存在，将会从 downloadUrl 中下载
    */
-  async ensureSystemDisk() {
+  async ensureSystemDisk(update = false) {
     let systemDiskFile = path.join(this.diskDir, "disk-system.qcow2");
-    try {
-      fs.accessSync(systemDiskFile);
-      return;
-    } catch {}
+    if (!update) {
+      try {
+        fs.accessSync(systemDiskFile);
+        return;
+      } catch {}
+    }
 
+    await this.downloadOVMF();
     await this.downloadSystemDisk();
     await this.downloadPrivateKey();
+    await this.downloadSystemDiskMd5();
+  }
+
+  async downloadOVMF() {
+    let name = `${os.arch()}.OVMF.fd`;
+    let savePath = path.join(this.diskDir, name);
+    let url = `${this.downloadUrl}/${name}`;
+    await this.download(url, savePath);
+  }
+
+  async downloadSystemDiskMd5() {
+    let savePath = path.join(this.diskDir, "disk-system.qcow2.md5");
+    let url = `${this.downloadUrl}/vm/disk-system.qcow2.md5`;
+    await this.download(url, savePath);
   }
 
   async downloadSystemDisk() {
     let savePath = path.join(this.diskDir, "disk-system.qcow2");
-    let url = `${this.downloadUrl}/disk-system.qcow2.lz4`;
+    let url = `${this.downloadUrl}/vm/disk-system.qcow2.gz`;
     await this.download(url, savePath, true);
   }
 
   async downloadPrivateKey() {
     let savePath = path.join(this.diskDir, "id_rsa");
-    let url = `${this.downloadUrl}/id_rsa`;
+    let url = `${this.downloadUrl}/vm/id_rsa`;
     await this.download(url, savePath);
     fs.chmodSync(savePath, 0o400);
     return;
@@ -90,7 +157,7 @@ export class QemuResource {
     );
   }
 
-  download(url, savePath, enableLz4 = false) {
+  download(url, savePath, enableGzip = false) {
     let tmpPath = savePath + ".tmp";
     const options = new URL(url);
     let request = url.startsWith("https") ? https.request : http.request;
@@ -110,8 +177,8 @@ export class QemuResource {
         });
 
         let outputFile = fs.createWriteStream(tmpPath, { flags: "w+" });
-        if (enableLz4) {
-          let decoder = lz4.createDecoderStream();
+        if (enableGzip) {
+          let decoder = zlib.createUnzip();
           res.pipe(decoder).pipe(outputFile);
         } else {
           res.pipe(outputFile);
@@ -144,9 +211,12 @@ export class QemuVM {
     let args = await this.buildQemuArgs(name, vmDir);
     let p = spawn("qemu-system-x86_64", args, {
       detached: true,
-      stdio: ["ignore", "ignore", "inherit"],
+      stdio: ["pipe", "ignore", "inherit"],
     });
-    console.log("启动中...");
+    p.on("error", (e) => {
+      throw e;
+    });
+    logger.debug("启动中...");
 
     // 需要等待 boxid 的出现
     return new Promise((resolve, reject) => {
@@ -165,14 +235,21 @@ export class QemuVM {
           return;
         }
 
-        let boxid = this.readBoxid(name);
-        if (boxid) {
-          p.unref();
-          resolve(boxid);
+        let boxId = this.readBoxid(name);
+        if (boxId) {
           clearInterval(id);
-          console.log("启动成功!");
+          p.unref();
+          resolve(boxId);
+          logger.debug("启动成功!");
         }
       }, 1000);
+
+      // 当在等待期间，ctrl-c 退出
+      process.on("SIGINT", () => {
+        p.kill();
+        clearInterval(id);
+        reject("exit");
+      });
     });
   }
 
@@ -184,38 +261,35 @@ export class QemuVM {
   async runVM(name) {
     let boxid = this.readBoxid(name);
     if (!boxid) {
-      console.log(`${name} 盒子不存在，请通过 lzc-cli box create 创建`);
+      logger.info(`${name} 盒子不存在，请通过 lzc-cli box create 创建`);
       return;
     }
     let vmDir = path.join(this.scheme.path, `vm-${name}`);
     let pid = parseVmPID(vmDir);
     if (pid) {
-      console.log(`${name} 盒子已经启动`);
+      logger.info(`${name} 盒子已经启动`);
       return boxid;
     }
     await this.startVM(name, vmDir);
-    console.log(`${name} 盒子启动成功！`);
+    logger.info(`${name} 盒子启动成功！`);
   }
 
   /**
    * 创建一个指定的虚拟机，并启动等待注册成功。
    **/
-  async createVM() {
-    let answer = await this.askBoxInfo();
-
-    let vmDir = this.ensureVmDir(answer.boxName);
+  async createVM({ boxName, adminName, adminPass }) {
+    let vmDir = this.ensureVmDir(boxName);
     this.ensureVolumeDir(vmDir);
     await this.buildDisks(vmDir);
-    let boxId = await this.startVM(answer.boxName, vmDir);
-    console.log("盒子ID: ", boxId);
+    let boxId = await this.startVM(boxName, vmDir);
+    logger.info("盒子ID: ", boxId);
 
-    let boxName = await this.registerVM(boxId, answer);
-    return {
+    await this.registerVM(boxId, {
       boxName,
-      boxId,
-      user: answer.adminName,
-      password: answer.adminPass,
-    };
+      adminName,
+      adminPass,
+    });
+    return boxId;
   }
 
   /**
@@ -244,29 +318,20 @@ export class QemuVM {
         mask: "*",
         validate: noEmpty,
       },
-      {
-        type: "input",
-        name: "origin",
-        message: "注册服务器地址",
-        default: "origin.lazycat.cloud",
-      },
     ]);
   }
 
   /**
    * 调用 hportal client 进行注册
    **/
-  async registerVM(boxid, { boxName, adminName, adminPass, origin }) {
+  async registerVM(boxid, { boxName, adminName, adminPass }) {
     // prettier-ignore
-    spawnSync("sudo",[
-      "-S",
-      "home-portal-client",
+    spawnSync("home-portal-client",[
       "-setup", "-boxid", boxid,
       "-boxname", boxName,
       "-user", adminName,
       "-password", adminPass,
-      "-origin", origin,
-    ], {stdio: ["inherit", "inherit", "inherit"]})
+    ], {stdio: "inherit"})
     return boxName;
   }
 
@@ -308,7 +373,7 @@ export class QemuVM {
   }
 
   async buildSystemDisk(name, diskPath, diskInfo) {
-    console.log(`构建系统盘快照：${diskPath}`);
+    logger.debug(`构建系统盘快照：${diskPath}`);
     let baseImage = path.join(this.scheme.path, name);
     return spawnSync(
       "qemu-img",
@@ -318,7 +383,7 @@ export class QemuVM {
   }
 
   async buildDataDisk(name, diskPath, diskInfo) {
-    console.log(`构建数据盘：${diskPath}`);
+    logger.debug(`构建数据盘：${diskPath}`);
     return spawnSync(
       "qemu-img",
       ["create", "-f", "qcow2", diskPath, diskInfo.size],
@@ -330,7 +395,11 @@ export class QemuVM {
    * 寻找默认可用的 bios 文件
    */
   findBIOS() {
-    let includes = ["/usr/share/ovmf/x64/OVMF.fd", "/usr/share/ovmf/OVMF.fd"];
+    let includes = [
+      "/usr/share/ovmf/x64/OVMF.fd",
+      "/usr/share/ovmf/OVMF.fd",
+      path.join(this.scheme.path, `${os.arch()}.OVMF.fd`),
+    ];
     for (let file of includes) {
       try {
         fs.accessSync(file, fs.constants.F_OK);
@@ -350,7 +419,7 @@ export class QemuVM {
     // prettier-ignore
     let args = [
       "-name", `${this.scheme.name}-${this.scheme.uuid}-vm-${name}`,
-      "-machine", "pc,accel=kvm",
+      "-machine", "pc,accel=kvm,accel=kvf,accel=xen,accel=hax,accel=nvmm,accel=whpx,accel=tcg",
       "-m", `${this.scheme.memory}`,
       "-smp", "4,sockets=4,cores=1,threads=1",
       "-bios", bios,
@@ -391,19 +460,36 @@ export class QemuVM {
     if (pid) {
       process.kill(pid);
     }
-    console.log(`${name} 盒子已停止`);
+    logger.info(`${name} 盒子已停止`);
+  }
+
+  /**
+   * 清理盒子，用于注册失败或者在注册过程中用户手动中止的情况
+   */
+  async cleanVM(name) {
+    let vmDir = path.join(this.scheme.path, `vm-${name}`);
+
+    try {
+      fs.accessSync(vmDir);
+    } catch {
+      return;
+    }
+    fs.rmSync(vmDir, { recursive: true, force: true });
   }
 
   /**
    * 删除虚拟盒子
+   * @param {boolean} silence - 是否提示错误，如果被删除的盒子不存在
    */
-  async deleteVM(name) {
+  async deleteVM(name, silence = false) {
     let vmDir = path.join(this.scheme.path, `vm-${name}`);
 
     try {
       fs.accessSync(vmDir);
     } catch {
-      console.log(`${name} 盒子不存在或者该盒子为一个真实盒子`);
+      if (!silence) {
+        logger.warn(`${name} 盒子不存在或者该盒子为一个真实盒子`);
+      }
       return;
     }
 
@@ -423,7 +509,7 @@ export class QemuVM {
             return;
           }
           process.kill(pid);
-          console.log(`${name} 盒子已停止`);
+          logger.info(`${name} 盒子已停止`);
         });
     }