@akanjs/devkit 2.1.1-rc.1 → 2.1.1

package/aiEditor.test.ts

@@ -0,0 +1,68 @@
+import { describe, expect, test } from "bun:test";
+import {
+  parseTypescriptFileBlocks,
+  preserveTypescriptResponseContent,
+} from "./aiEditor";
+
+describe("parseTypescriptFileBlocks", () => {
+  test("parses TypeScript file blocks with common fence variants", () => {
+    const writes = parseTypescriptFileBlocks(`
+\`\`\`ts
+
+// File: lib/car/car.constant.ts
+
+export const car = "car";
+\`\`\`
+
+\`\`\`tsx
+  // File: lib/car/Car.Unit.tsx
+export const CarUnit = () => null;
+\`\`\`
+`);
+
+    expect(writes).toEqual([
+      {
+        filePath: "lib/car/car.constant.ts",
+        content: 'export const car = "car";',
+      },
+      {
+        filePath: "lib/car/Car.Unit.tsx",
+        content: "export const CarUnit = () => null;",
+      },
+    ]);
+  });
+
+  test("keeps previous code response when validation responds with prose only", () => {
+    const previousContent = `
+\`\`\`typescript
+// File: lib/car/car.constant.ts
+export const car = "car";
+\`\`\`
+`;
+    const nextContent =
+      "The generated file meets all specified requirements. No rewrite is necessary.";
+
+    expect(
+      preserveTypescriptResponseContent(previousContent, nextContent),
+    ).toBe(previousContent);
+  });
+
+  test("uses next code response when validation rewrites with parseable files", () => {
+    const previousContent = `
+\`\`\`typescript
+// File: lib/car/car.constant.ts
+export const car = "car";
+\`\`\`
+`;
+    const nextContent = `
+\`\`\`typescript
+// File: lib/car/car.constant.ts
+export const car = "updated";
+\`\`\`
+`;
+
+    expect(
+      preserveTypescriptResponseContent(previousContent, nextContent),
+    ).toBe(nextContent);
+  });
+});

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 {
@@ -28,20 +31,68 @@ interface EditOptions {
   maxTry?: number;
   validate?: string[];
   approve?: boolean;
+  fallbackToPreviousTypescript?: boolean;
 }
 
+export const parseTypescriptFileBlocks = (text: string): FileContent[] => {
+  const fileBlocks: FileContent[] = [];
+  const codeBlockRegex = /```(?:typescript|ts|tsx)\s*\n([\s\S]*?)```/gi;
+  const filePathRegex = /^\s*\/\/\s*File:\s*(.+?)\s*$/im;
+
+  for (const codeBlock of text.matchAll(codeBlockRegex)) {
+    const content = codeBlock[1]?.trim();
+    if (!content) continue;
+
+    const filePath = filePathRegex.exec(content)?.[1]?.trim();
+    if (!filePath) continue;
+
+    fileBlocks.push({
+      filePath,
+      content: content.replace(filePathRegex, "").trim(),
+    });
+  }
+
+  return fileBlocks;
+};
+
+export const preserveTypescriptResponseContent = (
+  previousContent: string,
+  nextContent: string,
+) => {
+  const previousWrites = parseTypescriptFileBlocks(previousContent);
+  const nextWrites = parseTypescriptFileBlocks(nextContent);
+  if (previousWrites.length > 0 && nextWrites.length === 0)
+    return previousContent;
+  return nextContent;
+};
+
 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 +102,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 +117,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 +166,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 +193,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 +212,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();
@@ -151,13 +222,15 @@ export class AiSession {
       this.messageHistory.push(humanMessage);
       const stream = await AiSession.#chat.stream(this.messageHistory);
       let reasoningResponse = "",
-        fullResponse = "",
-        tokenIdx = 0;
+        fullResponse = "";
       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);
@@ -173,24 +246,45 @@ export class AiSession {
           fullResponse += content;
           onChunk(content); // Send individual chunks to callback
         }
-        tokenIdx++;
       }
       fullResponse += "\n";
       onChunk("\n");
       this.messageHistory.push(new AIMessage(fullResponse));
       return { content: fullResponse, messageHistory: this.messageHistory };
