@lazycatcloud/lzc-cli 1.1.12 → 1.2.0

package/lib/box/api/empty.js

@@ -1,35 +0,0 @@
-/* eslint-disable */
-import _m0 from "protobufjs/minimal.js";
-function createBaseEmpty() {
-  return {};
-}
-export const Empty = {
-  encode(_, writer = _m0.Writer.create()) {
-    return writer;
-  },
-  decode(input, length) {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseEmpty();
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        default:
-          reader.skipType(tag & 7);
-          break;
-      }
-    }
-    return message;
-  },
-  fromJSON(_) {
-    return {};
-  },
-  toJSON(_) {
-    const obj = {};
-    return obj;
-  },
-  fromPartial(_) {
-    const message = createBaseEmpty();
-    return message;
-  },
-};

package/lib/box/check_qemu.js

@@ -1,51 +0,0 @@
-// 检测当前系统是否安装 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;
-      }
-    }
-    return this;
-  }
-}

package/lib/box/qemu_vm_mgr.js

@@ -1,608 +0,0 @@
-#!/bin/node
-import fs from "node:fs";
-import { spawn, spawnSync } from "node:child_process";
-import path from "node:path";
-import inquirer from "inquirer";
-import process from "node:process";
-import net from "node:net";
-import fetch from "node-fetch";
-import os from "node:os";
-import logger from "loglevel";
-import glob from "fast-glob";
-import env from "../env.js";
-
-import { Downloader, envsubstrDefault, contextDirname } from "../utils.js";
-import { ShellCoreClientImpl, GrpcWebImpl } from "./api/clientapi.js";
-
-const cc = new ShellCoreClientImpl(
-  new GrpcWebImpl("http://127.0.0.1:30553", {})
-);
-
-const remoteBox = "远程盒子";
-const unRegistry = "未注册";
-
-function getBoxStatus(status) {
-  switch (status) {
-    case 0:
-      return "未激活";
-    case 1:
-      return "连接中";
-    case 2:
-      return "已连接";
-    case 3:
-      return "无法连接";
-  }
-}
-
-async function getFreePort() {
-  return new Promise((resolve, reject) => {
-    const server = net.createServer();
-    server.listen(() => {
-      let addr = server.address();
-      resolve(addr.port);
-      server.close();
-    });
-    server.on("error", reject);
-  });
-}
-
-function parseVmPID(vmDir) {
-  let p = spawnSync("pgrep", ["-f", path.join(vmDir, "disk-system.qcow2")]);
-  if (p.status == 0) {
-    return p.stdout.toString();
-  } else {
-    // 没有找到任何记录
-    return "";
-  }
-}
-
-function isDefault(boxName) {
-  const defaultBoxName = env.get("DEFAULT_BOXNAME");
-  return boxName == defaultBoxName ? "yes" : "no";
-}
-
-function isRunning(vmname) {
-  return parseVmPID(vmname) ? "running" : "stop";
-}
-
-export class QemuResource {
-  /**
-   * diskDir qemu 磁盘存储路径，默认 ~/.cache/box-emulator
-   * downloadUrl system-disk 下载路径
-   */
-  constructor(
-    diskDir = "~/.cache/box-emulator",
-    downloadUrl = "https://dl.lazycat.cloud/sdk"
-  ) {
-    this.diskDir = diskDir;
-
-    this.downloadUrlRoot = downloadUrl;
-    this.downloadUrl = undefined;
-
-    this.downloader = new Downloader();
-  }
-
-  async init() {
-    // fetch 最新的稳定版
-    const res = await fetch(`${this.downloadUrlRoot}/vm/index.json`);
-    if (res.status !== 200) {
-      throw "获取最新的版本信息出错";
-    }
-    const body = await res.json();
-    const version = body["stable-latest"];
-    this.downloadUrl = `${this.downloadUrlRoot}/vm/${version}`;
-
-    fs.mkdirSync(this.diskDir, { recursive: true });
-    let { update, force } = await this.shouldUpdate();
-    if (!force && update) {
-      let answer = await inquirer.prompt([
-        {
-          type: "confirm",
-          name: "yesorno",
-          message: `检测到盒子系统具有更新，是否需要重新下载盒子系统镜像？`,
-          default: true,
-        },
-      ]);
-      if (!answer.yesorno) {
-        update = false;
-      }
-    }
-    await this.ensureSystemDisk(update);
-    return this;
-  }
-
-  /**
-   * 根据下载到的 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 { update: true, force: true };
-    }
-
-    // 拉取最新的 md5
-    let newMd5;
-    try {
-      let url = `${this.downloadUrl}/disk-system.qcow2.md5`;
-      let res = await fetch(url);
-      if (res.status !== 200) {
-        return { update: false };
-      }
-      newMd5 = await res.text();
-    } catch {
-      return { update: false };
-    }
-
-    let oldMd5 = fs.readFileSync(oldMd5Path, { encoding: "utf-8" });
-    return { update: oldMd5 !== newMd5 };
-  }
-
-  /**
-   * 确保 qemu 系统盘的镜像存在，如果不存在，将会从 downloadUrl 中下载
-   */
-  async ensureSystemDisk(update = false) {
-    let systemDiskFile = path.join(this.diskDir, "disk-system.qcow2");
-    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.downloadUrlRoot}/${name}`;
-    await this.downloader.download(url, savePath);
-  }
-
-  async downloadSystemDiskMd5() {
-    let savePath = path.join(this.diskDir, "disk-system.qcow2.md5");
-    let url = `${this.downloadUrl}/disk-system.qcow2.md5`;
-    await this.downloader.download(url, savePath);
-  }
-
-  async downloadSystemDisk() {
-    let savePath = path.join(this.diskDir, "disk-system.qcow2");
-    let url = `${this.downloadUrl}/disk-system.qcow2.gz`;
-    await this.downloader.download(url, savePath, true);
-  }
-
-  async downloadPrivateKey() {
-    let savePath = path.join(this.diskDir, "id_rsa");
-    let url = `${this.downloadUrl}/id_rsa`;
-    await this.downloader.download(url, savePath);
-    fs.chmodSync(savePath, 0o400);
-    return;
-  }
-}
-
-export class QemuVM {
-  /**
-   * @param {Object} scheme - 各个操作系统的配置文件.
-   */
-  constructor() {
-    this.scheme = undefined;
-  }
-
-  async init() {
-    let defaultSchemeFile = path.resolve(
-      contextDirname(import.meta.url),
-      "schemes",
-      "vm_box_system_debian.json"
-    );
-    const content = await envsubstrDefault(
-      fs.readFileSync(defaultSchemeFile, "utf8"),
-      process.env
-    );
-    let scheme = JSON.parse(content);
-    if (scheme.path && !scheme.path.startsWith("/")) {
-      scheme.path = path.resolve(scheme.path);
-    }
-    fs.mkdirSync(scheme.path, { recursive: true });
-
-    this.scheme = scheme;
-    return this;
-  }
-
-  /**
-   * 运行虚拟盒子，并等待 boxid 的出现，确保盒子启动正常
-   */
-  async startVM(vmname) {
-    let args = await this.buildQemuArgs(vmname);
-    let p = spawn("qemu-system-x86_64", args, {
-      detached: true,
-      stdio: ["pipe", "ignore", "inherit"],
-    });
-    p.on("error", (e) => {
-      throw e;
-    });
-    logger.info("启动中...");
-
-    // 需要等待 boxid 的出现
-    return new Promise((resolve, reject) => {
-      let count = 0;
-      let id = setInterval(() => {
-        if (count == 15) {
-          count = 0;
-        }
-        process.stdout.write("\r");
-        process.stdout.write("等待中" + ".".repeat(count));
-        count++;
-
-        if (p.exitCode) {
-          reject(`qemu 已经退出 Code: ${p.exitCode}`);
-          clearInterval(id);
-          return;
-        }
-
-        let boxId = this.readBoxid(vmname);
-        if (boxId) {
-          clearInterval(id);
-          p.unref();
-          resolve(boxId);
-          logger.debug("启动成功!");
-        }
-      }, 1000);
-
-      // 当在等待期间，ctrl-c 退出
-      process.on("SIGINT", () => {
-        p.kill();
-        clearInterval(id);
-        reject("exit");
-      });
-    });
-  }
-
-  /**
-   * 运行一个指定的虚拟机，如果已经运行，将直接退出。如果盒子不存在，将报错退出
-   * @param {string} name - 盒子的名称
-   * @return {string} id - 盒子的id
-   **/
-  async runVM(nameOrBoxId) {
-    const { vmname, name, id } = await this.findVmname(nameOrBoxId);
-    if (!vmname) {
-      logger.info(`${name || id} 盒子不存在，请通过 lzc-cli box create 创建`);
-      return;
-    }
-    let pid = parseVmPID(vmname);
-    if (pid) {
-      return id;
-    }
-    await this.startVM(vmname);
-    logger.info(`${name || id} 盒子启动成功！`);
-  }
-
-  /**
-   * 创建一个指定的虚拟机，并启动等待注册成功。
-   **/
-  async createVM(resourcer, name) {
-    const vmDir = this.ensureVmDir(name);
-    this.ensureVolumeDir(vmDir);
-    await this.buildDisks(vmDir);
-
-    let boxId = await this.startVM(path.basename(vmDir));
-    return boxId;
-  }
-
-  /**
-   * 根据虚拟机名称确保缓存文件夹存在，返回对应的虚拟机缓存文件夹
-   */
-  ensureVmDir(name) {
-    const vmDir = path.resolve(this.scheme.path, `vm-${name}`);
-    fs.mkdirSync(vmDir, { recursive: true });
-    return vmDir;
-  }
-
-  ensureVolumeDir(vmDir) {
-    for (let key in this.scheme.volume) {
-      let bindPath = `${vmDir}/volume-${key}`;
-      fs.mkdirSync(bindPath, { recursive: true });
-    }
-  }
-
-  /**
-   * 构建硬盘，从 scheme 中读取 disk 的配置信息，并构建。
-   */
-  async buildDisks(vmDir) {
-    for (const diskInfo of this.scheme.disks) {
-      let name = `disk-${diskInfo.id}.qcow2`;
-      let diskPath = path.join(vmDir, name);
-
-      try {
-        fs.accessSync(diskPath, fs.constants.F_OK);
-        continue;
-      } catch {}
-
-      if (diskInfo.system) {
-        await this.buildSystemDisk(name, diskPath, diskInfo);
-      } else {
-        await this.buildDataDisk(name, diskPath, diskInfo);
-      }
-    }
-  }
-
-  async buildSystemDisk(name, diskPath, diskInfo) {
-    logger.debug(`构建系统盘快照：${diskPath}`);
-    let baseImage = path.join(this.scheme.path, name);
-    return spawnSync(
-      "qemu-img",
-      ["create", "-f", "qcow2", "-b", baseImage, "-F", "qcow2", diskPath],
-      { stdio: "inherit" }
-    );
-  }
-
-  async buildDataDisk(name, diskPath, diskInfo) {
-    logger.debug(`构建数据盘：${diskPath}`);
-    return spawnSync(
-      "qemu-img",
-      ["create", "-f", "qcow2", diskPath, diskInfo.size],
-      { stdio: "inherit" }
-    );
-  }
-
-  /**
-   * 寻找默认可用的 bios 文件
-   */
-  findBIOS() {
-    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);
-        return file;
-      } catch {}
-    }
-
-    throw "找不到 ovmf 文件";
-  }
-
-  /**
-   * 构建 qemu 启动的参数
-   */
-  async buildQemuArgs(vmname) {
-    const vmDir = path.resolve(this.scheme.path, vmname);
-    let sshPort = await getFreePort();
-    let bios = this.findBIOS();
-    // prettier-ignore
-    let args = [
-      "-name", `${this.scheme.name}-${this.scheme.uuid}-${vmname}`,
-      "-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,
-      "-device", "piix3-usb-uhci",
-      "-vnc", `unix:${vmDir}/.vnc`,
-      "-monitor", `unix:${vmDir}/.monitor,server,nowait`,
-      "-serial", `unix:${vmDir}/.serial,server,nowait`,
-      "-parallel", `unix:${vmDir}/.parallel,server,nowait`,
-      "-netdev", `user,hostfwd=tcp::${sshPort}-:22,id=eth`,
-      "-device", "virtio-net-pci,netdev=eth",
-      "-chardev", "stdio,id=s1,signal=off",
-      "-device", "isa-serial,chardev=s1",
-    ]
-
-    this.scheme.disks.forEach((diskInfo, index) => {
-      let file = `file=${vmDir}/disk-${diskInfo.id}.qcow2,format=qcow2,index=${index},media=disk,if=virtio`;
-      args.push("-drive", file);
-    });
-
-    Object.keys(this.scheme.volume).forEach((key) => {
-      let volumePath = this.scheme.volume[key];
-      let bindPath = `${vmDir}/volume-${key}`;
-      args.push(
-        "-virtfs",
-        `local,path=${bindPath},mount_tag=id_2245023265ae4cf87d02c8b6,security_model=mapped-xattr,id=id_2245023265ae4cf87d02c8b6`
-      );
-    });
-
-    return args;
-  }
-
-  /**
-   * 停止虚拟盒子
-   */
-  async stopVM(nameOrBoxId) {
-    const { vmname, name, id } = await this.findVmname(nameOrBoxId);
-    let pid = parseVmPID(vmname);
-    if (pid) {
-      process.kill(pid);
-    }
-    logger.info(`${name || id} 盒子已停止`);
-  }
-
-  /**
-   * 清理盒子，用于注册失败或者在注册过程中用户手动中止的情况
-   */
-  async cleanVM(nameOrBoxId) {
-    const { vmname } = await this.findVmname(nameOrBoxId);
-    const vmDir = path.resolve(this.scheme.path, vmname);
-    try {
-      fs.accessSync(vmDir);
-    } catch {
-      return;
-    }
-    fs.rmSync(vmDir, { recursive: true, force: true });
-  }
-
-  async deleteVM(nameOrBoxId) {
-    const boxes = await this.listAllVM();
-    const box = boxes.find((b) => b.id == nameOrBoxId || b.name == nameOrBoxId);
-    if (!box) {
-      logger.info(`${nameOrBoxId} 盒子不存在`);
-      return;
-    }
-    if (box.status !== unRegistry) {
-      await cc.DelBox({ id: box.id });
-    }
-
-    if (box["vm status"] === remoteBox) {
-      return;
-    }
-
-    const { vmname, name, id } = box;
-    const vmDir = path.resolve(this.scheme.path, vmname);
-    let pid = parseVmPID(vmDir);
-    if (pid) {
-      await inquirer
-        .prompt([
-          {
-            type: "confirm",
-            name: "yesorno",
-            message: `${name || id} 正在运行中，是否停止？`,
-            default: false,
-          },
-        ])
-        .then(async (answer) => {
-          if (!answer.yesorno) {
-            return;
-          }
-          process.kill(pid);
-          logger.info(`${name || id} 盒子已停止`);
-        });
-    }
-
-    return inquirer
-      .prompt([
-        {
-          type: "confirm",
-          name: "yesorno",
-          message: `确定要删除 ${name || id} 盒子吗？`,
-          default: false,
-        },
-      ])
-      .then(async (answer) => {
-        if (!answer.yesorno) {
-          return;
-        }
-        fs.rmSync(vmDir, { recursive: true, force: true });
-      });
-  }
-
-  async listAllVM() {
-    const boxes = (await cc.QueryBoxList({})).boxes;
-    const entries = await this.loadBoxIdAndBoxName();
-
-    let result = [];
-    Object.keys(entries).forEach((vmname) => {
-      let info = entries[vmname];
-      const box = boxes.find((box) => box.boxId == info.id);
-      const status = box ? getBoxStatus(box.status) : unRegistry;
-      result.push({
-        ...info,
-        status,
-        default: isDefault(info.name),
-        "vm status": isRunning(vmname),
-      });
-    });
-
-    boxes.forEach((box) => {
-      let info = result.find((r) => r.id == box.boxId);
-      if (!info) {
-        result.push({
-          id: box.boxId,
-          name: box.boxName,
-          status: getBoxStatus(box.status),
-          default: isDefault(box.boxName),
-          "vm status": remoteBox,
-        });
-      }
-    });
-    return result;
-  }
-
-  /**
-   * 根据 scheme 中的 path 和 uuid 和 name 获取盒子的信息
-   */
-  async listVM(nameOrBoxId) {
-    let infos = await this.listAllVM();
-    if (nameOrBoxId) {
-      let info = infos.find(
-        (i) => i.name === nameOrBoxId || i.id === nameOrBoxId
-      );
-      if (info) {
-        infos = [info];
-      }
-    }
-
-    return infos.map((info) => {
-      delete info["vmname"];
-      return info;
-    });
-  }
-
-  /**
-   * 根据 scheme 中的 path 和 uuid 和 name 获取盒子的boxid
-   */
-  readBoxid(vmname) {
-    if (!this.scheme.volume["config"]) {
-      return "";
-    }
-
-    let vmDir = path.join(this.scheme.path, vmname);
-    let volumeDir = path.join(vmDir, `volume-config`);
-
-    try {
-      let boxid = fs.readFileSync(path.join(volumeDir, "box.id"), {
-        encoding: "utf8",
-      });
-      return boxid;
-    } catch {
-      return "";
-    }
-  }
-
-  async loadBoxIdAndBoxName() {
-    const files = await glob(
-      ["vm-*/volume-config/box.id", "vm-*/volume-config/box.name"],
-      {
-        cwd: this.scheme.path,
-        dot: false,
-      }
-    );
-    const result = {};
-    files.forEach((file) => {
-      const vmDir = file.split(path.sep)[0];
-      const type = path.extname(file).toLowerCase() === ".name" ? "name" : "id";
-      const value = fs.readFileSync(
-        path.resolve(this.scheme.path, file),
-        "utf8"
-      );
-      if (!result[vmDir]) {
-        result[vmDir] = { id: "", name: "", vmname: "" };
-      }
-      result[vmDir][type] = value;
-      result[vmDir]["vmname"] = vmDir;
-    });
-    return result;
-  }
-
-  async findVmname(nameOrBoxId) {
-    const entries = await this.loadBoxIdAndBoxName();
-    const vmname = Object.keys(entries).find((key) => {
-      const e = entries[key];
-      return e?.name === nameOrBoxId || e.id === nameOrBoxId;
-    });
-    if (!vmname) {
-      throw `${nameOrBoxId} 盒子不存在，请检查盒子名称或者ID是否正确`;
-    }
-
-    return entries[vmname];
-  }
-}