@akanjs/cli 3.0.0-beta.2 → 3.0.0-beta.21

package/guidelines/workspaceRecipes/workspaceRecipes.instruction.md

@@ -376,15 +376,16 @@ export default page()
 |---|---|
 | `interface PageProps { params }` + `[x]` folder | `.param("x", ID \| String \| Int \| …)` — one per `[x]` segment, every one of them, in path order |
 | `searchParams.k` | `.search("k", Type)`; `[Type]` for a repeated key; the value arrives typed and optional |
-| `params.lang` | `lang` — on every route's `.render()`, `.head()`, `.metadata()` and `.loading()` with no stage; `.param("lang")` is refused |
+| `params.lang` | `lang` — on every route's `.render()`, `.head()` and `.loading()` with no stage; `.param("lang")` is refused |
 | `export const pageConfig = {…}` | `.config({…})` — `devOnly` stays a literal |
 | `export const head = <…/>` / `generateHead({ params })` | `.head(<…/>)` / `.head(({ x }) => <…/>)` |
-| `export const metadata` / `generateMetadata` | `.metadata({…})` / `.metadata((args) => …)` |
+| `export const metadata` / `generateMetadata` | `.head(<><title>…</title><meta name="description" content="…" /></>)` — there is no object form |
 | `export function Loading()` | `.loading((args) => …)` |
 | `export default async function Page({ params, searchParams })` | `.render(async ({ x, k }) => { …same body… })` — `async` only if it awaits |
 | `_layout.tsx`: `export default function Layout({ children })` | `layout().render(({ children }) => …)` |
 | `export function NotFound` / `export function Error` | `.notFound(fn)` / `.error(fn)` on `layout()` |
-| root `_layout.tsx`: `fonts`, `theme`, `manifest`, `reconnect`, `wsConnect`, `layoutStyle`, `gaTrackingId` | `rootLayout().fonts([…]).theme("dark").manifest({…}).reconnect(false).wsConnect(false).layoutStyle("web").gaTrackingId("G-…")` |
+| root `_layout.tsx`: `fonts`, `theme`, `manifest`, `reconnect`, `wsConnect`, `layoutStyle` | `rootLayout().fonts([…]).theme("dark").manifest({…}).reconnect(false).wsConnect(false).layoutStyle("web")` |
+| root `_layout.tsx`: `gaTrackingId` | none — render the app's own `"use client"` analytics component from the root layout's `.render()` |
 | `prompt()` on `endpoint()` (removed) | `.prompt(name, description)` on the page that shows the same screen |
 
 Rules the loader and `akan sync` enforce: a chain module has no other export; `page()` belongs in a page file and
