@akanjs/cli 2.4.0 → 2.4.1-rc.1

package/index-x53a5nya.js

@@ -0,0 +1,301 @@
+// @bun
+import {
+  FileSys
+} from "./index-61keag0s.js";
+
+// pkgs/@akanjs/devkit/dependencyScanner.ts
+import { builtinModules } from "module";
+import * as path from "path";
+import ignore from "ignore";
+import ts from "typescript";
+var testFileRegex = /\.(?:test|spec)\.[cm]?[tj]sx?$/;
+var builtinModuleSet = new Set([...builtinModules, ...builtinModules.map((mod) => `node:${mod}`)]);
+var stripShebang = (source) => source.replace(/^#!.*(?:\r?\n|$)/, "");
+
+class TypeScriptDependencyScanner {
+  #fileDependencies = new Map;
+  #fileRuntimeDependencies = new Map;
+  #fileTypeDependencies = new Map;
+  #visitedFiles = new Set;
+  #tsTranspiler = new Bun.Transpiler({ loader: "ts" });
+  #tsxTranspiler = new Bun.Transpiler({ loader: "tsx" });
+  directory;
+  rootPackageJson;
+  ig;
+  workspaceRoot;
+  constructor(directory, {
+    workspaceRoot,
+    rootPackageJson,
+    gitignorePatterns = []
+  }) {
+    this.directory = directory;
+    this.rootPackageJson = rootPackageJson;
+    this.ig = ignore().add(gitignorePatterns);
+    this.workspaceRoot = workspaceRoot;
+  }
+  async getMonorepoDependencies(projectName, { pkgs = [], libs = [] } = {}) {
+    const npmSet = new Set(Object.keys({ ...this.rootPackageJson.dependencies, ...this.rootPackageJson.devDependencies }));
+    const pkgPathSet = new Set(pkgs);
+    const libPathSet = new Set(libs.map((lib) => `@libs/${lib}`));
+    await this.getDependencies();
+    const [npmDepSet, pkgPathDepSet, libPathDepSet] = this.#getImportSetsFromDependencies([npmSet, pkgPathSet, libPathSet], this.#fileRuntimeDependencies);
+    const [npmDevDepSet] = this.#getImportSetsFromDependencies([npmSet], this.#fileTypeDependencies);
+    const pkgDeps = [...pkgPathDepSet];
+    const libDeps = [...libPathDepSet].map((path2) => path2.replace("@libs/", "")).filter((libName) => libName !== projectName);
+    return {
+      pkgDeps,
+      libDeps,
+      npmDeps: [...npmDepSet],
+      npmDevDeps: [...npmDevDepSet].filter((dep) => !npmDepSet.has(dep))
+    };
+  }
+  async getPackageBuildDependencies(projectName) {
+    const runtimeDeps = new Set;
+    const devDeps = new Set;
+    const sourceFiles = await this.#findTypeScriptFiles(this.directory, {
+      excludeBuildFiles: true,
+      excludeTestFiles: true
+    });
+    const cssFiles = await this.#findCssFiles(this.directory);
+    for (const filePath of sourceFiles) {
+      const fileContent = await FileSys.readText(filePath);
+      const { imports, typeImports } = this.#extractImports(fileContent, filePath);
+      this.#addNormalizedImports(runtimeDeps, imports, projectName);
+      this.#addNormalizedImports(devDeps, typeImports, projectName);
+    }
+    for (const filePath of cssFiles) {
+      const fileContent = await FileSys.readText(filePath);
+      this.#addNormalizedImports(runtimeDeps, this.#extractCssPluginImports(fileContent), projectName);
+    }
+    const buildFilePath = path.join(this.directory, "build.ts");
+    if (await FileSys.fileExists(buildFilePath)) {
+      const fileContent = await FileSys.readText(buildFilePath);
+      const { imports, typeImports } = this.#extractImports(fileContent, buildFilePath);
+      this.#addNormalizedImports(devDeps, [...imports, ...typeImports], projectName);
+    }
+    for (const dep of runtimeDeps)
+      devDeps.delete(dep);
+    const rootDeps = { ...this.rootPackageJson.dependencies, ...this.rootPackageJson.devDependencies };
+    const missingDeps = [];
+    for (const dep of [...runtimeDeps, ...devDeps]) {
+      if (rootDeps[dep] || await this.#hasWorkspacePackage(dep))
+        continue;
+      missingDeps.push(dep);
+    }
+    return {
+      npmDeps: [...runtimeDeps].sort(),
+      npmDevDeps: [...devDeps].sort(),
+      missingDeps: missingDeps.sort()
+    };
+  }
+  async#hasWorkspacePackage(dep) {
+    const packageJsonPath = path.join(this.workspaceRoot, "pkgs", dep, "package.json");
+    if (!await Bun.file(packageJsonPath).exists())
+      return false;
+    try {
+      const packageJson = await FileSys.readJson(packageJsonPath);
+      return packageJson.name === dep && !!packageJson.version;
+    } catch {
+      return false;
+    }
+  }
+  async getImportSets(depSets) {
+    const fileDependencies = await this.getDependencies();
+    return this.#getImportSetsFromDependencies(depSets, fileDependencies);
+  }
+  #getImportSetsFromDependencies(depSets, fileDependencies) {
+    const importedDepSets = new Array(depSets.length);
+    for (let i = 0;i < depSets.length; i++)
+      importedDepSets[i] = new Set;
+    fileDependencies.forEach((imps) => {
+      imps.forEach((imp) => {
+        if (imp.startsWith("."))
+          return;
+        const moduleName = imp;
+        const moduleNameParts = moduleName.split("/");
+        const subModuleLength = moduleNameParts.length;
+        for (let i = 0;i < subModuleLength; i++) {
+          const importName = moduleNameParts.slice(0, i + 1).join("/");
+          for (let j = 0;j < depSets.length; j++) {
+            if (depSets[j]?.has(importName)) {
+              importedDepSets[j]?.add(importName);
+              return;
+            }
+          }
+        }
+      });
+    });
+    return importedDepSets;
+  }
+  async getDependencies() {
+    this.#fileDependencies.clear();
+    this.#fileRuntimeDependencies.clear();
+    this.#fileTypeDependencies.clear();
+    this.#visitedFiles.clear();
+    const files = await this.#findTypeScriptFiles(this.directory);
+    for (const file of files)
+      await this.#analyzeFile(file, this.directory);
+    return this.#fileDependencies;
+  }
+  async#findTypeScriptFiles(directory, {
+    excludeBuildFiles = false,
+    excludeTestFiles = false
+  } = {}) {
+    const files = [];
+    const skipDirs = ["node_modules", "dist", "build", ".git", ".next", "public", "ios", "android"];
+    const glob = new Bun.Glob("**/*.{ts,tsx}");
+    for await (const filePath of glob.scan({ cwd: directory, onlyFiles: true })) {
+      if (skipDirs.some((dir) => filePath.includes(`/${dir}/`) || filePath.startsWith(`${dir}/`)))
+        continue;
+      if (excludeBuildFiles && filePath === "build.ts")
+        continue;
+      if (excludeTestFiles && testFileRegex.test(filePath))
+        continue;
+      const fullPath = path.join(directory, filePath);
+      const relativePath = path.relative(this.workspaceRoot, fullPath);
+      if (this.ig.ignores(relativePath))
+        continue;
+      files.push(fullPath);
+    }
+    return files;
+  }
+  async#findCssFiles(directory) {
+    const files = [];
+    const skipDirs = ["node_modules", "dist", "build", ".git", ".next", "public", "ios", "android"];
+    const glob = new Bun.Glob("**/*.css");
+    for await (const filePath of glob.scan({ cwd: directory, onlyFiles: true })) {
+      if (skipDirs.some((dir) => filePath.includes(`/${dir}/`) || filePath.startsWith(`${dir}/`)))
+        continue;
+      const fullPath = path.join(directory, filePath);
+      const relativePath = path.relative(this.workspaceRoot, fullPath);
+      if (this.ig.ignores(relativePath))
+        continue;
+      files.push(fullPath);
+    }
+    return files;
+  }
+  async#analyzeFile(filePath, baseDir) {
+    if (this.#visitedFiles.has(filePath))
+      return;
+    this.#visitedFiles.add(filePath);
+    try {
+      const fileContent = await FileSys.readText(filePath);
+      const { imports, typeImports } = this.#extractImports(fileContent, filePath);
+      const resolvedImports = await this.#resolveImports(imports, filePath, baseDir);
+      const resolvedTypeImports = await this.#resolveImports(typeImports, filePath, baseDir);
+      const relativePath = path.relative(baseDir, filePath);
+      this.#fileDependencies.set(relativePath, [...new Set([...resolvedImports, ...resolvedTypeImports])]);
+      this.#fileRuntimeDependencies.set(relativePath, resolvedImports);
+      this.#fileTypeDependencies.set(relativePath, resolvedTypeImports);
+    } catch {}
+  }
+  async#resolveImports(imports, filePath, baseDir) {
+    return await Promise.all(imports.map(async (importPath) => {
+      if (importPath.startsWith(".")) {
+        const resolvedPath = `./${path.join(path.relative(baseDir, filePath), importPath)}`;
+        return await this.#ensureExtension(resolvedPath);
+      }
+      return importPath;
+    }));
+  }
+  async#ensureExtension(filePath) {
+    if (await FileSys.fileExists(`${filePath}.ts`))
+      return `${filePath}.ts`;
+    else if (await FileSys.fileExists(`${filePath}.tsx`))
+      return `${filePath}.tsx`;
+    else if (await FileSys.fileExists(filePath))
+      return filePath;
+    return `${filePath}.ts`;
+  }
+  #extractImports(source, filePath) {
+    const transpiler = filePath.endsWith(".tsx") ? this.#tsxTranspiler : this.#tsTranspiler;
+    const scanSource = stripShebang(source);
+    const imports = new Set(transpiler.scanImports(scanSource).map((imp) => imp.path).filter(Boolean));
+    const typeImports = new Set;
+    const sourceFile = ts.createSourceFile(filePath, scanSource, ts.ScriptTarget.Latest, true);
+    for (const statement of sourceFile.statements) {
+      if (!ts.isImportDeclaration(statement))
+        continue;
+      if (!ts.isStringLiteral(statement.moduleSpecifier))
+        continue;
+      const importPath = statement.moduleSpecifier.text;
+      const namedBindings = statement.importClause?.namedBindings;
+      const isNamedTypeOnlyImport = namedBindings && ts.isNamedImports(namedBindings) && namedBindings.elements.length > 0 && namedBindings.elements.every((element) => element.isTypeOnly);
+      if ((statement.importClause?.isTypeOnly || isNamedTypeOnlyImport) && !imports.has(importPath)) {
+        typeImports.add(importPath);
+      }
+    }
+    return { imports: [...imports], typeImports: [...typeImports] };
+  }
+  #extractCssPluginImports(source) {
+    const imports = new Set;
+    const pluginRegex = /@plugin\s+(?:url\()?["']([^"')]+)["']\)?/g;
+    for (const match of source.matchAll(pluginRegex)) {
+      const importPath = match[1];
+      if (importPath)
+        imports.add(importPath);
+    }
+    return [...imports];
+  }
+  #addNormalizedImports(deps, imports, projectName) {
+    for (const importPath of imports) {
+      const dep = this.#normalizePackageImport(importPath, projectName);
+      if (dep)
+        deps.add(dep);
+    }
+  }
+  #normalizePackageImport(importPath, projectName) {
+    if (importPath.startsWith(".") || importPath.startsWith("/") || importPath.startsWith("#") || importPath.startsWith("bun:") || builtinModuleSet.has(importPath))
+      return null;
+    const parts = importPath.split("/");
+    const packageName = importPath.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+    if (!packageName || packageName === projectName || importPath.startsWith(`${projectName}/`))
+      return null;
+    return packageName;
+  }
+  generateDependencyGraph() {
+    let graph = `Dependency Graph:
+
+`;
+    for (const [file, imports] of this.#fileDependencies.entries()) {
+      graph += `${file}:
+`;
+      const projectImports = imports.filter((i) => !i.startsWith("react") && !i.startsWith("@"));
+      const externalImports = imports.filter((i) => i.startsWith("react") || i.startsWith("@"));
+      if (projectImports.length > 0) {
+        graph += `  Project dependencies:
+`;
+        projectImports.forEach((imp) => {
+          graph += `    \u2192 ${imp}
+`;
+        });
+      }
+      if (externalImports.length > 0) {
+        graph += `  External dependencies:
+`;
+        externalImports.forEach((imp) => {
+          graph += `    \u2192 ${imp}
+`;
+        });
+      }
+      graph += `
+`;
+    }
+    return graph;
+  }
+  static async from(exec) {
+    const [tsconfig, rootPackageJson, gitignorePatterns] = await Promise.all([
+      exec.getTsConfig(),
+      exec.workspace.getPackageJson(),
+      exec.workspace.getGitignorePatterns()
+    ]);
+    return new TypeScriptDependencyScanner(exec.cwdPath, {
+      workspaceRoot: exec.workspace.cwdPath,
+      tsconfig,
+      rootPackageJson,
+      gitignorePatterns
+    });
+  }
+}
+
+export { TypeScriptDependencyScanner };

