akanjs 0.0.1 → 2.0.0-beta.0

package/cli/application/application.runner.ts

@@ -0,0 +1,359 @@
+import path from "node:path";
+import { confirm, input, select } from "@inquirer/prompts";
+import { StringOutputParser } from "@langchain/core/output_parsers";
+import { PromptTemplate } from "@langchain/core/prompts";
+import { RunnableSequence } from "@langchain/core/runnables";
+import { ChatOpenAI } from "@langchain/openai";
+import { Logger } from "akanjs/common";
+import {
+  AkanAppHost,
+  type App,
+  AppExecutor,
+  ApplicationBuildRunner,
+  ApplicationReleasePackager,
+  type BuildProgressReporter,
+  type BuildResult,
+  CapacitorApp,
+  type DatabaseMode,
+  type Exec,
+  LibExecutor,
+  type MobileEnv,
+  type ReleaseSourceOptions,
+  type ResolvedMobileTarget,
+  resolveMobileTargets,
+  runner,
+  type TypecheckOptions,
+  type Workspace,
+} from "akanjs/devkit";
+import openBrowser from "open";
+import ora from "ora";
+
+export class ApplicationRunner extends runner("application") {
+  async createApplication(appName: string, workspace: Workspace, libs: string[] = []) {
+    await workspace.applyTemplate({
+      basePath: `apps/${appName}`,
+      template: "app",
+      dict: { appName, companyName: workspace.repoName, startDomain: "localhost" },
+      options: { libs },
+    });
+    await workspace.setTsPaths("app", appName);
+    return AppExecutor.from(workspace, appName);
+  }
+  async removeApplication(app: App) {
+    await app.workspace.exec(`rm -rf apps/${app.name}`);
+    await app.workspace.unsetTsPaths("app", app.name);
+  }
+  async getConfig(app: App) {
+    return await app.getConfig();
+  }
+
+  async getScriptFilename(app: App) {
+    if (!(await app.exists("script"))) {
+      await app.mkdir("script");
+      throw new Error(`No script files found. make a script file in apps/${app.name}/script folder`);
+    }
+    const scriptFiles = (await app.readdir("script")).filter((file) => file.endsWith(".ts"));
+    const scriptFile = await select({
+      message: "Select script to run",
+      choices: scriptFiles.map((file) => ({ name: file, value: file.replace(".ts", "") })),
+    });
+    return scriptFile;
+  }
+  async runScript(app: App, filename: string) {
+    const scriptName = filename.endsWith(".ts") ? filename.slice(0, -3) : filename;
+    if (scriptName.includes("/") || scriptName.includes("\\") || scriptName.includes("..")) {
+      throw new Error(`Invalid script filename: ${filename}`);
+    }
+    const scriptPath = `script/${scriptName}.ts`;
+    if (!(await app.exists(scriptPath))) throw new Error(`Script file not found: apps/${app.name}/${scriptPath}`);
+    await app.spawn("bun", [scriptPath], {
+      env: app.getCommandEnv({ AKAN_COMMAND_TYPE: "script" }),
+      stdio: "inherit",
+    });
+  }
+  async typecheck(app: App, options: TypecheckOptions = {}) {
+    await new ApplicationBuildRunner(app).typecheck(options);
+  }
+  async test(exec: Exec) {
+    const isSignalTarget = exec instanceof AppExecutor || exec instanceof LibExecutor;
+    const preloadPath = path.join(exec.cwdPath, "../../pkgs/akanjs/test/signalTest.preload.ts");
+    const env = isSignalTarget
+      ? {
+          AKAN_TEST_SIGNAL: "1",
+          AKAN_TEST_TARGET_TYPE: exec.type,
+          AKAN_TEST_TARGET_NAME: exec.name,
+          AKAN_TEST_LIBS: exec.getScanInfo({ allowEmpty: true })?.getLibs().join(",") ?? "",
+        }
+      : {};
+    const args = isSignalTarget ? ["test", "--isolate", "--preload", preloadPath] : ["test", "--isolate"];
+    await exec.spawn("bun", args, {
+      ...(isSignalTarget ? { env: { ...process.env, ...env } } : {}),
+      stdio: "inherit",
+    });
+  }
+  async build(
+    app: App,
+    {
+      fast = false,
+      reporter,
+      spinner = false,
+    }: { fast?: boolean; reporter?: BuildProgressReporter; spinner?: boolean } = {},
+  ): Promise<BuildResult> {
+    return new ApplicationBuildRunner(app, { fast, reporter }).build({ spinner });
+  }
+  async start(
+    app: App,
+    { open = false, onStart, withInk = false }: { open?: boolean; onStart?: () => void; withInk?: boolean } = {},
+  ) {
+    const { env } = await app.prepareCommand("start");
+    const appHost = await new AkanAppHost(app, { env, withInk }).start();
+    onStart?.();
+    if (open) setTimeout(() => openBrowser("http://localhost:8282"), 3000);
+    return appHost;
+  }
+
+  async buildIos(
+    app: App,
+    { target, env = "debug", regenerate = false }: { target?: string; env?: MobileEnv; regenerate?: boolean } = {},
+  ) {
+    const targets = await resolveMobileTargets(app, target);
+    await this.#buildMobileCsr(app, env);
+    await this.#runMobileTargets(targets, async (mobileTarget) => {
+      await new CapacitorApp(app, mobileTarget.config).buildIos({ regenerate });
+    });
+  }
+  async startIos(
+    app: App,
+    {
+      open = false,
+      operation = "local",
+      env = "local",
+      target,
+      regenerate = false,
+    }: {
+      open?: boolean;
+      operation?: "local" | "release";
+      env?: MobileEnv;
+      target?: string;
+      regenerate?: boolean;
+    } = {},
+  ) {
+    const targets = await resolveMobileTargets(app, target);
+    if (operation === "release") await this.#buildMobileCsr(app, env);
+    else await this.start(app);
+    await this.#runMobileTargets(targets, async (mobileTarget) => {
+      const capacitorApp = new CapacitorApp(app, mobileTarget.config);
+      await capacitorApp.runIos({ operation, env, regenerate });
+      if (open) await capacitorApp.openIos();
+    });
+  }
+  async releaseIos(
+    app: App,
+    { target, env = "main", regenerate = false }: { target?: string; env?: MobileEnv; regenerate?: boolean } = {},
+  ) {
+    const targets = await resolveMobileTargets(app, target);
+    await this.#buildMobileCsr(app, env);
+    for (const mobileTarget of targets) {
+      await new CapacitorApp(app, mobileTarget.config).buildIos({ regenerate });
+    }
+  }
+
+  async buildAndroid(
+    app: App,
+    { target, env = "debug", regenerate = false }: { target?: string; env?: MobileEnv; regenerate?: boolean } = {},
+  ) {
+    const targets = await resolveMobileTargets(app, target);
+    await this.#buildMobileCsr(app, env);
+    await this.#runMobileTargets(targets, async (mobileTarget) => {
+      await new CapacitorApp(app, mobileTarget.config).buildAndroid("apk", { regenerate });
+    });
+  }
+
+  async startAndroid(
+    app: App,
+    {
+      open = false,
+      operation = "local",
+      env = "local",
+      target,
+      regenerate = false,
+    }: {
+      open?: boolean;
+      operation?: "local" | "release";
+      env?: MobileEnv;
+      target?: string;
+      regenerate?: boolean;
+    } = {},
+  ) {
+    const targets = await resolveMobileTargets(app, target);
+    if (operation === "release") await this.#buildMobileCsr(app, env);
+    else await this.start(app);
+    await this.#runMobileTargets(targets, async (mobileTarget) => {
+      const capacitorApp = new CapacitorApp(app, mobileTarget.config);
+      await capacitorApp.runAndroid({ operation, env, regenerate });
+      if (open) await capacitorApp.openAndroid();
+    });
+  }
+
+  async releaseAndroid(
+    app: App,
+    assembleType: "apk" | "aab",
+    { target, env = "main", regenerate = false }: { target?: string; env?: MobileEnv; regenerate?: boolean } = {},
+  ) {
+    const targets = await resolveMobileTargets(app, target);
+    await this.#buildMobileCsr(app, env);
+    for (const mobileTarget of targets) {
+      await new CapacitorApp(app, mobileTarget.config).buildAndroid(assembleType, { regenerate });
+      app.log(`Release Android ${app.name}/${mobileTarget.name} ${assembleType} Completed.`);
+      app.log(
+        `Path : ${app.cwdPath}/mobile/${mobileTarget.name}/android/app/build/outputs/${assembleType === "apk" ? "apk" : "bundle"}/release`,
+      );
+    }
+  }
+
+  async #buildMobileCsr(app: App, env: MobileEnv) {
+    const prevEnv = {
+      AKAN_PUBLIC_ENV: process.env.AKAN_PUBLIC_ENV,
+      AKAN_PUBLIC_OPERATION_MODE: process.env.AKAN_PUBLIC_OPERATION_MODE,
+      APP_OPERATION_MODE: process.env.APP_OPERATION_MODE,
+    };
+    Object.assign(process.env, {
+      AKAN_PUBLIC_ENV: env,
+      AKAN_PUBLIC_OPERATION_MODE: env === "local" ? "local" : "cloud",
+      APP_OPERATION_MODE: "release",
+    });
+    try {
+      await new ApplicationBuildRunner(app).build({ spinner: true });
+    } finally {
+      for (const [key, value] of Object.entries(prevEnv)) {
+        if (value === undefined) delete process.env[key];
+        else process.env[key] = value;
+      }
+    }
+  }
+  async #runMobileTargets(targets: ResolvedMobileTarget[], task: (target: ResolvedMobileTarget) => Promise<void>) {
+    const results: { target: string; error?: unknown }[] = [];
+    for (const target of targets) {
+      try {
+        await task(target);
+        results.push({ target: target.name });
+      } catch (error) {
+        results.push({ target: target.name, error });
+      }
+    }
+    const failures = results.filter((result) => result.error);
+    if (failures.length === 0) return;
+    for (const failure of failures) {
+      const message = failure.error instanceof Error ? failure.error.message : String(failure.error);
+      Logger.rawLog(`Mobile target ${failure.target} failed: ${message}`, undefined, "error");
+    }
+    throw new Error(`${failures.length}/${results.length} mobile targets failed`);
+  }
+
+  async codepush(app: App, os: "ios" | "android") {
+    const [target] = await resolveMobileTargets(app, undefined);
+    if (!target) throw new Error(`No mobile target configured for ${app.name}`);
+    const capacitorApp = new CapacitorApp(app, target.config);
+    await capacitorApp.init();
+
+  }
+
+  #getLocalDatabaseServices(mode: DatabaseMode): string[] {
+    if (mode === "single") return [];
+    if (mode === "multiple") return ["redis", "libsql"];
+    return ["redis", "postgres"];
+  }
+  async #isLocalDatabaseUp(workspace: Workspace, mode: DatabaseMode) {
+    const requiredServices = this.#getLocalDatabaseServices(mode);
+    if (!requiredServices.length) return true;
+    const output = await workspace.spawn("docker", ["compose", "ps", "--services", "--status", "running"], {
+      cwd: `${workspace.workspaceRoot}/local`,
+    });
+    const runningServices = new Set(output.split(/\s+/).filter(Boolean));
+    return requiredServices.every((service) => runningServices.has(service));
+  }
+  async dbup(workspace: Workspace, mode: DatabaseMode = "multiple"): Promise<boolean> {
+    if (mode === "single") return true;
+    try {
+      await workspace.applyTemplate({
+        basePath: "local",
+        template: "localDev",
+        dict: { repoName: workspace.repoName },
+        overwrite: false,
+      });
+      const wasAlreadyUp = await this.#isLocalDatabaseUp(workspace, mode);
+      if (!wasAlreadyUp)
+        await workspace.spawn(`docker`, ["compose", "up", "-d", ...this.#getLocalDatabaseServices(mode)], {
+          cwd: `${workspace.workspaceRoot}/local`,
+        });
+      return wasAlreadyUp;
+    } catch {
+      throw new Error(`Docker daemon is not running. Please install docker or start docker daemon and try again.`);
+    }
+  }
+  async dbdown(workspace: Workspace) {
+    await workspace.spawn(`docker`, ["compose", "down"], { cwd: `${workspace.workspaceRoot}/local` });
+  }
+
+  async configureApp(app: App) {
+    const [target] = await resolveMobileTargets(app, undefined);
+    if (!target) throw new Error(`No mobile target configured for ${app.name}`);
+    const capacitorApp = new CapacitorApp(app, target.config);
+    await capacitorApp.init();
+    
+    if (await confirm({ message: "want to add camera permission?" })) await capacitorApp.addCamera();
+    if (await confirm({ message: "want to add contact permission?" })) await capacitorApp.addContact();
+    if (await confirm({ message: "want to add location permission?" })) await capacitorApp.addLocation();
+    await capacitorApp.save();
+  }
+
+  async releaseSource(
+    app: App,
+    { rebuild, buildNum = 0, environment = "debug", local = true }: ReleaseSourceOptions = {},
+  ) {
+    await new ApplicationReleasePackager(app, { build: () => this.build(app).then(() => undefined) }).releaseSource({
+      rebuild,
+      buildNum,
+      environment,
+      local,
+    });
+    return;
+  }
+
+  async createApplicationTemplate(workspace: Workspace, appName: string) {
+    await workspace.applyTemplate({ basePath: `apps/${appName}`, template: "appRoot", dict: { appName } });
+  }
+
+  async compressProjectFiles(
+    app: App,
+    { rebuild, buildNum = 0, environment = "debug", local = true }: ReleaseSourceOptions = {},
+  ) {
+    await new ApplicationReleasePackager(app, {
+      build: () => this.build(app).then(() => undefined),
+    }).compressProjectFiles({
+      rebuild,
+      buildNum,
+      environment,
+      local,
+    });
+    return;
+  }
+
+  async generateApplicationTemplate(app: App) {
+    const openAIApiKey = process.env.OPENAI_API_KEY;
+    if (!openAIApiKey) throw new Error("OPENAI_API_KEY is not set");
+    const chatModel = new ChatOpenAI({ modelName: "gpt-4o", openAIApiKey });
+    const projectName = await input({ message: "please enter project name." });
+    const projectDesc = await input({ message: "please enter project description. (40 ~ 60 characters)" });
+    const spinner = ora("Gerating project files...");
+
+    const mainPrompt = PromptTemplate.fromTemplate(`prompt.requestApplication()`);
+    const chain = RunnableSequence.from([mainPrompt, chatModel, new StringOutputParser()]);
+    await chain.invoke({ projectName, projectDesc });
+    spinner.succeed("Loading complete!");
+
+  }
+
+  async testApplication(app: App) {
+  }
+}