-    } catch (error) {
+    } catch {
       loader.fail(`${AiSession.#chat.model} failed to respond`);
       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,
+      fallbackToPreviousTypescript,
+    }: EditOptions = {},
+  ) {
     for (let tryCount = 0; tryCount < maxTry; tryCount++) {
       let response = await this.ask(question, { onChunk, onReasoning });
       if (validate?.length && tryCount === 0) {
         const validateQuestion = `Double check if the response meets the requirements and conditions, and follow the instructions. If not, rewrite it.
 ${validate.map((v) => `- ${v}`).join("\n")}`;
-        response = await this.ask(validateQuestion, { onChunk, onReasoning });
+        const validateResponse = await this.ask(validateQuestion, {
+          onChunk,
+          onReasoning,
+        });
+        response = {
+          ...validateResponse,
+          content: fallbackToPreviousTypescript
+            ? preserveTypescriptResponseContent(
+                response.content,
+                validateResponse.content,
+              )
+            : validateResponse.content,
+        };
       }
       const isConfirmed = approve
         ? true
@@ -226,35 +320,72 @@ ${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 = {}) {
-    const content = await this.edit(question, options);
+  async writeTypescripts(
+    question: string,
+    executor: Executor,
+    options: EditOptions = {},
+  ) {
+    const content = await this.edit(question, {
+      ...options,
+      fallbackToPreviousTypescript: true,
+    });
     const writes = this.#getTypescriptCodes(content);
-    for (const write of writes) await executor.writeFile(write.filePath, write.content);
+    if (!writes.length)
+      throw new Error(
+        "No parseable TypeScript file blocks were found in the AI response. Include `// File: <path>` in each code block.",
+      );
+    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 #editTypescripts(
+    question: string,
+    options: EditOptions = {},
+    fallbackWrites?: FileContent[],
+  ) {
+    const content = await this.edit(question, {
+      ...options,
+      fallbackToPreviousTypescript: true,
+    });
+    const writes = this.#getTypescriptCodes(content);
+    if (!writes.length && fallbackWrites?.length) return fallbackWrites;
+    if (!writes.length)
+      throw new Error(
+        "No parseable TypeScript file blocks were found in the AI response. Include `// File: <path>` in each code block.",
+      );
+    return writes;
   }
-  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 lintResult = await executor.lint(filePath, { fix: true });
+          const typeCheckResult = await executor.typeCheckAsync(filePath);
+          const hasTypeErrors = typeCheckResult.fileErrors.length > 0;
+          const hasLintErrors = lintResult.errors.length > 0;
+          const needFix = hasTypeErrors || hasLintErrors;
           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");
+      const hasAnyFix = fileChecks.some((fileCheck) => fileCheck.needFix);
+      if (hasAnyFix) {
+        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 +395,17 @@ ${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,
+          },
+          writes,
+        );
+        for (const write of writes)
+          await executor.writeFile(write.filePath, write.content);
       } else {
         loader.succeed("Type checking and linting has no errors");
         return writes;
@@ -278,17 +414,7 @@ ${validate.map((v) => `- ${v}`).join("\n")}`;
     throw new Error("Failed to create scalar");
   }
   #getTypescriptCodes(text: string): FileContent[] {
-    const codes = text.match(/```(typescript|tsx)([\s\S]*?)```/g);
-    if (!codes) return [];
-    const result = codes.map((code) => {
-      const content = /```(typescript|tsx)([\s\S]*?)```/.exec(code)?.[2];
-      if (!content) return null;
-      const filePath = /\/\/ File: (.*?)(?:\n|$)/.exec(content)?.[1]?.trim();
-      if (!filePath) return null;
-      const contentWithoutFilepath = content.replace(`// File: ${filePath}\n`, "").trim();
-      return { filePath, content: contentWithoutFilepath };
-    });
-    return result.filter((code) => code !== null) as FileContent[];
+    return parseTypescriptFileBlocks(text);
   }
   async editMarkdown(request: string, options: EditOptions = {}) {
     const content = await this.edit(request, options);

package/cloud/cloudApi.ts

@@ -1,30 +1,45 @@
-import dayjs, { type Dayjs } from "dayjs";
-
-interface AccessTokenDto {
-  jwt: string;
-  refreshToken: string | null;
-  expiresAt: string | null;
-}
-interface AccessToken {
-  jwt: string;
-  refreshToken: string | null;
-  expiresAt: Dayjs | null;
-}
+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,
@@ -35,68 +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, file: File): Promise<boolean> {
     const formData = new FormData();
     formData.append("devProjectId", devProjectId);
     formData.append("file", file);
-    const response = await this.api.post<{ success: boolean }>(
+    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<AccessTokenDto>(
-      `/getRemoteAuthToken/${remoteId}`,
-    );
-    this.#accessToken = {
-      jwt: accessToken.jwt,
-      refreshToken: accessToken.refreshToken,
-      expiresAt: accessToken.expiresAt ? dayjs(accessToken.expiresAt) : null,
-    };
-    return this.#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<AccessTokenDto>(
+    const response = await this.#api.post<AccessTokenDto>(
       `/refreshRemoteAuthToken`,
       {
         refreshToken: this.#accessToken?.refreshToken,
       },
     );
-    this.#accessToken = {
-      jwt: response.jwt,
-      refreshToken: response.refreshToken,
-      expiresAt: response.expiresAt ? dayjs(response.expiresAt) : null,
-    };
+    this.#accessToken = GlobalConfig.toAccessToken(response);
+    this.#api.setHeaders({ Authorization: `Bearer ${this.#accessToken.jwt}` });
     return this.#accessToken;
   }
-  #needRefreshToken(): boolean {
-    return !!this.#accessToken?.expiresAt?.isBefore(dayjs().add(1, "hour"));
+  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;
+}