package/index-y3hdhy4p.js

@@ -0,0 +1,229 @@
+// @bun
+import {
+  pluralizeName
+} from "./index-ss469dec.js";
+import {
+  Prompter
+} from "./index-qaq13qk3.js";
+import {
+  createPassedPrimitiveReport,
+  generatedFilesForSync,
+  scalarChangedFiles
+} from "./index-h6ca6qg0.js";
+import {
+  AiSession
+} from "./index-5vvwc0cz.js";
+import {
+  runner,
+  script
+} from "./index-hdqztm58.js";
+
+// pkgs/@akanjs/cli/scalar/scalar.prompt.ts
+import { input } from "@inquirer/prompts";
+class ScalarPrompt extends Prompter {
+  sys;
+  name;
+  constructor(sys, name) {
+    super();
+    this.sys = sys;
+    this.name = name;
+  }
+  async requestUpdateConstant() {
+    const request = await input({ message: `What do you want to change?` });
+    return { request, validate: undefined };
+  }
+  async requestCreateConstant() {
+    const constantFiles = await this.sys.getConstantFilesWithLibs();
+    const description = await input({ message: "description of scalar" });
+    const schemaDescription = await input({ message: "schema description of scalar" });
+    await this.sys.applyTemplate({
+      basePath: "./lib/__scalar",
+      template: "__scalar",
+      dict: { model: this.name, models: pluralizeName(this.name), sysName: this.sys.name }
+    });
+    const boilerplate = await this.sys.readFile(`lib/__scalar/${this.name}/${this.name}.constant.ts`);
+    return await this.#requestConstant({
+      modelDesc: description,
+      modelSchemaDesign: schemaDescription,
+      boilerplate,
+      constantFiles
+    });
+  }
+  async#requestConstant({
+    modelDesc,
+    modelSchemaDesign,
+    boilerplate,
+    constantFiles
+  }) {
+    const scanInfo = await this.sys.scan();
+    const guideJson = await Prompter.getGuideJson("scalarConstant");
+    const request = await this.makeTsFileUpdatePrompt({
+      context: `
+1. Overview of __scalar/<model>/<model>.constant.ts file
+${await this.getDocumentation("scalarConstant")}
+
+2. How to write Enums in __scalar/<model>/<model>.constant.ts file
+${await this.getDocumentation("enumConstant")}
+
+3. How to write Fields in __scalar/<model>/<model>.constant.ts file
+${await this.getDocumentation("fieldRule")}
+
+4. List of constant.ts files in other libraries connected to current ${this.sys.name} ${this.sys.type === "app" ? "Application" : "Library"} ${scanInfo.getLibs().map((lib) => lib).join(", ")}
+Please understand the content and file patterns below, and feel free to reuse any constants or enums if available.
+${constantFiles.map((constant) => `
+\`\`\`typescript
+// File: ${constant.filePath}
+${constant.content}
+\`\`\`
+`).join(`
+`)}
+		`,
+      request: `
+Based on the above content, please organize it according to the boilerplate below for easy parsing
+
+Application name: ${this.sys.name} (${this.sys.type === "app" ? "Application" : "Library"})
+Model name: ${this.name}
+Model description: ${modelDesc}
+Model schema design: ${modelSchemaDesign}
+Model filename(You can create another connected scalar model file if needed): ${this.name}.constant.ts
+\`\`\`typescript
+// File: lib/__scalar/${this.name}/${this.name}.constant.ts
+${boilerplate}
+\`\`\`
+
+If additional connected scalar models need to be written besides ${this.name}.constant.ts file, please write them in the following format
+\`\`\`typescript
+// File: lib/__scalar/otherModel/otherModel.constant.ts
+...file content
+\`\`\`
+
+Please provide only the file results without any other content.`
+    });
+    return { request, validate: guideJson.update.rules };
+  }
+  async requestUpdateDictonaryWithInstruction() {
+    const constant = await this.sys.readFile(`lib/__scalar/${this.name}/${this.name}.constant.ts`);
+    const boilerplate = await this.sys.readFile(`lib/__scalar/${this.name}/${this.name}.dictionary.ts`);
+    const guideJson = await Prompter.getGuideJson("scalarDictionary");
+    const request = `\uB2E4\uC74C ${this.name}.dictionary.ts \uD30C\uC77C\uB3C4 \uC644\uC131\uB41C ${this.name}.constant.ts \uD30C\uC77C\uC744 \uAE30\uBC18\uC73C\uB85C \uC791\uC131\uD574\uC918.
+1. Dictionary \uC791\uC131\uBC95
+${await this.getDocumentation("scalarDictionary")}
+
+Model constant file
+\`\`\`typescript
+// File: lib/__scalar/${this.name}/${this.name}.constant.ts
+${constant}
+\`\`\`
+
+Model filename: ${this.name}.dictionary.ts
+\`\`\`typescript
+// File: lib/__scalar/${this.name}/${this.name}.dictionary.ts
+${boilerplate}
+\`\`\`
+  `;
+    return { request, validate: guideJson.update.rules };
+  }
+  async requestUpdateDictonaryWithFollowing() {
+    const [constant, boilerplate] = await Promise.all([
+      this.sys.readFile(`lib/__scalar/${this.name}/${this.name}.constant.ts`),
+      this.sys.readFile(`lib/__scalar/${this.name}/${this.name}.dictionary.ts`)
+    ]);
+    const request = `\uB2E4\uC74C ${this.name}.dictionary.ts \uD30C\uC77C\uB3C4 \uC644\uC131\uB41C ${this.name}.constant.ts \uD30C\uC77C\uC744 \uAE30\uBC18\uC73C\uB85C \uC791\uC131\uD574\uC918.
+Model constant file
+\`\`\`typescript
+// File: lib/__scalar/${this.name}/${this.name}.constant.ts
+${constant}
+\`\`\`
+
+Model filename: ${this.name}.dictionary.ts
+\`\`\`typescript
+// File: lib/__scalar/${this.name}/${this.name}.dictionary.ts
+${boilerplate}
+\`\`\`
+  `;
+    return { request, validate: [] };
+  }
+}
+
+// pkgs/@akanjs/cli/scalar/scalar.runner.ts
+class ScalarRunner extends runner("scalar") {
+  async applyScalarTemplate(sys, scalarName) {
+    await sys.applyTemplate({
+      basePath: "./lib/__scalar",
+      template: "__scalar",
+      dict: { model: scalarName, models: pluralizeName(scalarName), sysName: sys.name },
+      overwrite: false
+    });
+    return {
+      abstract: {
+        filename: `${scalarName}.abstract.md`,
+        content: await sys.readFile(`lib/__scalar/${scalarName}/${scalarName}.abstract.md`)
+      },
+      constant: {
+        filename: `${scalarName}.constant.ts`,
+        content: await sys.readFile(`lib/__scalar/${scalarName}/${scalarName}.constant.ts`)
+      },
+      dictionary: {
+        filename: `${scalarName}.dictionary.ts`,
+        content: await sys.readFile(`lib/__scalar/${scalarName}/${scalarName}.dictionary.ts`)
+      },
+      document: {
+        filename: `${scalarName}.document.ts`,
+        content: await sys.readFile(`lib/__scalar/${scalarName}/${scalarName}.document.ts`)
+      }
+    };
+  }
+  async createScalarConstant(sys, scalarName) {
+    const isContinued = await sys.exists(`lib/__scalar/${scalarName}/${scalarName}.constant.ts`);
+    const prompt = new ScalarPrompt(sys, scalarName);
+    const session = new AiSession("createScalar", { workspace: sys.workspace, cacheKey: scalarName, isContinued });
+    const { request, validate } = session.isCacheLoaded ? await prompt.requestUpdateConstant() : await prompt.requestCreateConstant();
+    const writes = await session.writeTypescripts(request, sys, { validate });
+    const scalarNames = writes.map(({ filePath }) => filePath.split("/").at(-2)).filter((name) => !!name);
+    if (!scalarNames.includes(scalarName))
+      scalarNames.unshift(scalarName);
+    for (const name of scalarNames)
+      await this.applyScalarTemplate(sys, name);
+    return { session, scalarNames, writes, prompt };
+  }
+  async updateScalarDictionaries(sys, scalarNames, { session }) {
+    const [firstScalarName, ...followingScalarNames] = scalarNames;
+    const prompt = new ScalarPrompt(sys, firstScalarName);
+    const { request, validate } = await prompt.requestUpdateDictonaryWithInstruction();
+    await session.writeTypescripts(request, sys, { validate });
+    for (const scalarName of followingScalarNames) {
+      const prompt2 = new ScalarPrompt(sys, scalarName);
+      const { request: request2, validate: validate2 } = await prompt2.requestUpdateDictonaryWithFollowing();
+      await session.writeTypescripts(request2, sys, { validate: validate2 });
+    }
+  }
+}
+
+// pkgs/@akanjs/cli/scalar/scalar.script.ts
+class ScalarScript extends script("scalar", [ScalarRunner]) {
+  async createScalar(sys, scalarName) {
+    const files = await this.scalarRunner.applyScalarTemplate(sys, scalarName);
+    return createPassedPrimitiveReport({
+      command: "create-scalar",
+      changedFiles: scalarChangedFiles(sys, scalarName, files),
+      generatedFiles: generatedFilesForSync(sys),
+      target: sys.name
+    });
+  }
+  async createScalarWithAi(sys, scalarName) {
+    const { session, scalarNames } = await this.scalarRunner.createScalarConstant(sys, scalarName);
+    await this.scalarRunner.updateScalarDictionaries(sys, scalarNames, { session });
+    const fileMaps = await Promise.all(scalarNames.map(async (name) => ({ name, files: await this.scalarRunner.applyScalarTemplate(sys, name) })));
+    return createPassedPrimitiveReport({
+      command: "create-scalar",
+      changedFiles: fileMaps.flatMap(({ name, files }) => scalarChangedFiles(sys, name, files)),
+      generatedFiles: generatedFilesForSync(sys),
+      target: sys.name
+    });
+  }
+  async removeScalar(sys, scalarName) {
+    await sys.removeDir(`lib/__scalar/${scalarName}`);
+  }
+}
+
+export { ScalarScript };

