@lazycatcloud/lzc-cli 1.1.13 → 1.2.1

package/README.md

@@ -1,79 +1,47 @@
-# 懒猫云应用命令行工具
-```
-<command> [options]
-
-Commands:
-  lzc-cli box       盒子管理  lzc-cli app       应用管理  lzc-cli project   项目管理  lzc-cli appstore  应用商店
-Options:
-  -h, --help                                          [boolean] [default: false]
-      --version  Show version number                                   [boolean]
-      --log      log level 'trace', 'debug', 'info', 'warn', 'error'
-                                                      [string] [default: "info"]
-```
+# lzc-cli 指南
 
-## 安装
-```
-npm install -g @lazycatcloud/lzc-cli
-```
+#### 依赖
 
-## 虚拟盒子
+1. `ssh`
+2. `ssh-copy-id`
+3. `rsync`
 
-### 创建虚拟盒子
-```
-lzc-cli box create
-```
-将从 https://dl.lazycat.cloud 中下载最新的盒子系统数据，跟创建对应的 qemu 虚拟盒子。
+#### 快速上手
 
-### 启动盒子
-```
-lzc-cli box start <boxname>
-# lzc-cli box start mydemobox
+```bash
+npm install -g @lazycatcloud/lzc-cli
+# 将 lzc-cli 添加 bash/zsh 补全支持
+lzc-cli completion >> ~/.zshrc
 ```
-启动盒子成功后，就可以在 https://<mydemobox>.heiyu.space 中看到盒子的主页了。
 
-### 切换默认的盒子
-```
-lzc-cli box switch <otherBoxName>
-```
+下面开始使用 `lzc-cli` 去创建一个项目吧!
 
-### 查看本地的虚拟盒子信息
-```
-lzc-cli box info
-```
+```bash
+lzc-cli project create you_project
 
-## 应用管理
+# 构建懒猫云平台lpk包
+lzc-cli project build
 
-### 安装应用到盒子中去
+# 将lpk包安装到盒子中去
+lzc-cli app install
 
-- 从 https://repo.lazycat.cloud 中安装
-```
-lzc-cli app install https://repo.lazycat.cloud/pkgs/cloud.lazycat.app.kityminder/cloud.lazycat.app.kityminder-v1.0.3.lpk
-```
+# 使用 devshell 可以让你在盒子中开发调试
+lzc-cli project devshell
 
-- 从本地安装
-```
-lzc-cli app install ./kityminder.lpk
+# 经过测试后，将包发布到懒猫云商店中去
+lzc-cli appstore publish
 ```
 
-### 卸载应用
-```
-lzc-cli app uninstall cloud.lazycat.app.kityminder
-```
+### FAQ
 
-## 项目管理
+#### 1. 开发者工具 ssh 的帐号密码是多少？
 
-### 初始化懒猫云应用
-```
-lzc-cli project create yourappname
-```
+现在帐号密码设置为 box:box，后面会使用 pam 模块对接盒子帐号体系。
 
-### 构建 lpk 包
-```
-lzc-cli project build -o yourappname.lpk
-```
+#### 2. 如何切换默认的开发的盒子?
 
-### 盒子内开发
-```
-lzc-cli project devshell -b
-```
-`-b` 表示是否重新构建盒子中项目环境。
+目前不支持通过 lzc-cli 工具切换默认的盒子，所以你需要在 lzc-client-desktop 客户端上点击你要使用的盒子来切换。
+
+#### 3. 如果在盒子中构建镜像? 不想在本地构建
+
+现在已经把在盒子中构建镜像的功能去掉了，只能在本地或者其他地方构建好，然后指定 image 字段来选择你需要的开发环境。

package/lib/app/index.js

@@ -3,12 +3,10 @@ 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 { LpkUninstaller } from "./lpk_uninstall.js";
-import { LpkStatuser } from "./lpk_status.js";
-import { LpkLogger } from "./lpk_log.js";
 import logger from "loglevel";