package/cli/application/application.script.ts

@@ -0,0 +1,244 @@
+import { Logger } from "akanjs/common";
+import {
+  type App,
+  ApplicationBuildReporter,
+  type DatabaseMode,
+  type Exec,
+  type Lib,
+  LibExecutor,
+  type MobileEnv,
+  PkgExecutor,
+  type ReleaseSourceOptions,
+  type Sys,
+  script,
+  type TypecheckOptions,
+  type Workspace,
+} from "akanjs/devkit";
+import { LibraryScript } from "../library/library.script";
+import { ApplicationRunner } from "./application.runner";
+
+type MobileOperation = "local" | "release";
+type MobileCommandOptions = {
+  target?: string;
+  env?: MobileEnv;
+  write?: boolean;
+  regenerate?: boolean;
+};
+type MobileReleaseOptions = MobileCommandOptions & {
+  allowLocalRelease?: boolean;
+};
+
+export class ApplicationScript extends script("application", [ApplicationRunner, LibraryScript]) {
+  async createApplication(
+    appName: string,
+    workspace: Workspace,
+    { start = false, libs = [] }: { start?: boolean; libs?: string[] } = {},
+  ) {
+    const spinner = workspace.spinning("Creating application...");
+    const app = await this.applicationRunner.createApplication(appName, workspace, libs);
+    spinner.succeed(`Application created in apps/${app.name}`);
+    await app.scanSync();
+    if (start) await this.start(app, { open: true });
+  }
+  async removeApplication(app: App) {
+    const spinner = app.spinning("Removing application...");
+    await this.applicationRunner.removeApplication(app);
+    spinner.succeed(`Application ${app.name} (apps/${app.name}) removed`);
+  }
+  async sync(sys: Sys) {
+    if (sys.type === "app") await (sys as App).scanSync();
+    else await this.libraryScript.syncLibrary(sys as Lib);
+  }
+
+  async script(app: App, filename: string | null) {
+    const scriptFilename = filename ?? (await this.applicationRunner.getScriptFilename(app));
+    await app.scanSync();
+    await this.applicationRunner.runScript(app, scriptFilename);
+  }
+
+  async build(
+    app: App,
+    { write = true, fast = false, quiet = false }: { write?: boolean; fast?: boolean; quiet?: boolean } = {},
+  ) {
+    await app.scanSync({ write });
+    if (!quiet) Logger.rawLog(`Creating an optimized production build for ${app.name}...`);
+    try {
+      const result = await this.applicationRunner.build(app, {
+        fast,
+        spinner: !quiet,
+      });
+      Logger.rawLog(`${app.name} built in dist/apps/${app.name}`);
+      if (!quiet) ApplicationBuildReporter.printSummary(result);
+    } catch (error) {
+      Logger.rawLog(`${app.name} build failed in dist/apps/${app.name}`, undefined, "error");
+      Logger.rawLog(ApplicationBuildReporter.formatError(error), undefined, "error");
+      throw error;
+    }
+  }
+
+  async typecheck(
+    app: App,
+    { write = true, clean = false, incremental = true }: TypecheckOptions & { write?: boolean } = {},
+  ) {
+    await app.scanSync({ write });
+    const spinner = app.spinning(`Typechecking ${app.name}...`);
+    try {
+      await this.applicationRunner.typecheck(app, { clean, incremental });
+      spinner.succeed(`${app.name} typechecked`);
+    } catch (error) {
+      spinner.fail(`${app.name} typecheck failed`);
+      Logger.rawLog(ApplicationBuildReporter.formatError(error), undefined, "error");
+      throw error;
+    }
+  }
+
+  async test(exec: Exec, { write = true }: { write?: boolean } = {}) {
+    const spinner = exec.spinning(`Preparing ${exec.name}...`);
+    try {
+      if (exec instanceof PkgExecutor) await exec.scan({ refresh: true });
+      else if (exec instanceof LibExecutor) await this.libraryScript.syncLibrary(exec);
+      else await (exec as App).scanSync({ write });
+      spinner.succeed(`${exec.name} prepared`);
+    } catch (error) {
+      spinner.fail(`${exec.name} prepare failed`);
+      throw error;
+    }
+    await this.applicationRunner.test(exec);
+  }
+
+  async start(
+    app: App,
+    {
+      open = false,
+      dbup = true,
+      withInk = false,
+      write = true,
+    }: { open?: boolean; dbup?: boolean; withInk?: boolean; write?: boolean } = {},
+  ) {
+    await app.scanSync({ write });
+    const akanConfig = await app.getConfig();
+    const databaseMode = (process.env.AKAN_DATABASE_MODE ?? akanConfig.defaultDatabaseMode ?? "single") as DatabaseMode;
+    if (app.getEnv() === "local" && dbup && databaseMode !== "single") {
+      const wasDbAlreadyUp = await this.dbup(app.workspace, databaseMode);
+      if (!wasDbAlreadyUp)
+        process.on("SIGINT", async () => {
+          await this.dbdown(app.workspace);
+          process.exit(0);
+        });
+    }
+    const spinner = app.spinning("Preparing backend...");
+    const akanAppHost = await this.applicationRunner.start(app, {
+      open,
+      onStart: () => {
+        spinner.succeed(`${app.name} prepared, ready to start`);
+      },
+      withInk,
+    });
+    return akanAppHost;
+  }
+
+  async buildIos(app: App, { write = true, target, env = "debug", regenerate = false }: MobileCommandOptions = {}) {
+    await app.scanSync({ write });
+    await this.applicationRunner.buildIos(app, { target, env, regenerate });
+  }
+  async startIos(
+    app: App,
+    {
+      open = false,
+      operation = "local",
+      env = "local",
+      write = true,
+      target,
+      regenerate = false,
+    }: {
+      operation?: MobileOperation;
+      env?: MobileEnv;
+      open?: boolean;
+      write?: boolean;
+      target?: string;
+      regenerate?: boolean;
+    } = {},
+  ) {
+    await app.scanSync({ write });
+    await this.applicationRunner.startIos(app, { open, operation, env, target, regenerate });
+  }
+  async releaseIos(
+    app: App,
+    { write = true, target, env = "main", regenerate = false, allowLocalRelease = false }: MobileReleaseOptions = {},
+  ) {
+    await app.scanSync({ write });
+    if (env === "local" && !allowLocalRelease)
+      throw new Error(
+        "releaseIos --env local is blocked. Pass allowLocalRelease only for explicit local release testing.",
+      );
+    await this.applicationRunner.releaseIos(app, { target, env, regenerate });
+  }
+  async buildAndroid(app: App, { write = true, target, env = "debug", regenerate = false }: MobileCommandOptions = {}) {
+    await app.scanSync({ write });
+    await this.applicationRunner.buildAndroid(app, { target, env, regenerate });
+  }
+  async startAndroid(
+    app: App,
+    {
+      open = false,
+      operation = "local",
+      env = "local",
+      write = true,
+      target,
+      regenerate = false,
+    }: {
+      open?: boolean;
+      env?: MobileEnv;
+      operation?: MobileOperation;
+      write?: boolean;
+      target?: string;
+      regenerate?: boolean;
+    } = {},
+  ) {
+    await app.scanSync({ write });
+    await this.applicationRunner.startAndroid(app, { open, operation, env, target, regenerate });
+  }
+  
+  async releaseAndroid(
+    app: App,
+    assembleType: "apk" | "aab",
+    { write = true, target, env = "main", regenerate = false, allowLocalRelease = false }: MobileReleaseOptions = {},
+  ) {
+    await app.scanSync({ write });
+    if (env === "local" && !allowLocalRelease)
+      throw new Error(
+        "releaseAndroid --env local is blocked. Pass allowLocalRelease only for explicit local release testing.",
+      );
+    await this.applicationRunner.releaseAndroid(app, assembleType, { target, env, regenerate });
+  }
+
+  async configureApp(app: App) {
+    await this.applicationRunner.configureApp(app);
+  }
+  async releaseSource(app: App, options: ReleaseSourceOptions) {
+    await this.applicationRunner.releaseSource(app, options);
+  }
+  async codepush(app: App, os: "ios" | "android") {
+    await this.applicationRunner.codepush(app, os);
+  }
+  async dbup(workspace: Workspace, mode: DatabaseMode = "multiple"): Promise<boolean> {
+    const spinner = workspace.spinning(`Starting local database (${mode})...`);
+    const wasAlreadyUp = await this.applicationRunner.dbup(workspace, mode);
+    spinner.succeed(wasAlreadyUp ? `Local database (${mode}) was already up` : `Local database (${mode}) is up`);
+    return wasAlreadyUp;
+  }
+  async dbdown(workspace: Workspace) {
+    const spinner = workspace.spinning("Stopping local database...");
+    await this.applicationRunner.dbdown(workspace);
+    spinner.succeed("Local database (/local/docker-compose.yaml) is down");
+  }
+  async testSys(sys: Sys) {
+    if (sys.type === "app") await this.testApplication(sys as App);
+    else await this.libraryScript.testLibrary(sys as Lib);
+  }
+  async testApplication(app: App) {
+    const spinner = app.spinning("Testing application...");
+    await this.applicationRunner.testApplication(app);
+    spinner.succeed(`Application ${app.name} (apps/${app.name}) test is successful`);
+  }
+}