package/index-z9gvz7b0.js

@@ -0,0 +1,83 @@
+// @bun
+import {
+  CloudRunner
+} from "./index-sgmas1fc.js";
+import {
+  ApplicationScript
+} from "./index-77crfweb.js";
+import {
+  PackageScript
+} from "./index-wq8jwx8z.js";
+import {
+  AiSession,
+  CloudApi,
+  GlobalConfig
+} from "./index-5vvwc0cz.js";
+import {
+  script
+} from "./index-hdqztm58.js";
+import {
+  PkgExecutor
+} from "./index-a6sbyy0b.js";
+
+// pkgs/@akanjs/cli/cloud/cloud.script.ts
+import { Logger } from "akanjs/common";
+class CloudScript extends script("cloud", [CloudRunner, ApplicationScript, PackageScript]) {
+  async login(workspace, host = GlobalConfig.akanCloudHost) {
+    await this.cloudRunner.login(host, workspace);
+  }
+  async logout(workspace, host = GlobalConfig.akanCloudHost) {
+    await this.cloudRunner.logout(host);
+  }
+  async setLlm(workspace) {
+    await this.cloudRunner.setLlm();
+  }
+  resetLlm(workspace) {
+    this.cloudRunner.resetLlm();
+  }
+  async ask(question, workspace) {
+    const session = new AiSession("general", { workspace, isContinued: true });
+    await session.ask(question);
+  }
+  async downloadEnv(workspace, workspaceId = workspace.getWorkspaceId({ allowEmpty: true }), { host = GlobalConfig.akanCloudHost } = {}) {
+    if (workspaceId) {
+      await this.login(workspace, host);
+      const cloudApi = await CloudApi.fromHost(workspace, host);
+      await this.cloudRunner.downloadEnv(cloudApi, workspace, workspaceId);
+      return;
+    }
+    await this.cloudRunner.downloadEnvByScp(workspace);
+  }
+  async uploadEnv(workspace, { host = GlobalConfig.akanCloudHost } = {}) {
+    const workspaceId = workspace.getWorkspaceId({ allowEmpty: true });
+    const { path } = await this.cloudRunner.gatherEnvFiles(workspace);
+    if (workspaceId) {
+      await this.login(workspace, host);
+      const cloudApi = await CloudApi.fromHost(workspace, host);
+      await this.cloudRunner.uploadEnv(cloudApi, workspaceId, path);
+      return;
+    }
+    await this.cloudRunner.uploadEnvByScp(workspace, path);
+  }
+  async deployAkan(workspace, { test = true, registryUrl } = {}) {
+    const akanPkgs = await this.cloudRunner.getAkanPkgs(workspace);
+    await this.packageScript.updateWorskpaceRootPackageJson(workspace);
+    const pkgs = akanPkgs.map((pkgName) => PkgExecutor.from(workspace, pkgName));
+    if (test)
+      for (const pkg of pkgs)
+        await this.applicationScript.test(pkg);
+    for (const pkg of pkgs)
+      await this.packageScript.buildPackage(pkg);
+    await this.packageScript.verifyAkanPublishPackages(workspace);
+    await this.cloudRunner.deployAkan(workspace, akanPkgs, { registryUrl });
+  }
+  async update(workspace, tag = "latest", { registryUrl } = {}) {
+    const spinner = workspace.spinning("Updating Akan.js packages and CLI...");
+    await this.cloudRunner.update(workspace, tag, { registryUrl });
+    spinner.succeed("Akan.js packages and CLI updated, global version is below");
+    Logger.raw("> Akan version: ");
+    await workspace.spawn("akan", ["--version"], { stdio: "inherit" });
+  }
+}
+
+export { CloudScript };