@akanjs/devkit 2.1.1-rc.0 → 2.1.1-rc.2

package/aiEditor.ts

@@ -12,14 +12,17 @@ import { ChatOpenAI } from "@langchain/openai";
 import { Logger } from "akanjs/common";
 import chalk from "chalk";
 
-import { getAkanGlobalConfig, setAkanGlobalConfig } from "./auth";
+import { GlobalConfig } from "./cloud";
 import type { Executor, WorkspaceExecutor } from "./executors";
 import { Spinner } from "./spinner";
 import type { FileContent } from "./types";
 
 const MAX_ASK_TRY = 300;
 
-export const supportedLlmModels = ["deepseek-chat", "deepseek-reasoner"] as const;
+export const supportedLlmModels = [
+  "deepseek-chat",
+  "deepseek-reasoner",
+] as const;
 export type SupportedLlmModel = (typeof supportedLlmModels)[number];
 
 interface EditOptions {
@@ -33,15 +36,30 @@ interface EditOptions {
 export class AiSession {
   static #cacheDir = "node_modules/.cache/akan/aiSession";
   static #chat: ChatDeepSeek | ChatOpenAI | null = null;
-  static async init({ temperature = 0, useExisting = true }: { temperature?: number; useExisting?: boolean } = {}) {
+  static async init({
+    temperature = 0,
+    useExisting = true,
+  }: {
+    temperature?: number;
+    useExisting?: boolean;
+  } = {}) {
     if (useExisting) {
       const llmConfig = await AiSession.getLlmConfig();
       if (llmConfig) {
         AiSession.#setChatModel(llmConfig.model, llmConfig.apiKey);
-        Logger.rawLog(chalk.dim(`🤖akan editor uses existing LLM config (${llmConfig.model})`));
+        Logger.rawLog(
+          chalk.dim(
+            `🤖akan editor uses existing LLM config (${llmConfig.model})`,
+          ),
+        );
         return AiSession;
       }
-    } else Logger.rawLog(chalk.yellow("🤖akan-editor is not initialized. LLM configuration should be set first."));
+    } else
+      Logger.rawLog(
+        chalk.yellow(
+          "🤖akan-editor is not initialized. LLM configuration should be set first.",
+        ),
+      );
 
     const llmConfig = await AiSession.#requestLlmConfig();
     const { model, apiKey } = llmConfig;
@@ -51,7 +69,11 @@ export class AiSession {
     await session.setLlmConfig({ model, apiKey });
     return session;
   }
-  static #setChatModel(model: SupportedLlmModel, apiKey: string, { temperature = 0 }: { temperature?: number } = {}) {
+  static #setChatModel(
+    model: SupportedLlmModel,
+    apiKey: string,
+    { temperature = 0 }: { temperature?: number } = {},
+  ) {
     AiSession.#chat = new ChatDeepSeek({
       modelName: model,
       temperature,
@@ -62,22 +84,26 @@ export class AiSession {
     return AiSession;
   }
   static async getLlmConfig() {
-    const akanConfig = await getAkanGlobalConfig();
-    return akanConfig.llm ?? null;
+    return await GlobalConfig.getLlmConfig();
   }
-  static async setLlmConfig(llmConfig: { model: SupportedLlmModel; apiKey: string } | null) {
-    const akanConfig = await getAkanGlobalConfig();
-    akanConfig.llm = llmConfig;
-    await setAkanGlobalConfig(akanConfig);
+  static async setLlmConfig(
+    llmConfig: { model: SupportedLlmModel; apiKey: string } | null,
+  ) {
+    await GlobalConfig.setLlmConfig(llmConfig);
     return AiSession;
   }
   static async #requestLlmConfig() {
-    const model = await select<SupportedLlmModel>({ message: "Select a LLM model", choices: supportedLlmModels });
+    const model = await select<SupportedLlmModel>({
+      message: "Select a LLM model",
+      choices: supportedLlmModels,
+    });
     const apiKey = await input({ message: "Enter your API key" });
     return { model, apiKey };
   }
   static async #validateApiKey(modelName: SupportedLlmModel, apiKey: string) {
-    const spinner = new Spinner("Validating LLM API key...", { prefix: `🤖akan-editor` }).start();
+    const spinner = new Spinner("Validating LLM API key...", {
+      prefix: `🤖akan-editor`,
+    }).start();
     const chat = new ChatOpenAI({
       modelName,
       temperature: 0,
@@ -107,7 +133,15 @@ export class AiSession {
   workspace: WorkspaceExecutor;
   constructor(
     type: string,
-    { workspace, cacheKey, isContinued }: { workspace: WorkspaceExecutor; cacheKey?: string; isContinued?: boolean },
+    {
+      workspace,
+      cacheKey,
+      isContinued,
+    }: {
+      workspace: WorkspaceExecutor;
+      cacheKey?: string;
+      isContinued?: boolean;
+    },
   ) {
     this.workspace = workspace;
     this.sessionKey = `${type}${cacheKey ? `-${cacheKey}` : ""}`;
@@ -126,7 +160,10 @@ export class AiSession {
   }
   async #saveCache() {
     const cacheFilePath = `${AiSession.#cacheDir}/${this.sessionKey}.json`;
-    await this.workspace.writeJson(cacheFilePath, mapChatMessagesToStoredMessages(this.messageHistory));
+    await this.workspace.writeJson(
+      cacheFilePath,
+      mapChatMessagesToStoredMessages(this.messageHistory),
+    );
   }
   async ask(
     question: string,
@@ -142,7 +179,8 @@ export class AiSession {
     if (!AiSession.#chat) await AiSession.init();
     if (this.#cacheLoadPromise) await this.#cacheLoadPromise;
 
-    if (!AiSession.#chat) throw new Error("Failed to initialize the AI session");
+    if (!AiSession.#chat)
+      throw new Error("Failed to initialize the AI session");
     const loader = new Spinner(`${AiSession.#chat.model} is thinking...`, {
       prefix: `🤖akan-editor`,
     }).start();
@@ -154,10 +192,13 @@ export class AiSession {
         fullResponse = "",
         tokenIdx = 0;
       for await (const chunk of stream) {
-        if (loader.isSpinning()) loader.succeed(`${AiSession.#chat.model} responded`);
+        if (loader.isSpinning())
+          loader.succeed(`${AiSession.#chat.model} responded`);
 
         if (!fullResponse.length) {
-          const reasoningContent = (chunk.additional_kwargs as { reasoning_content?: string }).reasoning_content ?? "";
+          const reasoningContent =
+            (chunk.additional_kwargs as { reasoning_content?: string })
+              .reasoning_content ?? "";
           if (reasoningContent.length) {
             reasoningResponse += reasoningContent;
             onReasoning(reasoningContent);
@@ -184,7 +225,16 @@ export class AiSession {
       throw new Error("Failed to stream response");
     }
   }
-  async edit(question: string, { onChunk, onReasoning, maxTry = MAX_ASK_TRY, validate, approve }: EditOptions = {}) {
+  async edit(
+    question: string,
+    {
+      onChunk,
+      onReasoning,
+      maxTry = MAX_ASK_TRY,
+      validate,
+      approve,
+    }: EditOptions = {},
+  ) {
     for (let tryCount = 0; tryCount < maxTry; tryCount++) {
       let response = await this.ask(question, { onChunk, onReasoning });
       if (validate?.length && tryCount === 0) {
@@ -226,35 +276,51 @@ ${validate.map((v) => `- ${v}`).join("\n")}`;
     // const toolMessages = messages.map(
     //   (message) => new ToolMessage({ content: message.content, tool_call_id: message.type })
     // );
-    const toolMessages = messages.map((message) => new HumanMessage(message.content));
+    const toolMessages = messages.map(
+      (message) => new HumanMessage(message.content),
+    );
     this.messageHistory.push(...toolMessages);
     return this;
   }
-  async writeTypescripts(question: string, executor: Executor, options: EditOptions = {}) {
+  async writeTypescripts(
+    question: string,
+    executor: Executor,
+    options: EditOptions = {},
+  ) {
     const content = await this.edit(question, options);
     const writes = this.#getTypescriptCodes(content);
-    for (const write of writes) await executor.writeFile(write.filePath, write.content);
+    for (const write of writes)
+      await executor.writeFile(write.filePath, write.content);
     return await this.#tryFixTypescripts(writes, executor, options);
   }
   async #editTypescripts(question: string, options: EditOptions = {}) {
     const content = await this.edit(question, options);
     return this.#getTypescriptCodes(content);
   }
-  async #tryFixTypescripts(writes: FileContent[], executor: Executor, options: EditOptions = {}) {
+  async #tryFixTypescripts(
+    writes: FileContent[],
+    executor: Executor,
+    options: EditOptions = {},
+  ) {
     const MAX_EDIT_TRY = 5;
     for (let tryCount = 0; tryCount < MAX_EDIT_TRY; tryCount++) {
-      const loader = new Spinner(`Type checking and linting...`, { prefix: `🤖akan-editor` }).start();
+      const loader = new Spinner(`Type checking and linting...`, {
+        prefix: `🤖akan-editor`,
+      }).start();
       const fileChecks = await Promise.all(
         writes.map(async ({ filePath }) => {
           const typeCheckResult = executor.typeCheck(filePath);
           const lintResult = await executor.lint(filePath);
-          const needFix = !!typeCheckResult.fileErrors.length || !!lintResult.errors.length;
+          const needFix =
+            !!typeCheckResult.fileErrors.length || !!lintResult.errors.length;
           return { filePath, typeCheckResult, lintResult, needFix };
         }),
       );
       const needFix = fileChecks.some((fileCheck) => fileCheck.needFix);
       if (needFix) {
-        loader.fail("Type checking and linting has some errors, try to fix them");
+        loader.fail(
+          "Type checking and linting has some errors, try to fix them",
+        );
         fileChecks.forEach((fileCheck) => {
           Logger.rawLog(
             `TypeCheck Result \n${fileCheck.typeCheckResult.message}\nLint Result \n${fileCheck.lintResult.message}`,
@@ -264,12 +330,16 @@ ${validate.map((v) => `- ${v}`).join("\n")}`;
             { type: "eslint", content: fileCheck.lintResult.message },
           ]);
         });
-        writes = await this.#editTypescripts("Fix the typescript and eslint errors", {
-          ...options,
-          validate: undefined,
-          approve: true,
-        });
-        for (const write of writes) await executor.writeFile(write.filePath, write.content);
+        writes = await this.#editTypescripts(
+          "Fix the typescript and eslint errors",
+          {
+            ...options,
+            validate: undefined,
+            approve: true,
+          },
+        );
+        for (const write of writes)
+          await executor.writeFile(write.filePath, write.content);
       } else {
         loader.succeed("Type checking and linting has no errors");
         return writes;
@@ -285,7 +355,9 @@ ${validate.map((v) => `- ${v}`).join("\n")}`;
       if (!content) return null;
       const filePath = /\/\/ File: (.*?)(?:\n|$)/.exec(content)?.[1]?.trim();
       if (!filePath) return null;
-      const contentWithoutFilepath = content.replace(`// File: ${filePath}\n`, "").trim();
+      const contentWithoutFilepath = content
+        .replace(`// File: ${filePath}\n`, "")
+        .trim();
       return { filePath, content: contentWithoutFilepath };
     });
     return result.filter((code) => code !== null) as FileContent[];

package/cloud/cloudApi.ts

@@ -1,23 +1,45 @@
-interface AccessToken {
-  jwt: string;
-  refreshToken: string;
-  expiresAt: Date;
-}
+import {
+  type AccessToken,
+  type AccessTokenDto,
+  akanCloudHost,
+  type HostConfig,
+} from "./constants";
+import { GlobalConfig } from "./globalConfig";
 
 class HttpClient {
   readonly baseUrl: string;
-  constructor(baseUrl: string) {
+  readonly headers: Record<string, string> = {};
+  constructor(baseUrl: string, headers: Record<string, string> = {}) {
     this.baseUrl = baseUrl;
+    this.headers = headers;
   }
   async get<T>(
     url: string,
     { headers }: { headers?: Record<string, string> } = {},
   ): Promise<T> {
     const response = await fetch(`${this.baseUrl}${url}`, {
-      headers: { "Content-Type": "application/json", ...headers },
+      headers: {
+        "Content-Type": "application/json",
+        ...this.headers,
+        ...headers,
+      },
     });
     return response.json();
   }
+  async getFile(
+    url: string,
+    localPath: string,
+    headers?: Record<string, string>,
+  ): Promise<void> {
+    const response = await fetch(`${this.baseUrl}${url}`, {
+      headers: { ...this.headers, ...headers },
+    });
+    if (!response.ok)
+      throw new Error(
+        `Failed to download file: ${response.status} ${response.statusText}`,
+      );
+    await Bun.write(localPath, response);
+  }
   async post<T>(
     url: string,
     data: unknown,
@@ -28,74 +50,86 @@ class HttpClient {
       method: "POST",
       body: isFormData ? data : JSON.stringify(data),
       headers: isFormData
-        ? headers
-        : { "Content-Type": "application/json", ...headers },
+        ? { ...this.headers, ...headers }
+        : { "Content-Type": "application/json", ...this.headers, ...headers },
     });
     return response.json();
   }
+  setHeaders(headers: Record<string, string>) {
+    Object.assign(this.headers, headers);
+    return this;
+  }
 }
 
 export class CloudApi {
-  readonly api: HttpClient;
+  readonly #api: HttpClient;
   #accessToken: AccessToken | null = null;
-  constructor(
-    host: string,
-    { accessToken }: { accessToken?: AccessToken } = {},
-  ) {
-    this.api = new HttpClient(`${host}/api`);
-    this.#accessToken = accessToken ?? null;
+
+  static async fromHost(host?: string) {
+    const hostConfig = await GlobalConfig.getHostConfig(host);
+    return new CloudApi(hostConfig);
+  }
+  constructor(hostConfig: HostConfig) {
+    const host = akanCloudHost;
+    this.#api = new HttpClient(`${host}/api`);
+    this.#accessToken = hostConfig.auth?.accessToken ?? null;
+    if (this.#accessToken && !GlobalConfig.needRefreshToken(this.#accessToken))
+      this.#api.setHeaders({
+        Authorization: `Bearer ${this.#accessToken.jwt}`,
+      });
   }
 
-  async uploadEnv(
-    devProjectId: string,
-    fileStream: ReadableStream,
-  ): Promise<boolean> {
+  async uploadEnv(devProjectId: string, file: File): Promise<boolean> {
     const formData = new FormData();
     formData.append("devProjectId", devProjectId);
-    formData.append("fileStream", await new Response(fileStream).blob());
-    const response = await this.api.post<{ success: boolean }>(
+    formData.append("file", file);
+    const data = await this.#api.post<boolean>(
       `/uploadEnv/${devProjectId}`,
       formData,
     );
-    return response.success;
+    return data;
   }
-  async downloadEnv(devProjectId: string): Promise<boolean> {
-    const response = await this.api.get<{ success: boolean }>(
-      `/downloadEnv/${devProjectId}`,
-    );
-    return response.success;
+  async downloadEnv(devProjectId: string, localPath: string): Promise<void> {
+    await this.#api.getFile(`/downloadEnv/${devProjectId}`, localPath);
   }
-  async getRemoteAuthToken(remoteId: string): Promise<AccessToken> {
-    if (this.#needRefreshToken()) return await this.refreshAuthToken();
-    else if (this.#accessToken) return this.#accessToken;
-    const accessToken = await this.api.get<AccessToken>(
-      `/getRemoteAuthToken/${remoteId}`,
-    );
-    this.#accessToken = {
-      jwt: accessToken.jwt,
-      refreshToken: accessToken.refreshToken,
-      expiresAt: new Date(accessToken.expiresAt),
-    };
-    return accessToken;
+  async getRemoteAuthToken(remoteId: string): Promise<AccessToken | null> {
+    try {
+      if (this.#accessToken) {
+        if (GlobalConfig.needRefreshToken(this.#accessToken))
+          return await this.refreshAuthToken();
+        else return await this.refreshAuthToken();
+      }
+      const accessToken = await this.#api.get<AccessTokenDto>(
+        `/getRemoteAuthToken/${remoteId}`,
+      );
+      this.#accessToken = GlobalConfig.toAccessToken(accessToken);
+      this.#api.setHeaders({
+        Authorization: `Bearer ${this.#accessToken.jwt}`,
+      });
+      return this.#accessToken;
+    } catch (_) {
+      return null;
+    }
   }
   async refreshAuthToken(): Promise<AccessToken> {
-    const response = await this.api.post<AccessToken>(
+    const response = await this.#api.post<AccessTokenDto>(
       `/refreshRemoteAuthToken`,
       {
         refreshToken: this.#accessToken?.refreshToken,
       },
     );
-    this.#accessToken = {
-      jwt: response.jwt,
-      refreshToken: response.refreshToken,
-      expiresAt: new Date(response.expiresAt),
-    };
-    return response;
+    this.#accessToken = GlobalConfig.toAccessToken(response);
+    this.#api.setHeaders({ Authorization: `Bearer ${this.#accessToken.jwt}` });
+    return this.#accessToken;
   }
-  #needRefreshToken(): boolean {
-    return !!(
-      this.#accessToken?.expiresAt &&
-      this.#accessToken.expiresAt.getTime() < Date.now() - 1000 * 60 * 60
-    );
+  async getRemoteSelf(): Promise<{ id: string; nickname: string } | null> {
+    try {
+      const data = await this.#api.get<{ id: string; nickname: string }>(
+        `/getRemoteSelf`,
+      );
+      return data;
+    } catch {
+      return null;
+    }
   }
 }

package/cloud/constants.ts

@@ -0,0 +1,48 @@
+import type { Dayjs } from "dayjs";
+import type { SupportedLlmModel } from "../aiEditor";
+
+export const basePath = `${Bun.env.HOME ?? Bun.env.USERPROFILE}/.akan`;
+export const configPath = `${basePath}/config.json`;
+export const akanCloudHost =
+  process.env.AKAN_PUBLIC_OPERATION_MODE === "local" ? "http://localhost" : "https://cloud.akanjs.com";
+export const akanCloudUrl = `${akanCloudHost}${process.env.AKAN_PUBLIC_OPERATION_MODE === "local" ? ":8282" : ""}/api`;
+
+export interface HostConfig {
+  auth?: {
+    accessToken?: AccessToken;
+    self?: { id: string; nickname: string };
+  };
+}
+export interface HostConfigDto {
+  auth?: {
+    accessToken?: AccessTokenDto;
+    self?: { id: string; nickname: string };
+  };
+}
+export const defaultHostConfig: HostConfig = {};
+export interface RemoteEnvServerConfig {
+  host: string;
+  username?: string;
+  port?: number;
+}
+export interface AkanGlobalConfig {
+  cloudHost: { [key: string]: HostConfigDto };
+  remoteEnvServers: Record<string, RemoteEnvServerConfig>;
+  llm: { model: SupportedLlmModel; apiKey: string } | null;
+}
+export const defaultAkanGlobalConfig: AkanGlobalConfig = {
+  cloudHost: {},
+  remoteEnvServers: {},
+  llm: null,
+};
+
+export interface AccessTokenDto {
+  jwt: string;
+  refreshToken: string | null;
+  expiresAt: string | null;
+}
+export interface AccessToken {
+  jwt: string;
+  refreshToken: string | null;
+  expiresAt: Dayjs | null;
+}

package/cloud/globalConfig.ts

@@ -0,0 +1,109 @@
+import { mkdir } from "node:fs/promises";
+import dayjs from "dayjs";
+import { FileSys } from "../fileSys";
+import {
+  type AccessToken,
+  type AccessTokenDto,
+  type AkanGlobalConfig,
+  akanCloudHost,
+  basePath,
+  configPath,
+  defaultAkanGlobalConfig,
+  defaultHostConfig,
+  type HostConfig,
+  type HostConfigDto,
+  type RemoteEnvServerConfig,
+} from "./constants";
+
+export class GlobalConfig {
+  static async #getAkanGlobalConfig(): Promise<AkanGlobalConfig> {
+    const exists = await FileSys.fileExists(configPath);
+    const akanConfig = exists ? await FileSys.readJson<Partial<AkanGlobalConfig>>(configPath) : {};
+    return {
+      ...defaultAkanGlobalConfig,
+      ...akanConfig,
+      cloudHost: akanConfig.cloudHost ?? defaultAkanGlobalConfig.cloudHost,
+      remoteEnvServers: akanConfig.remoteEnvServers ?? defaultAkanGlobalConfig.remoteEnvServers,
+    };
+  }
+  static async #setAkanGlobalConfig(akanConfig: AkanGlobalConfig) {
+    await mkdir(basePath, { recursive: true });
+    await Bun.write(configPath, JSON.stringify(akanConfig, null, 2));
+  }
+  static async getHostConfig(host = akanCloudHost): Promise<HostConfig> {
+    const akanConfig = await GlobalConfig.#getAkanGlobalConfig();
+    return GlobalConfig.toHostConfig(akanConfig.cloudHost[host] ?? defaultHostConfig);
+  }
+  static async setHostConfig(host = akanCloudHost, config: HostConfig = {}) {
+    const akanConfig = await GlobalConfig.#getAkanGlobalConfig();
+    akanConfig.cloudHost[host] = GlobalConfig.toHostConfigDto(config);
+    await GlobalConfig.#setAkanGlobalConfig(akanConfig);
+  }
+  static async getLlmConfig(): Promise<AkanGlobalConfig["llm"]> {
+    const akanConfig = await GlobalConfig.#getAkanGlobalConfig();
+    return akanConfig.llm ?? null;
+  }
+  static async setLlmConfig(llmConfig: AkanGlobalConfig["llm"]) {
+    const akanConfig = await GlobalConfig.#getAkanGlobalConfig();
+    await GlobalConfig.#setAkanGlobalConfig({ ...akanConfig, llm: llmConfig });
+  }
+  static async getRemoteEnvServers(): Promise<AkanGlobalConfig["remoteEnvServers"]> {
+    const akanConfig = await GlobalConfig.#getAkanGlobalConfig();
+    return akanConfig.remoteEnvServers;
+  }
+  static async setRemoteEnvServer(name: string, config: RemoteEnvServerConfig) {
+    const akanConfig = await GlobalConfig.#getAkanGlobalConfig();
+    await GlobalConfig.#setAkanGlobalConfig({
+      ...akanConfig,
+      remoteEnvServers: {
+        ...akanConfig.remoteEnvServers,
+        [name]: config,
+      },
+    });
+  }
+  static async removeRemoteEnvServer(name: string) {
+    const akanConfig = await GlobalConfig.#getAkanGlobalConfig();
+    const { [name]: _, ...remoteEnvServers } = akanConfig.remoteEnvServers;
+    await GlobalConfig.#setAkanGlobalConfig({
+      ...akanConfig,
+      remoteEnvServers,
+    });
+  }
+  static needRefreshToken(accessToken: AccessToken): boolean {
+    return !!accessToken?.expiresAt?.isBefore(dayjs().add(1, "hour"));
+  }
+  static toAccessToken(accessToken: AccessTokenDto): AccessToken {
+    return {
+      jwt: accessToken.jwt,
+      refreshToken: accessToken.refreshToken ?? null,
+      expiresAt: accessToken.expiresAt ? dayjs(accessToken.expiresAt) : null,
+    };
+  }
+  static toAccessTokenDto(accessToken: AccessToken): AccessTokenDto {
+    return {
+      jwt: accessToken.jwt,
+      refreshToken: accessToken.refreshToken ?? null,
+      expiresAt: accessToken.expiresAt?.toString() ?? null,
+    };
+  }
+  static toHostConfigDto(hostConfig: HostConfig): HostConfigDto {
+    return {
+      auth: {
+        accessToken: hostConfig.auth?.accessToken
+          ? GlobalConfig.toAccessTokenDto(hostConfig.auth.accessToken)
+          : undefined,
+        self: hostConfig.auth?.self,
+      },
+    };
+  }
+  static toHostConfig(hostConfigDto: HostConfigDto): HostConfig {
+    return {
+      auth: {
+        accessToken: hostConfigDto.auth?.accessToken
+          ? GlobalConfig.toAccessToken(hostConfigDto.auth.accessToken)
+          : undefined,
+        self: hostConfigDto.auth?.self,
+      },
+    };
+  }
+}

package/cloud/index.ts

@@ -1 +1,3 @@
 export * from "./cloudApi";
+export * from "./constants";
+export * from "./globalConfig";

package/executors.ts

@@ -261,10 +261,30 @@ export class Executor {
     });
     return new Promise((resolve, reject) => {
       proc.on("error", (error) => {
-        reject(new CommandExecutionError({ command, cwd, code: null, signal: null, stdout, stderr, cause: error }));
+        reject(
+          new CommandExecutionError({
+            command,
+            cwd,
+            code: null,
+            signal: null,
+            stdout,
+            stderr,
+            cause: error,
+          }),
+        );
       });
       proc.on("exit", (code, signal) => {
-        if (!!code || signal) reject(new CommandExecutionError({ command, cwd, code, signal, stdout, stderr }));
+        if (!!code || signal)
+          reject(
+            new CommandExecutionError({
+              command,
+              cwd,
+              code,
+              signal,
+              stdout,
+              stderr,
+            }),
+          );
         else resolve({ code, signal });
       });
     });
@@ -293,12 +313,31 @@ export class Executor {
     return new Promise((resolve, reject) => {
       proc.on("error", (error) => {
         reject(
-          new CommandExecutionError({ command, args, cwd, code: null, signal: null, stdout, stderr, cause: error }),
+          new CommandExecutionError({
+            command,
+            args,
+            cwd,
+            code: null,
+            signal: null,
+            stdout,
+            stderr,
+            cause: error,
+          }),
         );
       });
       proc.on("close", (code, signal) => {
         if (code !== 0 || signal)
-          reject(new CommandExecutionError({ command, args, cwd, code, signal, stdout, stderr }));
+          reject(
+            new CommandExecutionError({
+              command,
+              args,
+              cwd,
+              code,
+              signal,
+              stdout,
+              stderr,
+            }),
+          );
         else resolve(stdout);
       });
     });
@@ -345,7 +384,17 @@ export class Executor {
       });
       proc.on("exit", (code, signal) => {
         if (!!code || signal)
-          reject(new CommandExecutionError({ command: modulePath, args, cwd, code, signal, stdout, stderr }));
+          reject(
+            new CommandExecutionError({
+              command: modulePath,
+              args,
+              cwd,
+              code,
+              signal,
+              stdout,
+              stderr,
+            }),
+          );
         else resolve({ code, signal });
       });
     });
@@ -490,7 +539,10 @@ export class Executor {
       const result = {
         ...extendsTsconfig,
         ...tsconfig,
-        compilerOptions: { ...extendsTsconfig.compilerOptions, ...tsconfig.compilerOptions },
+        compilerOptions: {
+          ...extendsTsconfig.compilerOptions,
+          ...tsconfig.compilerOptions,
+        },
       } as TsConfigJson;
       this.#tsconfig = result;
       return result;
@@ -571,7 +623,9 @@ export class Executor {
         content,
       );
       this.logger.verbose(`Apply template ${templatePath} to ${convertedTargetPath}`);
-      return this.writeFile(convertedTargetPath, convertedContent, { overwrite });
+      return this.writeFile(convertedTargetPath, convertedContent, {
+        overwrite,
+      });
     } else if (staticTemplateFileExtensions.has(path.extname(targetPath).toLowerCase())) {
       const convertedTargetPath = Object.entries(dict).reduce(
         (path, [key, value]) => path.replace(new RegExp(`__${key}__`, "g"), value),
@@ -606,7 +660,12 @@ export class Executor {
     if ((await stat(prefixTemplatePath)).isFile()) {
       const filename = path.basename(prefixTemplatePath);
       const fileContent = await this.#applyTemplateFile(
-        { templatePath: prefixTemplatePath, targetPath: path.join(basePath, filename), scanInfo, overwrite },
+        {
+          templatePath: prefixTemplatePath,
+          targetPath: path.join(basePath, filename),
+          scanInfo,
+          overwrite,
+        },
         dict,
         options,
       );
@@ -619,7 +678,12 @@ export class Executor {
             const subpath = path.join(templatePath, subdir);
             if ((await stat(subpath)).isFile()) {
               const fileContent = await this.#applyTemplateFile(
-                { templatePath: subpath, targetPath: path.join(basePath, subdir), scanInfo, overwrite },
+                {
+                  templatePath: subpath,
+                  targetPath: path.join(basePath, subdir),
+                  scanInfo,
+                  overwrite,
+                },
                 dict,
                 options,
               );
@@ -690,7 +754,10 @@ export class Executor {
   }> {
     const path = this.getPath(filePath);
     const linter = this.getLinter();
-    const { results, errors, warnings } = await linter.lint(path, { fix, dryRun });
+    const { results, errors, warnings } = await linter.lint(path, {
+      fix,
+      dryRun,
+    });
     const message = linter.formatLintResults(results);
     return { results, message, errors, warnings };
   }
@@ -726,6 +793,7 @@ export class WorkspaceExecutor extends Executor {
 
     const appName = sourceEnv.AKAN_PUBLIC_APP_NAME;
     const workspaceRoot = sourceEnv.AKAN_WORKSPACE_ROOT;
+    const workspaceId = sourceEnv.AKAN_WORKSPACE_ID;
 
     const repoName = sourceEnv.AKAN_PUBLIC_REPO_NAME;
     if (!repoName) throw new Error("AKAN_PUBLIC_REPO_NAME is not set");
@@ -743,7 +811,16 @@ export class WorkspaceExecutor extends Executor {
       | "local"
       | undefined;
     if (!env) throw new Error("AKAN_PUBLIC_ENV is not set");
-    return { ...(appName ? { appName } : {}), workspaceRoot, repoName, serveDomain, env, portOffset };
+    return { ...(appName ? { appName } : {}), workspaceRoot, repoName, serveDomain, env, portOffset, workspaceId };
+  }
+  getWorkspaceId<AllowEmpty extends boolean = false>({
+    allowEmpty,
+  }: {
+    allowEmpty?: AllowEmpty;
+  } = {}): AllowEmpty extends true ? string | undefined : string {
+    const { workspaceId } = WorkspaceExecutor.getBaseDevEnv();
+    if (!workspaceId && !allowEmpty) throw new Error("Workspace ID is not found");
+    return workspaceId as AllowEmpty extends true ? string | undefined : string;
   }
   async scan(): Promise<WorkspaceInfo> {
     return await WorkspaceInfo.fromExecutor(this);
@@ -976,8 +1053,12 @@ export class SysExecutor extends Executor {
     if (this.#scanInfo && !refresh) return this.#scanInfo;
     const scanInfo =
       this.type === "app"
-        ? await AppInfo.fromExecutor(this as unknown as AppExecutor, { refresh })
-        : await LibInfo.fromExecutor(this as unknown as LibExecutor, { refresh });
+        ? await AppInfo.fromExecutor(this as unknown as AppExecutor, {
+            refresh,
+          })
+        : await LibInfo.fromExecutor(this as unknown as LibExecutor, {
+            refresh,
+          });
     if (write) {
       await Promise.all(this.#getScanTemplateTasks(scanInfo));
       await this.writeJson(`akan.${this.type}.json`, scanInfo.getScanResult());
@@ -1147,7 +1228,11 @@ export class SysExecutor extends Executor {
       ),
     };
     const scanInfo = await this.scan();
-    const fileContents = await this._applyTemplate({ ...options, scanInfo, dict });
+    const fileContents = await this._applyTemplate({
+      ...options,
+      scanInfo,
+      dict,
+    });
     await this.scan();
     return fileContents;
   }
@@ -1247,7 +1332,11 @@ export class AppExecutor extends SysExecutor {
       this.#pageKeys = [];
       return this.#pageKeys;
     }
-    for await (const rel of glob.scan({ cwd: pageDir, absolute: false, onlyFiles: true })) {
+    for await (const rel of glob.scan({
+      cwd: pageDir,
+      absolute: false,
+      onlyFiles: true,
+    })) {
       const segments = rel.split(path.sep);
       if (segments.some((s) => s === "node_modules")) continue;
       const posix = segments.join("/");
@@ -1255,7 +1344,10 @@ export class AppExecutor extends SysExecutor {
       validatePageSourceFile(posix, { filePath: absPath });
       if (!isRouteSourceFile(posix)) continue;
       const key = `./${posix}`;
-      validateSubRoutePageKey(key, akanConfig.basePaths, { appName: this.name, filePath: absPath });
+      validateSubRoutePageKey(key, akanConfig.basePaths, {
+        appName: this.name,
+        filePath: absPath,
+      });
       const parsed = parseRouteModuleKey(key);
       if (parsed.isInternalRootLayout) {
         throw new Error(`[route-convention] __root_layout is reserved for Akan.js generated root layout: ${absPath}`);
@@ -1298,7 +1390,11 @@ export class AppExecutor extends SysExecutor {
     ]);
   }
   async scanSync({ refresh = false, write = true }: { refresh?: boolean; write?: boolean } = {}) {
-    const scanInfo = (await this.scan({ refresh, write, writeLib: write })) as AppInfo;
+    const scanInfo = (await this.scan({
+      refresh,
+      write,
+      writeLib: write,
+    })) as AppInfo;
     if (write) await this.syncAssets(scanInfo.getScanResult().libDeps);
     return scanInfo;
   }
@@ -1365,7 +1461,10 @@ export class PkgExecutor extends Executor {
     return scanInfo;
   }
   async #getDependencyVersion(rootPackageJson: PackageJson, dep: string): Promise<string | undefined> {
-    const rootDeps = { ...rootPackageJson.dependencies, ...rootPackageJson.devDependencies };
+    const rootDeps = {
+      ...rootPackageJson.dependencies,
+      ...rootPackageJson.devDependencies,
+    };
     const rootVersion = rootDeps[dep];
     if (rootVersion) return rootVersion;
 
@@ -1426,7 +1525,14 @@ export class PkgExecutor extends Executor {
     const distPkgJson: PackageJson = {
       ...pkgJson,
       type: "module",
-      exports: { ...pkgJson.exports, ".": { import: "./index.ts", types: "./index.ts", default: "./index.ts" } },
+      exports: {
+        ...pkgJson.exports,
+        ".": {
+          import: "./index.ts",
+          types: "./index.ts",
+          default: "./index.ts",
+        },
+      },
       engines: { bun: ">=1.3.13" },
       ...dependencyMaps,
     };

package/index.ts

@@ -6,11 +6,10 @@ export * from "./applicationBuildRunner";
 export * from "./applicationReleasePackager";
 export * from "./applicationTestPreload";
 export * from "./artifact";
-export * from "./auth";
 export * from "./builder";
 export * from "./capacitorApp";
+export * from "./cloud";
 export * from "./commandDecorators";
-export * from "./constants";
 export * from "./createTunnel";
 export * from "./dependencyScanner";
 export * from "./executors";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/devkit",
-  "version": "2.1.1-rc.0",
+  "version": "2.1.1-rc.2",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {
@@ -32,10 +32,11 @@
     "@langchain/openai": "^1.4.6",
     "@tailwindcss/node": "^4.3.0",
     "@trapezedev/project": "^7.1.4",
-    "akanjs": "2.1.1-rc.0",
+    "akanjs": "2.1.1-rc.2",
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
     "daisyui": "^5.5.20",
+    "dayjs": "^1.11.20",
     "fontaine": "^0.8.0",
     "fonteditor-core": "^2.6.3",
     "ignore": "^7.0.5",

package/auth.ts

@@ -1,41 +0,0 @@
-import { mkdir } from "node:fs/promises";
-
-import {
-  type AkanGlobalConfig,
-  akanCloudHost,
-  akanCloudUrl,
-  basePath,
-  configPath,
-  defaultAkanGlobalConfig,
-  defaultHostConfig,
-  type HostConfig,
-} from "./constants";
-import { FileSys } from "./fileSys";
-
-export const getAkanGlobalConfig = async () => {
-  const exists = await FileSys.fileExists(configPath);
-  const akanConfig = exists ? await FileSys.readJson<AkanGlobalConfig>(configPath) : defaultAkanGlobalConfig;
-  return akanConfig;
-};
-export const setAkanGlobalConfig = async (akanConfig: AkanGlobalConfig) => {
-  await mkdir(basePath, { recursive: true });
-  await Bun.write(configPath, JSON.stringify(akanConfig, null, 2));
-};
-export const getHostConfig = async (host = akanCloudHost) => {
-  const akanConfig = await getAkanGlobalConfig();
-  return akanConfig.cloudHost[host] ?? defaultHostConfig;
-};
-export const setHostConfig = async (host = akanCloudHost, config: HostConfig = {}) => {
-  const akanConfig = await getAkanGlobalConfig();
-  akanConfig.cloudHost[host] = config;
-  await setAkanGlobalConfig(akanConfig);
-};
-export const getSelf = async (token: string) => {
-  try {
-    const res = await fetch(`${akanCloudUrl}/user/getSelf`, { headers: { Authorization: `Bearer ${token}` } });
-    const user = (await res.json()) as { id: string; nickname: string };
-    return user;
-  } catch (e) {
-    return null;
-  }
-};

package/constants.ts

@@ -1,32 +0,0 @@
-import type { SupportedLlmModel } from "./aiEditor";
-
-export const basePath = `${Bun.env.HOME ?? Bun.env.USERPROFILE}/.akan`;
-export const configPath = `${basePath}/config.json`;
-export const akanCloudHost =
-  process.env.AKAN_PUBLIC_OPERATION_MODE === "local"
-    ? "http://localhost"
-    : "https://cloud.akanjs.com";
-export const akanCloudUrl = `${akanCloudHost}${
-  process.env.AKAN_PUBLIC_OPERATION_MODE === "local" ? ":8282" : ""
-}/api`;
-
-export interface HostConfig {
-  auth?: {
-    token: string;
-    self: { id: string; nickname: string };
-  };
-}
-export const defaultHostConfig: HostConfig = {};
-export interface AkanGlobalConfig {
-  cloudHost: {
-    [key: string]: HostConfig;
-  };
-  llm: {
-    model: SupportedLlmModel;
-    apiKey: string;
-  } | null;
-}
-export const defaultAkanGlobalConfig: AkanGlobalConfig = {
-  cloudHost: {},
-  llm: null,
-};