@@ -393,6 +394,68 @@ Rules the loader and `akan sync` enforce: a chain module has no other export; `p
 `_overrides.tsx` is untouched. MCP: `prompts/get` now runs the page's body under the caller's token and hands the
 model the description, what the page fetched, and the tools of those modules — see `mcpRule`.
 
+---
+
+### Recipe 8: Migrating the LLM Adaptor and the Removed `--ai` Commands
+
+Two changes land together. The runtime LLM seam now names a wire rather than a vendor, and the CLI's AI editor is
+gone. They touch different files and neither one is optional — the first breaks a build or, worse, degrades
+silently; the second breaks a script that calls a command that no longer exists.
+
+#### The adaptor, in `lib/option.ts` and `env/env.server.*.ts`
+
+`DeepseekLlm` is deleted. `OpenaiLlm` is the default and speaks the chat-completions dialect to whatever `host`
+names, so DeepSeek, Groq, Together, OpenRouter, Ollama and a self-hosted vLLM are the same class with a different
+`host` and `model`. `AnthropicLlm` is unchanged.
+
+```ts
+// before — env/env.server.local.ts
+export const env: ModulesOptions = {
+  ...libEnv,
+  llm: { apiKey: process.env.DEEPSEEK_KEY },
+};
+
+// after — the default model and host are gone, so name both
+export const env: ModulesOptions = {
+  ...libEnv,
+  llm: { apiKey: process.env.DEEPSEEK_KEY, model: "deepseek-v4-flash", host: "https://api.deepseek.com" },
+};
+```
+
+| Before | After | What happens if you skip it |
+|---|---|---|
+| `setLlm({ apiKey })`, relying on the DeepSeek default | `setLlm({ apiKey, model, host })` | The app boots, the log warns once, and the chat answers `llmUnavailable` to every turn |
+| `applyAdaptor(LlmAdaptorRole, DeepseekLlm)` | `OpenaiLlm` + `host: "https://api.deepseek.com"` | Build error — the class is gone |
+| `OpenaiLlm` pointed at a **named** `host`, reading images | add `accepts: { image: true }` to `setLlm` | **Silent**: images reach the model as a note saying they could not be read |
+| An adaptor of your own throwing `agent.error.<vendor>RequestFailed` | `new Err("agent.error.llmRequestFailed", { provider, status, reason })` | The chat prints the raw key instead of a sentence |
+| Provider settings in a second `option.use({ myLlmOption })` | put them in `setLlm` and read `use<MyLlmOption>()` | Nothing breaks; the second channel is no longer needed |
+
+`OpenaiLlm` claims vision for its default host (`https://api.openai.com/v1`) and for nothing else, because a host
+you named is a gateway it knows nothing about — and bytes handed to a model that cannot decode them kill the whole
+turn on a 400, where text-only degrades them to a note. Declare `accepts` whenever you set `host`.
+
+`LlmOption` is now a floor rather than the whole shape: `setLlm` carries whatever else it is handed to the role, so
+an adaptor of your own declares `interface MyLlmOption extends LlmOption { region: string }`, reads it with
+`use<MyLlmOption>()`, and stops needing a config channel beside `setLlm`.
+
+#### The CLI, in scripts and CI
+
+`AiSession` and every command that drove it are removed. There is no replacement command — the workspace's agent
+surface (`akan context`, the MCP tools, `akan guideline show`) is what feeds a coding agent now.
+
+| Removed | What to do instead |
+|---|---|
+| `akan create-module <name> --ai`, `akan create-scalar <name> --ai` | Drop the flag. The command scaffolds the same files it always did; write the constant and dictionary yourself or let a coding agent do it against `get_guideline modelConstant` / `modelDictionary` |
+| `akan compact <app-or-lib>` | Edit the `*.abstract.md` by hand. `akan quality scan` still warns past 300 lines |
+| `akan set-llm`, `akan reset-llm`, `akan ask` | Nothing. The runtime LLM is `option.setLlm(...)` and has never been this config |
+| `akan generate-instruction`, `akan update-instruction`, `akan generate-document`, `akan reapply-instruction` | Nothing. `akan guideline list` / `show` still read the bundled guidelines |
+| `import { AiSession } from "@akanjs/devkit/aiEditor"` | Nothing — the module is gone |
+
+`~/.akan/config.json` keeps an `llm` entry if it had one. It is ignored; delete it, because it holds an API key.
+
+Then: `bun run akan typecheck <app>`, `bun run akan lint <app>`, and one agent turn in the browser to confirm the
+provider answers.
+
 ### Data Flow Summary
 
 For each business question, follow this chain:

package/incrementalBuilder.proc.js

@@ -1,22 +1,22 @@
 // @bun
+import {
+  ApplicationBuildReporter,
+  HmrWatcher,
+  WatchRootResolver
+} from "./index-khpfpcsd.js";
 import {
   CodegenLock,
   WorkspaceExecutor,
   AppExecutor
-} from "./index-2tv3fdx4.js";
-import"./index-q0y2jq9j.js";
-import"./index-6wwzs1bc.js";
+} from "./index-ga6hygxr.js";
+import"./index-5b6tavv3.js";
 import {
   GraphClientEntryDiscovery,
   RouteClientBuilder,
   AutoImportSync,
   DevChangePlanner,
   DevGeneratedIndexSync
-} from "./index-w8kmx1b6.js";
-import {
-  HmrWatcher,
-  WatchRootResolver
-} from "./index-hwkygn9s.js";
+} from "./index-fgq75haa.js";
 import {
   prepareDevWatchBatch
 } from "./index-a5vmm6x4.js";