-import fetch from "../fetch.js";
-import { sdkEnv } from "../env.js";
+import { sleep } from "../utils.js";
+import { DebugBridge } from "./lpk_debug_bridge.js";
+import shellApi from "../shellapi.js";
 
 export function lpkProjectCommand(program) {
   let subCommands = [
@@ -16,6 +14,8 @@ export function lpkProjectCommand(program) {
       command: "create <name>",
       desc: "创建懒猫云应用",
       handler: async ({ name }) => {
+        await shellApi.init();
+
         await lpkCreate(name);
       },
     },
@@ -35,6 +35,8 @@ export function lpkProjectCommand(program) {
         });
       },
       handler: async ({ context, output, file }) => {
+        await shellApi.init();
+
         const lpk = await new LpkBuild(context, file).init();
         // 正常的打包逻辑不需要 devshell
         lpk.onBeforeBuildPackage(async (options) => {
@@ -52,18 +54,6 @@ export function lpkProjectCommand(program) {
       command: "devshell [context]",
       desc: "进入盒子的开发环境",
       builder: (args) => {
-        args.option("r", {
-          alias: "rsync",
-          deprecate: true,
-          type: "boolean",
-          default: true,
-        });
-        args.option("s", {
-          alias: "shell",
-          describe: "指定你最喜欢的shell",
-          type: "string",
-          default: "bash",
-        });
         args.option("f", {
           alias: "force",
           describe: "强制重新构建",
@@ -80,7 +70,9 @@ export function lpkProjectCommand(program) {
           type: "boolean",
         });
       },
-      handler: async ({ context, shell, force, config, contentdir }) => {
+      handler: async ({ context, force, config, contentdir }) => {
+        await shellApi.init();
+
         const cwd = context ? path.resolve(context) : process.cwd();
         const lpkBuild = await new LpkBuild(cwd, config).init();
         lpkBuild.onBeforeBuildPackage(async (options) => {
@@ -94,11 +86,11 @@ export function lpkProjectCommand(program) {
           }
           return options;
         });
-        await fetch(`${sdkEnv.sdkUrl}/api/v1/ping`);
         const app = new AppDevShell(cwd, lpkBuild, force);
         await app.init();
         await app.build();
-        await app.rsyncShell(shell);
+        await sleep(2000);
+        await app.rsyncShell();
       },
     },
   ];
@@ -114,30 +106,36 @@ export function lpkProjectCommand(program) {
 export function lpkAppCommand(program) {
   let subCommands = [
     {
-      command: "install <pkgUrl>",
-      desc: "部署应用至设备, pkgUrl 可以为路径，或者https://,http://请求地址",
-      handler: async ({ pkgUrl }) => {
+      command: "install [pkgPath]",
+      desc: "部署应用至设备, pkgPath 可以为路径，或者https://,http://请求地址, 如果不填写，将默认为当前目录下的lpk",
+      handler: async ({ pkgPath }) => {
+        await shellApi.init();
+
+        pkgPath = pkgPath ?? process.cwd();
         const installer = new LpkInstaller();
         await installer.init();
-        await installer.install(pkgUrl);
+        await installer.install(pkgPath);
       },
     },
     {
       command: "uninstall <pkgId>",
       desc: "从设备中卸载某一个应用",
       handler: async ({ pkgId }) => {
-        const uninstaller = new LpkUninstaller();
-        await uninstaller.init();
-        await uninstaller.uninstall(pkgId);
+        await shellApi.init();
+
+        const bridge = new DebugBridge();
+        await bridge.uninstall(pkgId);
       },
     },
     {
       command: "status <pkgId>",
       desc: "获取某一个应用的状态",
       handler: async ({ pkgId }) => {
-        const statuser = new LpkStatuser();
-        await statuser.init();
-        await statuser.status(pkgId);
+        await shellApi.init();
+
+        const bridge = new DebugBridge();
+        const status = await bridge.status(pkgId);
+        console.log(status);
       },
     },
     {
@@ -151,17 +149,17 @@ export function lpkAppCommand(program) {
           default: false,
         });
       },
-      handler: async ({ pkgId, follow }) => {
-        const log = new LpkLogger();
-        await log.init();
-        await log.start(pkgId, follow);
+      handler: async () => {
+        await shellApi.init();
+
+        throw "还没有实现";
       },
     },
   ];
   program.command({
     command: "app",
     desc: "应用管理",
-    builder: (args) => {
+    builder: async (args) => {
       args.command(subCommands);
     },
   });

package/lib/app/lpk_debug_bridge.js

@@ -0,0 +1,101 @@
+import { spawn, spawnSync } from "child_process";
+import fs from "node:fs";
+import shellApi from "../shellapi.js";
+import inquirer from "inquirer";
+
+export class DebugBridge {
+  constructor() {
+    this.uid = shellApi.uid;
+    this.boxname = shellApi.boxname;
+    this.sshCmd = `ssh -p 22222 box@dev.${this.boxname}.heiyu.space`;
+  }
+
+  common(cmd, args) {
+    const ssh = spawnSync(cmd, args, {
+      shell: true,
+      encoding: "utf-8",
+      stdio: "pipe",
+    });
+    return new Promise((resolve, reject) => {
+      ssh.status == 0 ? resolve(ssh.stdout) : reject(ssh.stderr);
+    });
+  }
+
+  async install(lpkPath) {
+    if (!(await this.canPublicKey())) {
+      await this.sshCopyId();
+    }
+
+    const stream = fs.createReadStream(lpkPath);
+    const ssh = spawn(this.sshCmd, [`install --uid ${this.uid}`], {
+      shell: true,
+      stdio: ["pipe", "inherit", "inherit"],
+    });
+    stream.pipe(ssh.stdin);
+    return new Promise((resolve, reject) => {
+      ssh.on("close", (code) => {
+        code == 0 ? resolve() : reject("install 失败");
+      });
+    });
+  }
+
+  async canPublicKey() {
+    try {
+      await this.common(this.sshCmd, [`-o PasswordAuthentication=no`]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async sshCopyId() {
+    const questions = [
+      {
+        name: "upload",
+        type: "input",
+        default: "y",
+        message:
+          "检测到你目前使用的密码帐号登录，是否使用 ssh-copy-id 上传密钥 (y/n): ",
+      },
+    ];
+    const answers = await inquirer.prompt(questions);
+    if (answers.upload.toLowerCase() == "y") {
+      return this.common(`ssh-copy-id`, [
+        `-f -p 22222 box@dev.${this.boxname}.heiyu.space`,
+      ]);
+    }
+  }
+
+  async status(appId) {
+    return this.common(this.sshCmd, [`status --uid ${this.uid}`, appId]);
+  }
+
+  async isDevshell(appId) {
+    const stdout = await this.common(this.sshCmd, [`isDevshell`, appId]);
+    return stdout == "true";
+  }
+
+  async resume(appId) {
+    return this.common(this.sshCmd, [`resume --uid ${this.uid}`, appId]);
+  }
+
+  async uninstall(appId) {
+    return this.common(this.sshCmd, [`uninstall --uid ${this.uid}`, appId]);
+  }
+
+  async devshell(appId) {
+    const stream = spawn(
+      this.sshCmd,
+      ["-t", "devshell", appId, "/lzcapp/pkg/content/devshell/exec.sh"],
+      {
+        shell: true,
+        stdio: "inherit",
+      }
+    );
+    return new Promise((resolve, reject) => {
+      stream.on("close", (code) => {
+        code == 0 ? resolve() : reject();
+      });
+    });
+  }
+}

package/lib/app/lpk_devshell.js

@@ -3,7 +3,6 @@ import path from "node:path";
 import fs from "node:fs";
 import logger from "loglevel";
 import { execSync } from "node:child_process";
-import { LpkBuild } from "./lpk_build.js";
 import { LpkInstaller } from "./lpk_installer.js";
 import debounce from "lodash.debounce";
 import {
@@ -12,32 +11,18 @@ import {
   ensureDir,
   isFileExist,
   GitIgnore,
-  sleep,
   md5String,
   md5File,
-  createTemplateFileCommon,
   loadFromYaml,
   FileLocker,
 } from "../utils.js";
-import Key from "../key.js";
 import os from "node:os";
-import { sdkEnv } from "../env.js";
 import commandExists from "command-exists";
 import chokidar from "chokidar";
 import _ from "lodash";
-import BoxAPI from "../api.js";
-import { SdkDocker } from "./lpk_devshell_docker.js";
 import { getUidByManifest } from "../lzc_sdk.js";
-
-function sdkSSHHost() {
-  const sdkUrl = sdkEnv.sdkUrl;
-  let url = new URL(sdkUrl);
-  return `box@${url.hostname}`;
-}
-
-function sdkSSHPort() {
-  return 2222;
-}
+import { DebugBridge } from "./lpk_debug_bridge.js";
+import shellApi from "../shellapi.js";
 
 // 判断是否需要重新构建
 // - 先判断 lzc-build.yml 是否发生改变
@@ -46,11 +31,9 @@ function sdkSSHPort() {
 // - 根据 backend api 判断一个 appid 是否属于 running
 // - 根据在 backend api 中判断同步的目录下是否存在文件 判断当前运行的 app 是否已经有一个挂载的实例，避免重复挂载
 class AppDevShellMonitor {
-  constructor(cwd, pkgId, uid = "") {
+  constructor(cwd, pkgId) {
     this.pwd = cwd ? path.resolve(cwd) : process.cwd();
-
     this.pkgId = pkgId;
-    this.boxapi = new BoxAPI(pkgId, sdkEnv.sdkUrl, uid);
 
     this.optionsFilePath = path.join(this.pwd, "lzc-build.yml");
     this.options = loadFromYaml(this.optionsFilePath);
@@ -66,6 +49,7 @@ class AppDevShellMonitor {
     this.cacheFilePath = undefined;
     this.oldHash = undefined;
     this.newHash = undefined;
+    this.bridge = new DebugBridge();
   }
 
   async init() {
@@ -85,7 +69,9 @@ class AppDevShellMonitor {
 
   async shouldBuild() {
     return (
-      this.change() || (await this.notRunning()) || (await this.noDevshell())
+      this.change() ||
+      (await this.bridge.status(this.pkgId)) === "NotInstalled" ||
+      !(await this.bridge.isDevshell(this.pkgId))
     );
   }
 
@@ -113,19 +99,6 @@ class AppDevShellMonitor {
       fs.writeFileSync(this.cacheFilePath, JSON.stringify(this.newHash));
     }
   }
-
-  async notRunning() {
-    try {
-      const { status } = await this.boxapi.status();
-      return status !== "running";
-    } catch {
-      return true;
-    }
-  }
-
-  async noDevshell() {
-    return !(await this.boxapi.isDevshell());
-  }
 }
 
 export class AppDevShell {
@@ -155,11 +128,6 @@ export class AppDevShell {
   }
 
   async devshellBuild() {
-    // 确保 sdk key ，并上传到 sdk
-    const k = new Key();
-    await k.ensure(sdkEnv.sdkUrl);
-    const pairs = await k.getKeyPair();
-
     this.lpkBuild.onBeforeBuildPackage(async (options) => {
       const devshell = options["devshell"];
       if (!devshell) {
@@ -174,6 +142,30 @@ export class AppDevShell {
       return options;
     });
 
+    // 复制 busybox 到 devshell 中去
+    this.lpkBuild.onBeforeTarContent(async (contentdir) => {
+      const busyboxPath = path.join(
+        contextDirname(import.meta.url),
+        "../../template/_lpk/busybox-1.35.0"
+      );
+      let dest = path.join(contentdir, "devshell", "busybox");
+      ensureDir(dest);
+      fs.copyFileSync(busyboxPath, dest);
+      fs.chmodSync(dest, 0o775);
+    });
+
+    // 复制 init_debug_bridge.sh 到 devshell 中去
+    this.lpkBuild.onBeforeTarContent(async (contentdir) => {
+      const initPath = path.join(
+        contextDirname(import.meta.url),
+        "../../template/_lpk/init_debug_bridge.sh"
+      );
+      let dest = path.join(contentdir, "devshell", "init_debug_bridge.sh");
+      ensureDir(dest);
+      fs.copyFileSync(initPath, dest);
+      fs.chmodSync(dest, 0o775);
+    });
+
     // 复制 exec.sh 到 devshell 中去
     this.lpkBuild.onBeforeTarContent(async (contentdir) => {
       const execScriptPath = path.join(
@@ -186,15 +178,6 @@ export class AppDevShell {
       fs.chmodSync(dest, 0o775);
     });
 
-    // 用 sdk ssh key 并复制到 contentdir 目录
-    // docker 中 sshd 的配置中已改成 /lzcapp/pkg/content/devshell/authorized_keys
-    this.lpkBuild.onBeforeTarContent(async (contentdir) => {
-      let publicKey = pairs["public"];
-      let dest = path.join(contentdir, "devshell", "authorized_keys");
-      ensureDir(dest);
-      fs.copyFileSync(publicKey, dest);
-    });
-
     // 复制 setupscript 脚本
     this.lpkBuild.onBeforeTarContent(async (contentdir, options) => {
       const devshell = options["devshell"];
@@ -227,6 +210,13 @@ export class AppDevShell {
       const routes = devshell["routes"];
       logger.debug("options devshell delete 'routes' field");
       delete options["devshell"]["routes"];
+
+      // 添加 devshell 必要路由
+      routes.push(
+        "/__debug.bridge=exec://22222,/lzcapp/pkg/content/devshell/init_debug_bridge.sh"
+      );
+      routes.push("/__isdevshell=file:///lzcapp/pkg/devshell");
+
       // 如果 devshell 中的 router 和 manifest 中的 prefix 出现冲突
       // 优先使用 devshell 中的。
       routes.forEach((r) => {
@@ -274,32 +264,7 @@ export class AppDevShell {
         return manifest;
       }
 
-      const depsStr = deps.sort().join(" ");
-      logger.debug("开始创建 Dockerfile 文件");
-      const tag = `${await md5String(depsStr)}:latest`;
-
-      const tempDir = fs.mkdtempSync(".lzc-cli-build-dependencies");
-      try {
-        const dockerfilePath = path.join(
-          contextDirname(import.meta.url),
-          "../../template/_lpk/Dockerfile.in"
-        );
-        await createTemplateFileCommon(
-          dockerfilePath,
-          path.join(tempDir, "Dockerfile"),
-          { dependencies: depsStr }
-        );
-
-        logger.debug(`开始在盒子中构建 ${tag} 镜像 from ${tempDir}`);
-        const sdk = new SdkDocker();
-        await sdk.buildImage(tag, tempDir, tempDir);
-      } finally {
-        fs.rmSync(tempDir, { recursive: true });
-      }
-
-      delete manifest["application"]["devshell"];
-      manifest["application"]["image"] = tag;
-      return manifest;
+      throw "lzc-cli 不支持在盒子中构建 docker 镜像，请从其他地方构建，然后指定image字段";
     });
 
     // 如果 services 中有 devshell 的字段，需要检测是否需要提前构建
@@ -314,16 +279,7 @@ export class AppDevShell {
         return manifest;
       }
 
-      const tag = `${manifest["package"]}-devshell:${manifest["version"]}`;
-
-      logger.debug(`开始在盒子中构建 ${tag} 镜像`);
-
-      const sdk = new SdkDocker();
-      await sdk.buildImage(tag, config["build"], process.cwd());
-
-      delete manifest["application"]["devshell"];
-      manifest["application"]["image"] = tag;
-      return manifest;
+      throw "lzc-cli 不支持在盒子中构建 docker 镜像，请从其他地方构建，然后指定image字段";
     });
 
     // 如果 devshell 中指定了 image 字段将使用 image 字段
@@ -361,13 +317,9 @@ export class AppDevShell {
     let installer = new LpkInstaller();
     await installer.init();
     await installer.deploy(this.lpkBuild, true);
-
-    await sleep(2000);
   }
 
-  async rsyncShell(runShell) {
-    const k = new Key();
-    const pairs = await k.getKeyPair();
+  async rsyncShell() {
     const manifest = await this.lpkBuild.getManifest();
     const pkgId = manifest["package"];
 
@@ -386,7 +338,7 @@ export class AppDevShell {
     }
 
     const uid = await getUidByManifest(manifest);
-    const devshell = new DevShell(pairs["private"], pkgId, runShell, uid);
+    const devshell = new DevShell(pkgId, uid);
     if (isSync) {
       await devshell.shell();
     } else {
@@ -400,29 +352,22 @@ export class AppDevShell {
 }
 
 class DevShell {
-  constructor(keyFile, appId, runShell = "sh", uid = "") {
-    logger.debug("keyFile", keyFile);
-    logger.debug("appid", appId);
-
-    this.keyFile = keyFile;
+  constructor(appId, uid = "") {
     this.appId = appId;
     this.uid = uid;
-    this.runShell = runShell;
   }
 
-  async syncProject(keyFile, appId) {
-    const host = sdkSSHHost();
-    const port = sdkSSHPort();
+  async syncProject(appId) {
     // prettier-ignore
     let rsh = [
       "ssh",
-      "-p", `${port}`,
+      "-J", `box@dev.${shellApi.boxname}.heiyu.space:22222`,
+      "-p", `22222`,
       "-o", `"StrictHostKeyChecking=no"`,
       "-o", `"UserKnownHostsFile=/dev/null"`,
       "-o", `"ConnectionAttempts=3"`,
       "-o", `"ConnectTimeout=30"`,
       "-o", `"LogLevel=ERROR"`,
-      "-i", keyFile,
     ].join(" ");
     // 检查rsync工具是否存在:提示用户
     const rsyncExisted = commandExists.sync("rsync");
@@ -431,13 +376,11 @@ class DevShell {
       process.exit(1);
     }
 
-    let rsyncDebug = process.env.RSYNCDEBUG ? "-P" : "";
-    const userId = this.uid ? `/${this.uid}` : "";
-    let storePath = `/lzcsys/run/data/app/cache/${appId}${userId}/devshell`;
-    // FIXME: 下方执行命令不确定是否有兼容性问题
+    const rsyncDebug = process.env.RSYNCDEBUG ? "-P" : "";
+    const dest = `root@app.${appId}.lzcapp:/lzcapp/cache/devshell`;
     try {
       execSync(
-        `rsync ${rsyncDebug} --rsh='${rsh}' --recursive --relative --perms --update . ${host}:${storePath} --filter=':- .gitignore' --ignore-errors --usermap=:nobody --groupmap=*:nobody`,
+        `rsync ${rsyncDebug} --rsh='${rsh}' --recursive --relative --perms --update --filter=':- .gitignore' --ignore-errors --usermap=:nobody --groupmap=*:nobody . ${dest}`,
         { stdio: ["ignore", "inherit", "inherit"] }
       );
     } catch (err) {
@@ -487,7 +430,7 @@ class DevShell {
 
   // 监听非.gitignore文件
   // TODO： 目前仅仅监听process.cwd()以下的文件
-  async watchFile(keyFile, appId) {
+  async watchFile(appId) {
     const ignore = new GitIgnore(process.cwd());
     await ignore.collect();
     chokidar
@@ -502,29 +445,27 @@ class DevShell {
       .on(
         "all",
         debounce(() => {
-          this.syncProject(keyFile, appId);
+          this.syncProject(appId);
         }),
         1000
       );
   }
   async shell() {
-    let keyFile = this.keyFile;
     try {
       // 当进入shell的时候，都同步一次
-      await this.syncProject(keyFile, this.appId);
+      await this.syncProject(this.appId);
       // 注册watch函数
-      await this.watchFile(keyFile, this.appId);
+      await this.watchFile(this.appId);
 
       await this.connectShell();
     } catch (e) {
       console.log(e);
-      // this.reset();
       return Promise.reject(e);
     }
   }
 
   async connectShell() {
-    const sdk = new SdkDocker();
-    await sdk.interactiveShell(this.appId, this.runShell, this.uid);
+    const bridge = new DebugBridge();
+    await bridge.devshell(this.appId);
   }
 }