@lazycatcloud/lzc-cli 1.1.7 → 1.1.9

package/lib/app/lpk_devshell.js

@@ -2,9 +2,10 @@
 import path from "node:path";
 import fs from "node:fs";
 import logger from "loglevel";
-import { spawnSync, execSync } from "child_process";
+import { spawn, execSync } from "node:child_process";
 import { LpkBuild } from "./lpk_build.js";
 import { LpkInstaller } from "./lpk_installer.js";
+import debounce from "lodash.debounce";
 import {
   mergeYamlInMemory,
   contextDirname,
@@ -14,7 +15,10 @@ import {
   sleep,
   envTemplateFile,
   md5String,
+  md5File,
   createTemplateFileCommon,
+  loadFromYaml,
+  FileLocker,
 } from "../utils.js";
 import yaml from "js-yaml";
 import Key from "../key.js";
@@ -22,18 +26,153 @@ import os from "node:os";
 import { sdkEnv } from "../env.js";
 import commandExists from "command-exists";
 import chokidar from "chokidar";
-import execa from "execa";
+import _ from "lodash";
+import BoxAPI from "../api.js";
+import inquirer from "inquirer";
+import { SdkDocker } from "./lpk_devshell_docker.js";
 
-function sdkSSHAddress() {
+function sdkSSHHost() {
   const sdkUrl = sdkEnv.sdkUrl;
   let url = new URL(sdkUrl);
-  return `box@${url.hostname}:2222`;
+  return `box@${url.hostname}`;
+}
+
+function sdkSSHPort() {
+  return 2222;
+}
+
+function sdkSSHAddress() {
+  const host = sdkSSHHost();
+  const port = sdkSSHPort();
+  return `${host}:${port}`;
+}
+
+// 如果本地的机器没有 docker, 将会使用 rsync 同步
+export function fallbackToRsync() {
+  return !commandExists.sync("docker");
+}
+
+// 判断是否需要重新构建
+// - 先判断 lzc-build.yml 是否发生改变
+// - 再判断 lzc-build.yml 中的 manifest 中指定的文件是否发生改变
+// - 文件的 md5 缓存在 /tmp/lzc-cli-devshell/$PKGID/hash => {}
+// - 根据 backend api 判断一个 appid 是否属于 running
+// - 根据在 backend api 中判断同步的目录下是否存在文件 判断当前运行的 app 是否已经有一个挂载的实例，避免重复挂载
+class AppDevShellMonitor {
+  constructor(cwd, pkgId, rsyncMode = false) {
+    this.pwd = cwd ? path.resolve(cwd) : process.cwd();
+    this.rsyncMode = rsyncMode;
+
+    this.pkgId = pkgId;
+    this.boxapi = new BoxAPI(pkgId, sdkEnv.sdkUrl);
+
+    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.hashObject = {
+      build: "",
+      manifest: "",
+    };
+    this.cacheFilePath = undefined;
+    this.oldHash = undefined;
+    this.newHash = undefined;
+  }
+
+  async init() {
+    const pathId = await md5String(this.pwd);
+    this.cacheFilePath = path.resolve(
+      os.tmpdir(),
+      "lzc-cli-devshell",
+      pathId,
+      "hash"
+    );
+    ensureDir(this.cacheFilePath);
+
+    await this.updateHash();
+
+    return this;
+  }
+
+  async shouldBuild() {
+    return (
+      this.change() ||
+      (await this.notRunning()) ||
+      (await this.noMount()) ||
+      (await this.noDevshell())
+    );
+  }
+
+  async shouldRemount() {
+    try {
+      return await this.noMount();
+    } catch {
+      return true;
+    }
+  }
+
+  change() {
+    logger.debug("oldHash", this.oldHash);
+    logger.debug("newHash", this.newHash);
+    return !_.isEqual(this.oldHash, this.newHash);
+  }
+
+  async updateHash() {
+    this.oldHash = isFileExist(this.cacheFilePath)
+      ? JSON.parse(fs.readFileSync(this.cacheFilePath))
+      : {};
+    const buildHash = isFileExist(this.optionsFilePath)
+      ? await md5File(this.optionsFilePath)
+      : "";
+    const manifestHash = isFileExist(this.manifestFilePath)
+      ? await md5File(this.manifestFilePath)
+      : "";
+    this.newHash = {
+      build: buildHash,
+      manifest: manifestHash,
+    };
+    if (!_.isEqual(this.oldHash, this.newHash)) {
+      fs.writeFileSync(this.cacheFilePath, JSON.stringify(this.newHash));
+    }
+  }
+
+  async notRunning() {
+    try {
+      const { status } = await this.boxapi.status();
+      return status !== "running";
+    } catch {
+      return true;
+    }
+  }
+
+  async noMount() {
+    let hasMount = await this.boxapi.hasMount();
+    if (hasMount && this.rsyncMode) {
+      throw "sshfs docker 进程还在运行中，如果需要使用rsync模式，请先停止；或者继续使用sshfs模式";
+    }
+    if (this.rsyncMode) {
+      // rsync mode skip mount check
+      return false;
+    }
+    return !hasMount;
+  }
+
+  async noDevshell() {
+    return !(await this.boxapi.isDevshell());
+  }
 }
 
 export class AppDevShell {
-  constructor(cwd, builder) {
+  constructor(cwd, builder, rsyncMode, forceBuild = false) {
     this.cwd = cwd ? path.resolve(cwd) : process.cwd();
     this.lpkBuild = builder;
+    this.monitor = undefined;
+    this.sshfsProcess = undefined;
+    this.rsyncMode = rsyncMode;
+    this.forceBuild = forceBuild;
   }
 
   async init() {
@@ -41,9 +180,28 @@ export class AppDevShell {
       this.lpkBuild = new LpkBuild(this.cwd);
       await this.lpkBuild.init();
     }
+    const manifest = await this.lpkBuild.getManifest();
+    this.monitor = await new AppDevShellMonitor(
+      this.cwd,
+      manifest["package"],
+      this.rsyncMode
+    ).init();
+  }
+
+  async build() {
+    // 先判断是否需要重新构建
+    if (this.forceBuild || (await this.monitor.shouldBuild())) {
+      logger.debug("build...");
+      await this.devshellBuild();
+    }
+    // 判断是否需要重新启动 sshfs 容器
+    if (!this.rsyncMode && (await this.monitor.shouldRemount())) {
+      logger.debug("mount...");
+      this.sshfsProcess = await this.sshfs();
+    }
   }
 
-  async shellWithBuild() {
+  async devshellBuild() {
     // 确保 sdk key ，并上传到 sdk
     const k = new Key();
     await k.ensure(sdkEnv.sdkUrl);
@@ -55,9 +213,32 @@ export class AppDevShell {
       logger.debug("devshell delete 'contentdir' field");
       delete options["buildscript"];
       delete options["contentdir"];
+
+      const devshell = options["devshell"];
+      if (!devshell) {
+        throw "devshell 模式下，devshell 字段必须要指定";
+      }
+
+      const routes = devshell["routes"];
+      if (!routes || routes.length == 0) {
+        throw "devshell 模式下，必须要指定 routes 内容";
+      }
+
       return options;
     });
 
+    // 复制 exec.sh 到 devshell 中去
+    this.lpkBuild.onBeforeTarContent(async (contentdir) => {
+      const execScriptPath = path.join(
+        contextDirname(import.meta.url),
+        "../../template/_lpk/exec.sh"
+      );
+      let dest = path.join(contentdir, "devshell", "exec.sh");
+      ensureDir(dest);
+      fs.copyFileSync(execScriptPath, dest);
+      fs.chmodSync(dest, 0o775);
+    });
+
     // 用 sdk ssh key 并复制到 contentdir 目录
     // docker 中 sshd 的配置中已改成 /lzcapp/pkg/content/devshell/authorized_keys
     this.lpkBuild.onBeforeTarContent(async (contentdir) => {
@@ -67,36 +248,36 @@ export class AppDevShell {
       fs.copyFileSync(publicKey, dest);
     });
 
-    // 在生成 manifest.yml 之前合并 sync 模板字段
-    this.lpkBuild.onBeforeDumpYaml(async (manifest, options) => {
-      const services = manifest["services"];
-      if (services && Object.keys(services).some((key) => key === "sync")) {
-        throw "自定义的 services 中与 devshell 中的 sync 名称冲突";
+    // 复制 setupscript 脚本
+    this.lpkBuild.onBeforeTarContent(async (contentdir, options) => {
+      const devshell = options["devshell"];
+      if (!devshell["setupscript"]) {
+        return;
       }
 
-      const syncManifestPath = path.join(
-        contextDirname(import.meta.url),
-        "../../template/_lpk/sync.manifest.yml.in"
-      );
-      const syncManifest = yaml.load(
-        await envTemplateFile(syncManifestPath, manifest)
-      );
-      return mergeYamlInMemory([manifest, syncManifest]);
+      logger.debug("处理 setupscript ");
+      const dest = path.join(contentdir, "devshell", "setupscript");
+      ensureDir(dest);
+
+      // 先判断是否文件
+      const filePath = path.resolve(devshell["setupscript"]);
+      if (isFileExist(filePath)) {
+        fs.copyFileSync(filePath, dest);
+      } else {
+        fs.writeFileSync(
+          dest,
+          `#!/bin/sh\nset -ex\n${devshell["setupscript"]}`
+        );
+      }
+      fs.chmodSync(dest, 0o775);
     });
 
     // 在生成 manifest.yml 之前合并 devshell manifest 模板字段
     this.lpkBuild.onBeforeDumpYaml(async (manifest, options) => {
       logger.debug("merge lzc-build.yml devshell routes field");
       const devshell = options["devshell"];
-      if (!devshell) {
-        throw "devshell 模式下，devshell 字段必须要指定";
-      }
 
       const routes = devshell["routes"];
-      if (!routes || routes.length == 0) {
-        throw "devshell 模式下，必须要指定 routes 内容";
-      }
-
       logger.debug("options devshell delete 'routes' field");
       delete options["devshell"]["routes"];
       // 如果 devshell 中的 router 和 manifest 中的 prefix 出现冲突
@@ -148,23 +329,26 @@ export class AppDevShell {
 
       const depsStr = deps.sort().join(" ");
       logger.debug("开始创建 Dockerfile 文件");
-      const tempDir = fs.mkdtempSync(".lzc-cli-build-dependencies");
-      const dockerfilePath = path.join(
-        contextDirname(import.meta.url),
-        "../../template/_lpk/Dockerfile.in"
-      );
-      await createTemplateFileCommon(
-        dockerfilePath,
-        path.join(tempDir, "Dockerfile"),
-        { dependencies: depsStr }
-      );
-
       const tag = `${await md5String(depsStr)}:latest`;
-      logger.debug(`开始在盒子中构建 ${tag} 镜像 from ${tempDir}`);
-      const sdk = new sdkDocker();
-      await sdk.buildImage(tag, tempDir, tempDir);
 
-      fs.rmSync(tempDir, { recursive: true });
+      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;
@@ -187,7 +371,7 @@ export class AppDevShell {
 
       logger.debug(`开始在盒子中构建 ${tag} 镜像`);
 
-      const sdk = new sdkDocker();
+      const sdk = new SdkDocker();
       await sdk.buildImage(tag, config["build"], process.cwd());
 
       delete manifest["application"]["devshell"];
@@ -195,66 +379,135 @@ export class AppDevShell {
       return manifest;
     });
 
+    // 如果 devshell 中指定了 image 字段将使用 image 字段
+    this.lpkBuild.onBeforeDumpYaml(async (manifest) => {
+      const config = manifest["application"];
+      if (config["devshell"] && config["devshell"]["image"]) {
+        manifest["application"]["image"] = config["devshell"]["image"];
+        delete manifest["application"]["devshell"];
+      }
+      return manifest;
+    });
+
     // 如果没有找到 devshell 中没有指定 image 不存在，将默认使用的 lzc-cli/devshell 容器
     this.lpkBuild.onBeforeDumpYaml(async (manifest) => {
+      delete manifest["application"]["devshell"];
+
       const config = manifest["application"];
       if (config["image"]) {
         return manifest;
       }
+
+      logger.debug("use default lzc-cli/devshell image");
       manifest["application"][
         "image"
       ] = `registry.lazycat.cloud/lzc-cli/devshell:latest`;
       return manifest;
     });
 
+    // 添加一个 devshell 的标记在 lpk 中，标记当前 lpk 为一个 debug 版本
+    this.lpkBuild.onBeforeDumpLpk(async (options, cwd, destDir) => {
+      fs.writeFileSync(path.resolve(destDir, "devshell"), "");
+    });
+
     // 在构建生成 lpk 包后，调用 deploy 进行部署
     let installer = new LpkInstaller();
     await installer.init();
     await installer.deploy(this.lpkBuild);
 
     await sleep(2000);
-
-    // 通过 rsync 同步源码到应用容器中
-    // TODO: 改成用 sshfs 的方式
-    await this.shell(true);
   }
 
-  async shell(build = false) {
+  async rsyncShell(runShell) {
     const k = new Key();
     const pairs = await k.getKeyPair();
     const manifest = await this.lpkBuild.getManifest();
-    const devshell = new DevShell(pairs["private"], manifest["package"]);
-    if (build || !devshell.isRsyncWatch()) {
+    const pkgId = manifest["package"];
+
+    let isSync = false;
+    try {
+      const locker = new FileLocker(pkgId);
+      locker.lock();
+      process.on("exit", () => {
+        logger.debug("filelock unlock");
+        locker.unlock();
+      });
+      isSync = true;
+    } catch (err) {
+      logger.debug("filelock catch");
+      logger.debug(err);
+    }
+
+    const devshell = new DevShell(pairs["private"], pkgId, runShell);
+    if (isSync) {
       await devshell.shell();
     } else {
-      await devshell.directShell();
+      await devshell.connectShell();
     }
     logger.debug("exit shell");
     // TODO: shell 在正常情况下，按 Ctrl-D 就会退出，回到原来的本地的 shell ，但
     // 现在会一直卡在退出状态后，必须要另外手动的指定 pkill node
     process.exit(0);
   }
+
+  async sshfs() {
+    const k = new Key();
+    const pairs = await k.getKeyPair();
+    const manifest = await this.lpkBuild.getManifest();
+    const localDevshell = new LocalDevshell(pairs, sdkSSHAddress());
+    const syncP = localDevshell.run(manifest.package, this.cwd);
+    await syncP.ready();
+    return syncP;
+  }
+
+  async sshfsShell(runShell) {
+    const manifest = await this.lpkBuild.getManifest();
+    const sdk = new SdkDocker();
+    await sdk.interactiveShell(manifest.package, runShell);
+
+    if (this.sshfsProcess) {
+      // already exit
+      if (this.sshfsProcess.p.exitCode) {
+        return;
+      }
+
+      const questions = [
+        {
+          name: "stop",
+          type: "input",
+          default: "n",
+          message: "是否停止 sshfs 同步容器(y/n): ",
+        },
+      ];
+      const answers = await inquirer.prompt(questions);
+      if (answers.stop.toLowerCase() === "y") {
+        this.sshfsProcess.p.kill("SIGTERM");
+      } else {
+        this.sshfsProcess.p.unref();
+        // FIXME: why must process.exit()
+        process.exit(0);
+      }
+    }
+  }
 }
 
 class DevShell {
-  constructor(keyFile, appId) {
+  constructor(keyFile, appId, runShell = "sh") {
     logger.debug("keyFile", keyFile);
     logger.debug("appid", appId);
 
-    this.tempDir = path.join(os.tmpdir(), "lzc-cli-devshell", appId);
-    if (!fs.existsSync(this.tmpdir)) {
-      fs.mkdirSync(this.tempDir, { recursive: true });
-    }
     this.keyFile = keyFile;
     this.appId = appId;
+    this.runShell = runShell;
   }
 
-  async syncProject(keyFile, appAddr, appId) {
-    let jump = sdkSSHAddress();
+  async syncProject(keyFile, appId) {
+    const host = sdkSSHHost();
+    const port = sdkSSHPort();
     // prettier-ignore
     let rsh = [
       "ssh",
-      "-J", jump,
+      "-p", `${port}`,
       "-o", `"StrictHostKeyChecking=no"`,
       "-o", `"UserKnownHostsFile=/dev/null"`,
       "-o", `"ConnectionAttempts=3"`,
@@ -269,11 +522,18 @@ class DevShell {
       process.exit(1);
     }
 
+    let rsyncDebug = process.env.RSYNCDEBUG ? "-P" : "";
+    let storePath = `/var/lib/box-server/lzcapps/${appId}/lzcapp/cache/devshell`;
     // FIXME: 下方执行命令不确定是否有兼容性问题
-    execSync(
-      `rsync --rsh='${rsh}' -czrPR . root@${appAddr}:/lzcapp/cache/${appId} --filter=':- .gitignore' --exclude='node_modules' --exclude='.git' --delete`,
-      { stdio: ["ignore", "ignore", "inherit"] }
-    );
+    try {
+      execSync(
+        `rsync ${rsyncDebug} --rsh='${rsh}' --recursive --relative --perms --update . ${host}:${storePath} --filter=':- .gitignore' --exclude='node_modules' --exclude='.git' --delete --ignore-errors --usermap=:nobody --groupmap=*:nobody`,
+        { stdio: ["ignore", "inherit", "inherit"] }
+      );
+    } catch (err) {
+      logger.error("rsync 同步失败");
+      logger.debug(err);
+    }
   }
 
   // fallback fs.watch on not darwin and windows platform
@@ -317,7 +577,7 @@ class DevShell {
 
   // 监听非.gitignore文件
   // TODO： 目前仅仅监听process.cwd()以下的文件
-  async watchFile(keyFile, appAddr, appId) {
+  async watchFile(keyFile, appId) {
     const ignore = new GitIgnore(process.cwd());
     await ignore.collect();
     chokidar
@@ -329,293 +589,98 @@ class DevShell {
         },
         ignoreInitial: true,
       })
-      .on("all", (event, path) => {
-        // console.log(event, path);
-        this.syncProject(keyFile, appAddr, appId);
-      });
-  }
-
-  // 保存一个dev shell状态的文件,如果重复执行dev shell
-  // 会先判断这个临时文件是否存在，如果不存在重新部署，更新流程
-  // 否则直接ssh连接
-  async storeShellStatus(isWatch) {
-    fs.writeFileSync(
-      path.join(this.tempDir, ".shellStatus"),
-      JSON.stringify({
-        isWatch,
-      })
-    );
-  }
-
-  isRsyncWatch() {
-    try {
-      let obj = this.readShellStatus();
-      return obj.isWatch;
-    } catch {
-      return false;
-    }
-  }
-
-  async readShellStatus() {
-    return JSON.parse(
-      fs.readFileSync(path.join(this.tempDir, ".shellStatus"), "utf-8")
-    );
-  }
-
-  async directShell() {
-    const keyFile = this.keyFile;
-    const appAddr = `sync.${this.appId}.lzcapp`;
-
-    let isWatch;
-    try {
-      ({ isWatch } = await this.readShellStatus());
-
-      if (!isWatch) {
-        await this.syncProject(keyFile, appAddr, this.appId);
-        // 注册watch函数
-        await this.watchFile(keyFile, appAddr, this.appId);
-
-        this.storeShellStatus(true);
-      }
-
-      await this.connectShell(this.appId);
-    } catch (e) {
-      return Promise.reject(e);
-    } finally {
-      if (!isWatch) {
-        this.storeShellStatus(false);
-      }
-    }
+      .on(
+        "all",
+        debounce(() => {
+          this.syncProject(keyFile, appId);
+        }),
+        1000
+      );
   }
-
   async shell() {
     let keyFile = this.keyFile;
-    const appAddr = `sync.${this.appId}.lzcapp`;
-
     try {
       // 当进入shell的时候，都同步一次
-      await this.syncProject(keyFile, appAddr, this.appId);
+      await this.syncProject(keyFile, this.appId);
       // 注册watch函数
-      await this.watchFile(keyFile, appAddr, this.appId);
-
-      this.storeShellStatus(true);
+      await this.watchFile(keyFile, this.appId);
 
-      await this.connectShell(this.appId);
+      await this.connectShell();
     } catch (e) {
       console.log(e);
       // this.reset();
       return Promise.reject(e);
-    } finally {
-      // 当shell退出后，更新isWatch状态
-      this.storeShellStatus(false);
     }
   }
 
-  async connectShell(appId) {
-    const sdk = new sdkDocker();
-    const replacedAppId = appId.replaceAll(".", "_").replaceAll("-", "__");
-    await sdk.interactiveShell(`lzc--${replacedAppId}-app-1`);
+  async connectShell() {
+    const sdk = new SdkDocker();
+    await sdk.interactiveShell(this.appId, this.runShell);
   }
 }
 
-// build strategies based on lzc-build.yml devshell field
-import { DockerClient, dockerPullLzcAppsImage } from "../sdk.js";
-import { DockerfileParser } from "dockerfile-ast";
-import glob from "fast-glob";
-import ignore from "@balena/dockerignore";
-import { createLogUpdate } from "log-update";
-
-class sdkDocker {
-  constructor() {}
-
-  // builder 需要在app 的场景下使用, 不过有两个路径要注意
-  // 一个是 docker build 时的context. 这个一般是运行cli时候的路径
-  async buildImage(tag, buildDir, contextDir) {
-    const dockerfilePath = path.join(buildDir, "Dockerfile");
-    try {
-      await this.dockerRemoteBuildV2(contextDir, dockerfilePath, tag);
-    } catch (e) {
-      throw e;
-    }
-  }
-
-  async collectContextFromDockerFile(contextDir, dockerfilePath) {
-    if (!fs.existsSync(dockerfilePath)) {
-      throw "未发现 Dockerfile";
-    }
-
-    let src = [path.relative(contextDir, dockerfilePath)];
-
-    // 通过 COPY 和 ADD 获取所有context中的文件
-    const ast = DockerfileParser.parse(fs.readFileSync(dockerfilePath, "utf8"));
-    for (let a of ast.getInstructions()) {
-      if (["COPY", "ADD"].includes(a.getInstruction())) {
-        const from = a.getArguments()[0].getValue().replace(/^\//, "");
-
-        const fromFullPath = path.join(contextDir, from);
-
-        if (fs.existsSync(fromFullPath)) {
-          const stat = fs.statSync(path.join(contextDir, from));
-          if (stat.isDirectory()) {
-            let files = await glob(path.join(from, "**"), {
-              cwd: contextDir,
-            });
-            src = src.concat(files);
-          } else if (stat.isFile()) {
-            src.push(from);
-          }
-        } else {
-          // try use glob
-          let files = await glob(from, {
-            cwd: contextDir,
-          });
-          src = src.concat(files);
-        }
-      }
-    }
-    // filter by dockerignore
-    const dockerIgnoreFile = path.join(contextDir, ".dockerignore");
-    //
-    if (fs.existsSync(dockerIgnoreFile)) {
-      let ig = ignore();
-      let data = fs.readFileSync(dockerIgnoreFile, "utf8");
-      ig.add(data.split("\n"));
-      src = ig.filter(src);
-    }
-    return src;
-  }
-
-  /**
-   * v2 版本会收集所有需要的context 文件,将其传入buildImage 方法中
-   * @param contextDir
-   * @param dockerfile
-   * @param tag
-   */
-  async dockerRemoteBuildV2(contextDir, dockerfile, tag) {
-    const src = await this.collectContextFromDockerFile(contextDir, dockerfile);
-    const host = new URL(sdkEnv.sdkUrl).host;
-    console.log(host);
-    const docker = await new DockerClient(host).init();
-    try {
-      await dockerPullLzcAppsImage(host);
-
-      return new Promise(async (resolve, reject) => {
-        let refresher = new StatusRefresher();
-
-        logger.info("开始在设备中构建镜像");
-        const stream = await docker.buildImage(
-          {
-            context: contextDir,
-            src: src,
-          },
-          {
-            dockerfile: src[0],
-            t: tag,
-          }
-        );
-        docker.modem.followProgress(
-          stream,
-          (err, res) => {
-            err ? reject(err) : resolve(res);
-          },
-          (res) => {
-            if (res.status) {
-              if (res.id) {
-                if (["Downloading", "Extracting"].includes(res.status)) {
-                  refresher.updateStatus({
-                    id: res.id,
-                    content: `${res.status} ${res.progress}`,
-                  });
-                } else {
-                  refresher.updateStatus({
-                    id: res.id,
-                    content: res.status,
-                  });
-                }
-              } else {
-                process.stdout.write(res.status);
-                process.stdout.write("\n");
-              }
-            }
-
-            if (res.stream) {
-              if (res.stream.startsWith("Step")) {
-                refresher.reset();
-              }
-              process.stdout.write(res.stream);
-            }
-            if (res.error) {
-              reject(res.error);
-            }
-          }
-        );
-      });
-    } catch (err) {
-      throw err;
-    }
+// 本地的 devshell 容器
+// - 将当前项目目录通过 volumes 的方式绑定到 local_devshell 中
+// - local_devshell 中通过 ssh 反代本地的 22 端口到 sdk 中 30222
+// - sdk 中的 sshfs 通过连接 30222 端口进行同步
+// - 结合 local_devshell 容器中的 entrypoint 脚本
+class LocalDevshell {
+  constructor(pairs, sdkHost) {
+    this.publicKey = pairs["public"];
+    this.privateKey = pairs["private"];
+    this.sdkHost = sdkHost;
+    this.log = logger.getLogger("LocalDevshell");
   }
 
-  async interactiveShell(containerName, shell = "sh") {
-    const host = new URL(sdkEnv.sdkUrl).hostname;
-    const docker = await new DockerClient(host).init();
-    const container = docker.getContainer(containerName);
-    const exec = await container.exec({
-      Cmd: [shell],
-      AttachStderr: true,
-      AttachStdout: true,
-      AttachStdin: true,
-      Tty: true,
+  run(pkgId, projectPath) {
+    const host = this.sdkHost.split(":")[0];
+    const port = this.sdkHost.split(":")[1];
+    // prettier-ignore
+    const syncP = spawn(`docker`, [
+      `run`, `--rm`,
+      `--network=host`,
+      `-v`, `${projectPath}:/project/${pkgId}`,
+      `-v`, `${this.privateKey}:/sdk/privateKey`,
+      `-v`, `${this.publicKey}:/sdk/publicKey`,
+      `-e`, `PKGID=${pkgId}`,
+      `-e`, `SDK_HOST=${host}`,
+      `-e`, `SDK_PORT=${port}`,
+      `-e`, `HOSTUID=${process.getuid()}`,
+      `-e`, `HOSTGID=${process.getgid()}`,
+      `registry.lazycat.cloud/lzc-cli/local_devshell:0.0.4`,
+    ], { detached: true, stdio: ["ignore", "pipe", "pipe"] });
+    syncP.stdout.on("data", (data) => {
+      this.log.debug(data.toString());
     });
-
-    const stream = await exec.start({ stdin: true });
-
-    process.stdin.setRawMode(true);
-    stream.pipe(process.stdout);
-    process.stdin.pipe(stream);
-
-    // prepare command
-    stream.write("cd /lzcapp/cache\n");
-    stream.write("ls\n");
-
-    await new Promise((resolve) => {
-      stream.on("end", () => {
-        logger.info("exit");
-        resolve();
-      });
+    syncP.stderr.on("data", (data) => {
+      this.log.debug(data.toString());
     });
+    return {
+      p: syncP,
+      ready: async () => {
+        return new Promise((_resolve, _reject) => {
+          syncP.stdout.on("data", (data) => {
+            if (data.toString().search(/sshfs running/g) > -1) {
+              this.log.debug("sshfs ready");
+              _resolve();
+            }
+          });
 
-    process.stdin.removeAllListeners();
-    process.stdin.setRawMode(false);
-    process.stdin.resume();
-  }
-}
-
-class StatusRefresher {
-  constructor() {
-    this.reset();
-  }
-  refresh() {
-    this.logUpdate(this.pulls.map((p) => `${p.id}: ${p.content}`).join("\n"));
-  }
-
-  reset() {
-    this.pulls = [];
-    this.logUpdate = createLogUpdate(process.stdout);
-  }
+          syncP.on("error", (err) => {
+            this.log.error(err);
+          });
 
-  updateStatus({ id, content }) {
-    let index = this.pulls.findIndex((p) => p.id == id);
-    if (index > -1) {
-      this.pulls[index] = {
-        id: id,
-        content: content,
-      };
-    } else {
-      this.pulls.push({
-        id: id,
-        content: content,
-      });
-    }
-    this.refresh();
+          syncP.on("close", (code) => {
+            if (code != 0) {
+              this.log.debug(`docker exited with code ${code}`);
+              _reject();
+            } else {
+              this.log.debug("sshfs close");
+              _resolve();
+            }
+          });
+        });
+      },
+    };
   }
 }