package/cli/build.ts

@@ -0,0 +1,25 @@
+import { $ } from "bun";
+
+const CLI_DIR = import.meta.dir;
+const PACKAGE_DIR = `${CLI_DIR}/..`;
+const WORKSPACE_ROOT = process.env.WORKSPACE_ROOT ?? process.cwd();
+const OUT_DIR = process.env.DIST_DIR ?? `${WORKSPACE_ROOT}/dist/pkgs/akanjs`;
+
+const build = async () => {
+  try {
+    await $`rm -rf ${OUT_DIR}/cli`;
+    await Bun.build({
+      entrypoints: [`${CLI_DIR}/index.ts`],
+      splitting: false,
+      target: "bun",
+      outdir: `${OUT_DIR}/cli`,
+      external: Object.keys((await Bun.file(`${PACKAGE_DIR}/package.json`).json()).dependencies ?? {}),
+    });
+    await $`cp -R ${CLI_DIR}/templates ${OUT_DIR}/cli/templates`;
+  } catch (error) {
+    console.error(error);
+    process.exit(1);
+  }
+};
+
+build();

package/cli/cloud/cloud.command.ts

@@ -0,0 +1,48 @@
+import { command, Workspace } from "akanjs/devkit";
+
+import { CloudScript } from "./cloud.script";
+
+export class CloudCommand extends command("cloud", [CloudScript], ({ public: target }) => ({
+  login: target({ desc: "Login to Akan Cloud services" })
+    .with(Workspace)
+    .exec(async function (workspace) {
+      await this.cloudScript.login(workspace);
+    }),
+  logout: target({ desc: "Logout from Akan Cloud services" })
+    .with(Workspace)
+    .exec(async function (workspace) {
+      await this.cloudScript.logout(workspace);
+    }),
+  setLlm: target({ desc: "Configure LLM (Large Language Model) API key" })
+    .with(Workspace)
+    .exec(async function (workspace) {
+      await this.cloudScript.setLlm(workspace);
+    }),
+  resetLlm: target({ desc: "Reset LLM configuration to default" })
+    .with(Workspace)
+    .exec(function (workspace) {
+      this.cloudScript.resetLlm(workspace);
+    }),
+  ask: target({ desc: "Ask AI assistant a question about your project" })
+    .option("question", String, { ask: "question to ask" })
+    .with(Workspace)
+    .exec(async function (question, workspace) {
+      await this.cloudScript.ask(question, workspace);
+    }),
+  deployAkan: target({ devOnly: true, desc: "Deploy Akan.js framework to cloud (internal use)" })
+    .option("test", Boolean, { desc: "test the deployment", default: true })
+    .with(Workspace)
+    .exec(async function (test, workspace) {
+      await this.cloudScript.deployAkan(workspace, { test });
+    }),
+  update: target({ desc: "Update Akan.js framework to the latest version" })
+    .with(Workspace)
+    .option("tag", String, {
+      desc: "tag of the update",
+      default: "latest",
+      enum: ["latest", "dev", "canary", "beta", "rc", "alpha"],
+    })
+    .exec(async function (workspace, tag) {
+      await this.cloudScript.update(workspace, tag);
+    }),
+})) {}