@@ -30,12 +30,6 @@ import path from "path";
 import { Logger } from "akanjs/common";
 
 class BuildBatchRunner {
-  static #entryCandidates = (workspaceRoot) => [
-    path.join(workspaceRoot, "pkgs/@akanjs/devkit/incrementalBuilder/buildBatch.proc.ts"),
-    path.join(workspaceRoot, "node_modules/@akanjs/devkit/incrementalBuilder/buildBatch.proc.ts"),
-    path.join(import.meta.dir, "buildBatch.proc.js"),
-    path.join(import.meta.dir, "buildBatch.proc.ts")
-  ];
   #logger = new Logger("BuildBatchRunner");
   #entry = null;
   #workspaceRoot;
@@ -47,7 +41,12 @@ class BuildBatchRunner {
   async#resolveEntry() {
     if (this.#entry)
       return this.#entry;
-    const candidates = BuildBatchRunner.#entryCandidates(this.#workspaceRoot);
+    const candidates = [
+      path.join(this.#workspaceRoot, "pkgs/@akanjs/devkit/incrementalBuilder/buildBatch.proc.ts"),
+      path.join(this.#workspaceRoot, "node_modules/@akanjs/devkit/incrementalBuilder/buildBatch.proc.ts"),
+      path.join(import.meta.dir, "buildBatch.proc.js"),
+      path.join(import.meta.dir, "buildBatch.proc.ts")
+    ];
     for (const candidate of candidates) {
       if (!await Bun.file(candidate).exists())
         continue;
@@ -173,6 +172,7 @@ class IncrementalBuilder {
         app: this.#app,
         routeId: msg.routeId,
         seeds: msg.seeds,
+        graphSeeds: msg.graphSeeds,
         artifact: this.#artifact,
         knownEntries: new Set(msg.knownEntries),
         discovery: this.#discovery
@@ -195,7 +195,7 @@ class IncrementalBuilder {
         }
       };
     } catch (err) {
-      const errMsg = err instanceof Error ? err.message : String(err);
+      const errMsg = ApplicationBuildReporter.formatError(err, this.#app.workspace.workspaceRoot);
       this.#logger.error(`build-route failed routeId=${msg.routeId}: ${errMsg}`);
       this.#sendBuildStatus("route", { generation: msg.generation, ok: false, files: msg.seeds, message: errMsg });
       return { type: "build-route-res", id: msg.id, ok: false, error: errMsg };
@@ -335,20 +335,19 @@ class IncrementalBuilder {
     }, 150);
   }
   async installWatcher() {
-    const artifactDir = this.#artifactDir;
     const roots = await new WatchRootResolver(this.#app).resolve();
     const watcher = new HmrWatcher({
       roots,
       logger: this.#logger,
       onBatch: async (batch) => {
-        await this.#enqueueWork("hmr-batch", async () => this.#handleWatchBatch(artifactDir, batch));
+        await this.#enqueueWork("hmr-batch", async () => this.#handleWatchBatch(batch));
       }
     });
     await watcher.start();
     this.#watcher = watcher;
     this.#logger.verbose(`watching ${roots.length} roots`);
   }
-  async#handleWatchBatch(artifactDir, batch) {
+  async#handleWatchBatch(batch) {
     const rawKinds = new Set(batch.kinds);
     if (rawKinds.size === 0)
       return;
@@ -401,7 +400,7 @@ class IncrementalBuilder {
     }
     const needs = [];
     if (kinds.includes("code") && rebuildClient) {
-      if (this.#shouldRebuildCsr())
+      if (this.#csrActive)
         needs.push("csr");
       else
         this.#logger.verbose(`csr-rebundle skipped; request /__csr or ?csr=true (or set AKAN_DEV_CSR_REBUILD=1) to enable per-save CSR rebuilds`);
@@ -416,13 +415,10 @@ class IncrementalBuilder {
       this.#logger.verbose(`css-rebuild scheduled generation=${generation}`);
     }
   }
-  async#runBatch({
-    generation,
-    needs,
-    changedFiles
-  }) {
+  async#runBatch(work) {
+    const { generation, needs, changedFiles } = work;
     const started = Date.now();
-    const result = await this.#batchRunner.run(await this.#batchRequest({ generation, needs, changedFiles }), (msg) => BuilderChannel.emit(msg));
+    const result = await this.#batchRunner.run(await this.#batchRequest(work), (msg) => BuilderChannel.emit(msg));
     if (result.optimizedFonts)
       this.#optimizedFonts = result.optimizedFonts;
     if (result.cssAssets)
@@ -436,11 +432,7 @@ class IncrementalBuilder {
       this.#logger.verbose(`css-rebuild checked (${Date.now() - started}ms)`);
     return result;
   }
-  async#batchRequest({
-    generation,
-    needs,
-    changedFiles
-  }) {
+  async#batchRequest({ generation, needs, changedFiles }) {
     return {
       appName: this.#app.name,
       workspaceRoot: this.#app.workspace.workspaceRoot,
@@ -505,9 +497,6 @@ class IncrementalBuilder {
       await BuilderChannel.send({ type: "build-csr-res", id: msg.id, ok: true });
     });
   }
-  #shouldRebuildCsr() {
-    return this.#csrActive;
-  }
   static #csrArmedByEnv() {
     return process.env.AKAN_DEV_CSR_REBUILD === "1";
   }
@@ -606,23 +595,17 @@ class IncrementalBuilder {
         builder.shutdown(msg.reason);
         return;
       }
-      if (msg.type === "build-route") {
+      if (msg.type !== "build-route" && msg.type !== "build-csr")
+        return;
+      if (!builder || builder.shuttingDown) {
         const error = builder?.shuttingDown ? recyclingError : bootingError;
-        if (!builder || builder.shuttingDown) {
-          BuilderChannel.emit({ type: "build-route-res", id: msg.id, ok: false, error });
-          return;
-        }
-        builder.handleBuildRoute(msg);
+        BuilderChannel.emit({ type: `${msg.type}-res`, id: msg.id, ok: false, error });
         return;
       }
-      if (msg.type === "build-csr") {
-        const error = builder?.shuttingDown ? recyclingError : bootingError;
-        if (!builder || builder.shuttingDown) {
-          BuilderChannel.emit({ type: "build-csr-res", id: msg.id, ok: false, error });
-          return;
-        }
+      if (msg.type === "build-route")
+        builder.handleBuildRoute(msg);
+      else
         builder.handleBuildCsr(msg);
-      }
     });
     process.on("disconnect", () => {
       logger.warn("host IPC channel closed; exiting builder");
@@ -647,7 +630,7 @@ class IncrementalBuilder {
     await builder.rearmCsrFromEnv();
   }
 }
-IncrementalBuilder.main().catch((err) => {
+await IncrementalBuilder.main().catch((err) => {
   console.error(err);
   process.exit(1);
 });

package/{index-h7yw2z9n.js → index-0bq14vr1.js}

@@ -1,12 +1,12 @@
 // @bun
 import {
   getDirname2
-} from "./index-6wwzs1bc.js";
+} from "./index-5b6tavv3.js";
 
 // pkgs/@akanjs/devkit/prompter.ts
 import fsPromise from "fs/promises";
 import { input, select } from "@inquirer/prompts";
-class Prompter {
+class Prompter2 {
   static async#getGuidelineRoot() {
     const dirname = getDirname2(import.meta.url);
     const candidates = [`${dirname}/guidelines`, `${dirname}/../cli/guidelines`];
@@ -19,27 +19,21 @@ class Prompter {
     return candidates[0];
   }
   static async selectGuideline() {
-    const guideNames = await Prompter.listGuidelines();
+    const guideNames = await Prompter2.listGuidelines();
     return await select({
       message: "Select a guideline",
       choices: guideNames.map((name) => ({ name, value: name }))
     });
   }
   static async listGuidelines() {
-    const guidelineRoot = await Prompter.#getGuidelineRoot();
+    const guidelineRoot = await Prompter2.#getGuidelineRoot();
     return (await fsPromise.readdir(guidelineRoot)).filter((name) => !name.startsWith("_")).sort();
   }
-  static async getGuideJson(guideName) {
-    const guidelineRoot = await Prompter.#getGuidelineRoot();
-    const filePath = `${guidelineRoot}/${guideName}/${guideName}.generate.json`;
-    const guideJson = await fsPromise.readFile(filePath, "utf-8");
-    return JSON.parse(guideJson);
-  }
   static async getInstruction(guideName) {
-    const guideNames = await Prompter.listGuidelines();
+    const guideNames = await Prompter2.listGuidelines();
     if (!guideNames.includes(guideName))
       throw new Error(`Unknown guideline "${guideName}". Available: ${guideNames.join(", ")}`);
-    const guidelineRoot = await Prompter.#getGuidelineRoot();
+    const guidelineRoot = await Prompter2.#getGuidelineRoot();
     return await fsPromise.readFile(`${guidelineRoot}/${guideName}/${guideName}.instruction.md`, "utf-8");
   }
   static async getUpdateRequest(guideName) {
@@ -67,7 +61,7 @@ ${request}
 `;
   }
   async getDocumentation(guideName) {
-    const guidelineRoot = await Prompter.#getGuidelineRoot();
+    const guidelineRoot = await Prompter2.#getGuidelineRoot();
     const filePath = `${guidelineRoot}/${guideName}/${guideName}.instruction.md`;
     const document = await fsPromise.readFile(filePath, "utf-8");
     return `\`\`\`markdown
@@ -77,4 +71,4 @@ ${document}
   }
 }
 
-export { Prompter };
+export { Prompter2 };

package/{index-259dsnz3.js → index-1db2cw0y.js}

@@ -2,23 +2,21 @@
 import {
   runner,
   script
-} from "./index-mak3cd28.js";
+} from "./index-rmcw8yc8.js";
 import {
   LibExecutor
-} from "./index-2tv3fdx4.js";
+} from "./index-ga6hygxr.js";
 import {
   LibSource,
   formatLibStatuses
-} from "./index-3d9y066c.js";
+} from "./index-bjwxs904.js";
 
 // pkgs/@akanjs/cli/library/library.script.ts
 import { Logger } from "akanjs/common";
 
 // pkgs/@akanjs/devkit/semver.ts
 var stripRangeOperator = (version) => version.replace(/^[\s^~>=<v]+/, "").trim();
-var parseVersion = (version) => {
-  return version.replace(/^[^\d]*/, "").split(/[.-]/).map((part) => Number.parseInt(part, 10)).map((part) => Number.isFinite(part) ? part : 0);
-};
+var parseVersion = (version) => version.replace(/^[^\d]*/, "").split(/[.-]/).map((part) => Number.parseInt(part, 10)).map((part) => Number.isFinite(part) ? part : 0);
 var compareNumeric = (a, b) => {
   const left = parseVersion(a);
   const right = parseVersion(b);
@@ -44,8 +42,7 @@ class LibraryRunner extends runner("library") {
   async createLibrary(libName, workspace) {
     await workspace.mkdir(`libs/${libName}`);
     await workspace.applyTemplate({ basePath: `libs/${libName}`, template: "libRoot", dict: { libName } });
-    const lib = LibExecutor.from(workspace, libName);
-    return lib;
+    return LibExecutor.from(workspace, libName);
   }
   async removeLibrary(lib) {
     await lib.workspace.removeDir(`libs/${lib.name}`);

package/index-22d57v4c.js

@@ -0,0 +1,266 @@
+// @bun
+import {
+  FileSys2
+} from "./index-5b6tavv3.js";
+import {
+  ConfigLock
+} from "./index-3hx1z96c.js";
+
+// pkgs/@akanjs/devkit/cloud/globalConfig.ts
+import { mkdir, rename, rm, writeFile } from "fs/promises";
+import dayjs from "dayjs";
+
+// pkgs/@akanjs/devkit/cloud/constants.ts
+import path from "path";
+var basePath = path.join(Bun.env.HOME ?? Bun.env.USERPROFILE ?? "", ".akan");
+var configPath = path.join(basePath, "config.json");
+var getDefaultHostConfig = (host = GlobalConfig.akanCloudHost) => ({ host });
+var defaultAkanGlobalConfig = {
+  cloudHost: {},
+  remoteEnvServers: {},
+  testTargets: {}
+};
+
+// pkgs/@akanjs/devkit/cloud/globalConfig.ts
+class GlobalConfig {
+  static akanCloudHost = process.env.USE_AKANJS_PKGS === "true" ? `http://localhost:${process.env.CLOUD_HOST_PORT ?? 8283}` : "https://cloud.akanjs.com";
+  static async#getAkanGlobalConfig() {
+    const exists = await FileSys2.fileExists(configPath);
+    const akanConfig = exists ? await FileSys2.readJson(configPath) : {};
+    return {
+      ...defaultAkanGlobalConfig,
+      ...akanConfig,
+      cloudHost: akanConfig.cloudHost ?? defaultAkanGlobalConfig.cloudHost,
+      remoteEnvServers: akanConfig.remoteEnvServers ?? defaultAkanGlobalConfig.remoteEnvServers,
+      testTargets: akanConfig.testTargets ?? defaultAkanGlobalConfig.testTargets
+    };
+  }
+  static async#setAkanGlobalConfig(akanConfig) {
+    await mkdir(basePath, { recursive: true, mode: 448 });
+    const temp = `${configPath}.${process.pid}.${crypto.randomUUID()}.tmp`;
+    try {
+      await writeFile(temp, JSON.stringify(akanConfig, null, 2), { mode: 384 });
+      await rename(temp, configPath);
+    } catch (error) {
+      await rm(temp, { force: true });
+      throw error;
+    }
+  }
+  static #lockPath = `${configPath}.lock`;
+  static async#update(mutate) {
+    await ConfigLock.run(GlobalConfig.#lockPath, async () => {
+      await GlobalConfig.#setAkanGlobalConfig(mutate(await GlobalConfig.#getAkanGlobalConfig()));
+    });
+  }
+  static async getHostConfig(host = GlobalConfig.akanCloudHost) {
+    const akanConfig = await GlobalConfig.#getAkanGlobalConfig();
+    return GlobalConfig.toHostConfig(akanConfig.cloudHost[host] ?? getDefaultHostConfig(host));
+  }
+  static async setHostConfig(config = getDefaultHostConfig()) {
+    await GlobalConfig.#update((akanConfig) => GlobalConfig.#withHost(akanConfig, config));
+  }
+  static #withHost(akanConfig, config) {
+    return {
+      ...akanConfig,
+      cloudHost: { ...akanConfig.cloudHost, [config.host]: GlobalConfig.toHostConfigDto(config) }
+    };
+  }
+  static async refreshHostAuth(host, refresh) {
+    try {
+      return await ConfigLock.run(GlobalConfig.#lockPath, async () => {
+        const akanConfig = await GlobalConfig.#getAkanGlobalConfig();
+        const current = GlobalConfig.toHostConfig(akanConfig.cloudHost[host] ?? getDefaultHostConfig(host));
+        const accessToken = current.auth?.accessToken;
+        const refreshToken = accessToken?.refreshToken;
+        if (!accessToken || !refreshToken || !GlobalConfig.needRefreshToken(accessToken))
+          return current;
+        const claimed = {
+          ...current,
+          auth: { ...current.auth, accessToken: { ...accessToken, refreshToken: null } }
+        };
+        await GlobalConfig.#setAkanGlobalConfig(GlobalConfig.#withHost(akanConfig, claimed));
+        const next = await refresh(refreshToken).catch(() => null);
+        if (!next?.jwt)
+          return claimed;
+        const refreshed = { ...current, auth: { ...current.auth, accessToken: next } };
+        await GlobalConfig.#setAkanGlobalConfig(GlobalConfig.#withHost(await GlobalConfig.#getAkanGlobalConfig(), refreshed));
+        return refreshed;
+      });
+    } catch {
+      return await GlobalConfig.getHostConfig(host);
+    }
+  }
+  static async getRemoteEnvServers() {
+    return (await GlobalConfig.#getAkanGlobalConfig()).remoteEnvServers;
+  }
+  static async setRemoteEnvServer(name, config) {
+    await GlobalConfig.#update((akanConfig) => ({
+      ...akanConfig,
+      remoteEnvServers: { ...akanConfig.remoteEnvServers, [name]: config }
+    }));
+  }
+  static async removeRemoteEnvServer(name) {
+    await GlobalConfig.#update((akanConfig) => {
+      const { [name]: _, ...remoteEnvServers } = akanConfig.remoteEnvServers;
+      return { ...akanConfig, remoteEnvServers };
+    });
+  }
+  static async getTestTargets() {
+    return (await GlobalConfig.#getAkanGlobalConfig()).testTargets;
+  }
+  static async setTestTargets(testTargets) {
+    await GlobalConfig.#update((akanConfig) => ({
+      ...akanConfig,
+      testTargets: { ...akanConfig.testTargets, ...testTargets }
+    }));
+  }
+  static needRefreshToken(accessToken) {
+    return !!accessToken?.expiresAt?.isBefore(dayjs().add(1, "hour"));
+  }
+  static toAccessToken(accessToken) {
+    return {
+      jwt: accessToken.jwt,
+      refreshToken: accessToken.refreshToken ?? null,
+      expiresAt: accessToken.expiresAt ? dayjs(accessToken.expiresAt) : null
+    };
+  }
+  static toAccessTokenDto(accessToken) {
+    return {
+      jwt: accessToken.jwt,
+      refreshToken: accessToken.refreshToken ?? null,
+      expiresAt: accessToken.expiresAt?.toString() ?? null
+    };
+  }
+  static toHostConfigDto(hostConfig) {
+    return {
+      host: hostConfig.host,
+      auth: {
+        accessToken: hostConfig.auth?.accessToken ? GlobalConfig.toAccessTokenDto(hostConfig.auth.accessToken) : undefined,
+        self: hostConfig.auth?.self
+      }
+    };
+  }
+  static toHostConfig(hostConfigDto) {
+    return {
+      host: hostConfigDto.host,
+      auth: {
+        accessToken: hostConfigDto.auth?.accessToken ? GlobalConfig.toAccessToken(hostConfigDto.auth.accessToken) : undefined,
+        self: hostConfigDto.auth?.self
+      }
+    };
+  }
+}
+
+// pkgs/@akanjs/devkit/cloud/cloudApi.ts
+class HttpClient {
+  baseUrl;
+  headers = {};
+  constructor(baseUrl, headers = {}) {
+    this.baseUrl = baseUrl;
+    this.headers = headers;
+  }
+  async get(url, { headers, signal } = {}) {
+    const response = await fetch(`${this.baseUrl}${url}`, {
+      headers: { "Content-Type": "application/json", ...this.headers, ...headers },
+      ...signal ? { signal } : {}
+    });
+    return await HttpClient.#body(response, url);
+  }
+  async getFile(url, localPath, headers) {
+    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(url, data, { headers, signal } = {}) {
+    const isFormData = data instanceof FormData;
+    const response = await fetch(`${this.baseUrl}${url}`, {
+      method: "POST",
+      body: isFormData ? data : JSON.stringify(data),
+      headers: isFormData ? { ...this.headers, ...headers } : { "Content-Type": "application/json", ...this.headers, ...headers },
+      ...signal ? { signal } : {}
+    });
+    return await HttpClient.#body(response, url);
+  }
+  static async#body(response, url) {
+    const text = await response.text();
+    if (!response.ok)
+      throw new Error(`${response.status} ${response.statusText} from ${url}: ${text.slice(0, 200)}`);
+    return JSON.parse(text);
+  }
+  setHeaders(headers) {
+    Object.assign(this.headers, headers);
+    return this;
+  }
+}
+
+class CloudApi {
+  #api;
+  #accessToken = null;
+  #workspace;
+  host;
+  url;
+  static async fromHost(workspace, host) {
+    const hostConfig = await GlobalConfig.getHostConfig(host);
+    const accessToken = hostConfig.auth?.accessToken;
+    if (!accessToken || !GlobalConfig.needRefreshToken(accessToken))
+      return new CloudApi(workspace, hostConfig);
+    const tokenless = new CloudApi(workspace, hostConfig);
+    const refreshed = await GlobalConfig.refreshHostAuth(hostConfig.host, (refreshToken) => tokenless.refreshAuthToken(refreshToken));
+    return new CloudApi(workspace, refreshed);
+  }
+  constructor(workspace, hostConfig) {
+    this.#workspace = workspace;
+    this.#accessToken = hostConfig.auth?.accessToken ?? null;
+    this.host = hostConfig.host;
+    this.url = `${this.host}/api`;
+    this.#api = new HttpClient(this.url);
+    if (this.#accessToken && !GlobalConfig.needRefreshToken(this.#accessToken))
+      this.#api.setHeaders({ Authorization: `Bearer ${this.#accessToken.jwt}` });
+  }
+  #authorize(accessTokenDto) {
+    this.#accessToken = GlobalConfig.toAccessToken(accessTokenDto);
+    this.#api.setHeaders({ Authorization: `Bearer ${this.#accessToken.jwt}` });
+    return this.#accessToken;
+  }
+  async uploadEnv(devProjectId, file) {
+    const formData = new FormData;
+    formData.append("devProjectId", devProjectId);
+    formData.append("file", file);
+    return await this.#api.post(`/uploadEnv/${devProjectId}`, formData);
+  }
+  async downloadEnv(devProjectId) {
+    const localPath = `${this.#workspace.workspaceRoot}/local/env.tar`;
+    await this.#api.getFile(`/downloadEnv/${devProjectId}`, localPath);
+    return localPath;
+  }
+  async getRemoteAuthToken(remoteId) {
+    try {
+      return this.#authorize(await this.#api.get(`/getRemoteAuthToken/${remoteId}`));
+    } catch (_) {
+      return null;
+    }
+  }
+  async refreshAuthToken(refreshToken) {
+    return this.#authorize(await this.#api.post(`/refreshAuthToken`, { refreshToken }, { signal: AbortSignal.timeout(20000) }));
+  }
+  async requestTunnel(input) {
+    return await this.#api.post(`/tunnel/requestTunnel`, input);
+  }
+  async tunnelListInSelf() {
+    return await this.#api.get(`/tunnel/tunnelListInSelf`);
+  }
+  async revokeTunnel(code) {
+    return await this.#api.post(`/tunnel/revokeTunnel`, { code }, { signal: AbortSignal.timeout(5000) });
+  }
+  async getRemoteSelf() {
+    try {
+      return await this.#api.get(`/getRemoteSelf`);
+    } catch {
+      return null;
+    }
+  }
+}
+export { getDefaultHostConfig, GlobalConfig, CloudApi };