alchemy 0.74.2 → 0.75.1

package/bin/alchemy.ts

@@ -32,7 +32,7 @@ export type AppRouter = typeof router;
 const cli = createCli({
   router,
   name: "alchemy",
-  version: getPackageVersion(),
+  version: await getPackageVersion(),
   description:
     "🧪 Welcome to Alchemy! Creating infrastructure as code with JavaScript and TypeScript.",
 });

package/bin/commands/create.ts

@@ -10,11 +10,12 @@ import {
   spinner,
   text,
 } from "@clack/prompts";
-import * as fs from "fs-extra";
-import { resolve } from "node:path";
+import { rm } from "fs-extra";
+import { resolve } from "pathe";
 import pc from "picocolors";
 import z from "zod";
 import { detectPackageManager } from "../../src/util/detect-package-manager.ts";
+import { exists } from "../../src/util/exists.ts";
 import { throwWithContext } from "../errors.ts";
 import { initializeGitRepo, isGitInstalled } from "../services/git.ts";
 import { addGitHubWorkflowToAlchemy } from "../services/github-workflow.ts";
@@ -209,7 +210,7 @@ async function getInstallPreference(
 async function handleDirectoryOverwrite(
   context: ProjectContext,
 ): Promise<void> {
-  if (!fs.existsSync(context.path)) {
+  if (!(await exists(context.path))) {
     return;
   }
 
@@ -249,7 +250,7 @@ async function removeExistingDirectory(context: ProjectContext): Promise<void> {
   s.start(`Removing existing directory: ${pc.yellow(context.path)}`);
 
   try {
-    await fs.rm(context.path, { recursive: true, force: true });
+    await rm(context.path, { recursive: true, force: true });
     s.stop(`Directory ${pc.yellow(context.path)} removed.`);
   } catch (error) {
     s.stop(pc.red(`Failed to remove directory ${pc.yellow(context.path)}.`));

package/bin/commands/init.ts

@@ -8,9 +8,15 @@ import {
   outro,
   select,
 } from "@clack/prompts";
-import * as fs from "fs-extra";
+import {
+  ensureDir,
+  ensureFile,
+  readFile,
+  writeFile,
+  writeJson,
+} from "fs-extra";
 import { parse as parseJsonc } from "jsonc-parse";
-import { dirname, relative, resolve } from "node:path";
+import { dirname, relative, resolve } from "pathe";
 import pc from "picocolors";
 import {
   IndentationText,
@@ -21,6 +27,7 @@ import {
 } from "ts-morph";
 import z from "zod";
 import { detectPackageManager } from "../../src/util/detect-package-manager.ts";
+import { exists } from "../../src/util/exists.ts";
 import type { DependencyVersionMap } from "../constants.ts";
 import { throwWithContext } from "../errors.ts";
 import { addPackageDependencies } from "../services/dependencies.ts";
@@ -89,7 +96,7 @@ function sanitizeProjectName(name: string): string {
 
 async function readJsonc(filePath: string): Promise<any> {
   try {
-    const content = await fs.readFile(filePath, "utf-8");
+    const content = await readFile(filePath, "utf-8");
     return parseJsonc(content);
   } catch (error) {
     throw new Error(`Failed to read or parse ${filePath}: ${error}`);
@@ -97,7 +104,7 @@ async function readJsonc(filePath: string): Promise<any> {
 }
 
 async function writeJsonWithSpaces(filePath: string, data: any): Promise<void> {
-  await fs.writeJson(filePath, data, { spaces: 2 });
+  await writeJson(filePath, data, { spaces: 2 });
 }
 
 async function safelyUpdateJson(
@@ -107,7 +114,7 @@ async function safelyUpdateJson(
 ): Promise<void> {
   try {
     let data = fallbackData;
-    if (await fs.pathExists(filePath)) {
+    if (await exists(filePath)) {
       data = await readJsonc(filePath);
     }
     updater(data);
@@ -123,7 +130,7 @@ async function createInitContext(options: {
 }): Promise<InitContext> {
   const cwd = resolve(process.cwd());
   const packageJsonPath = resolve(cwd, "package.json");
-  const hasPackageJson = await fs.pathExists(packageJsonPath);
+  const hasPackageJson = await exists(packageJsonPath);
 
   let projectName = "my-alchemy-app";
   if (hasPackageJson) {
@@ -135,7 +142,7 @@ async function createInitContext(options: {
     } catch (_error) {}
   }
 
-  const useTypeScript = await fs.pathExists(resolve(cwd, "tsconfig.json"));
+  const useTypeScript = await exists(resolve(cwd, "tsconfig.json"));
   const framework =
     options.framework ||
     (await detectFramework(cwd, hasPackageJson, options.yes));
@@ -160,6 +167,7 @@ const FRAMEWORK_DETECTION_MAP: Record<string, TemplateType> = {
   "@sveltejs/kit": "sveltekit",
   "@tanstack/react-start": "tanstack-start",
   vite: "vite",
+  "@types/bun": "bun-spa",
 };
 
 async function detectFramework(
@@ -182,6 +190,7 @@ async function detectFramework(
     options: [
       { label: "TypeScript Worker", value: "typescript" },
       { label: "Vite", value: "vite" },
+      { label: "Bun SPA", value: "bun-spa" },
       { label: "Astro", value: "astro" },
       { label: "React Router", value: "react-router" },
       { label: "SvelteKit", value: "sveltekit" },
@@ -226,9 +235,13 @@ async function detectFrameworkFromPackageJson(
 
 async function checkExistingAlchemyFiles(context: InitContext): Promise<void> {
   const alchemyFiles = ["alchemy.run.ts", "alchemy.run.js"];
-  const existingFile = alchemyFiles.find((file) =>
-    fs.pathExistsSync(resolve(context.cwd, file)),
-  );
+  let existingFile: string | undefined;
+  for (const file of alchemyFiles) {
+    if (await exists(resolve(context.cwd, file))) {
+      existingFile = file;
+      break;
+    }
+  }
 
   if (existingFile) {
     const overwriteResult = await confirm({
@@ -247,9 +260,7 @@ const ALCHEMY_RUN_TEMPLATES: Record<
   Exclude<TemplateType, "hono">,
   (context: InitContext) => string
 > = {
-  typescript: (context) => `/// <reference types="@types/node" />
-
-import alchemy from "alchemy";
+  typescript: (context) => `import alchemy from "alchemy";
 import { Worker } from "alchemy/cloudflare";
 
 const app = await alchemy("${context.projectName}");
@@ -283,9 +294,25 @@ console.log({
 await app.finalize();
 `,
 
-  astro: (context) => `/// <reference types="@types/node" />
+  "bun-spa": (context) => `import alchemy from "alchemy";
+import { BunSPA } from "alchemy/cloudflare";
+
+const app = await alchemy("${context.projectName}");
+
+export const bunsite = await BunSPA("website", {
+  frontend: "src/index.html", // adjust to match your HTML entrypoint(s)
+  entrypoint: "src/server.ts", // your backend API entrypoint
+});
+
+console.log({
+  url: bunsite.url,
+  apiUrl: bunsite.apiUrl,
+});
+
+await app.finalize();
+`,
 
-import alchemy from "alchemy";
+  astro: (context) => `import alchemy from "alchemy";
 import { Astro } from "alchemy/cloudflare";
 
 const app = await alchemy("${context.projectName}");
@@ -305,9 +332,7 @@ console.log({
 await app.finalize();
 `,
 
-  "react-router": (context) => `/// <reference types="@types/node" />
-
-import alchemy from "alchemy";
+  "react-router": (context) => `import alchemy from "alchemy";
 import { ReactRouter } from "alchemy/cloudflare";
 
 const app = await alchemy("${context.projectName}");
@@ -328,9 +353,7 @@ console.log({
 await app.finalize();
 `,
 
-  sveltekit: (context) => `/// <reference types="@types/node" />
-
-import alchemy from "alchemy";
+  sveltekit: (context) => `import alchemy from "alchemy";
 import { SvelteKit } from "alchemy/cloudflare";
 
 const app = await alchemy("${context.projectName}");
@@ -350,9 +373,7 @@ console.log({
 await app.finalize();
 `,
 
-  "tanstack-start": (context) => `/// <reference types="@types/node" />
-
-import alchemy from "alchemy";
+  "tanstack-start": (context) => `import alchemy from "alchemy";
 import { TanStackStart } from "alchemy/cloudflare";
 
 const app = await alchemy("${context.projectName}");
@@ -372,9 +393,7 @@ console.log({
 await app.finalize();
 `,
 
-  rwsdk: (context) => `/// <reference types="@types/node" />
-
-import alchemy from "alchemy";
+  rwsdk: (context) => `import alchemy from "alchemy";
 import { D1Database, DurableObjectNamespace, Redwood } from "alchemy/cloudflare";
 
 const app = await alchemy("${context.projectName}");
@@ -405,9 +424,7 @@ console.log({
 await app.finalize();
 `,
 
-  nextjs: (context) => `/// <reference types="@types/node" />
-
-import alchemy from "alchemy";
+  nextjs: (context) => `import alchemy from "alchemy";
 import { Nextjs } from "alchemy/cloudflare";
 
 const app = await alchemy("${context.projectName}");
@@ -422,9 +439,7 @@ console.log({
 await app.finalize();
 `,
 
-  nuxt: (context) => `/// <reference types="@types/node" />
-
-import alchemy from "alchemy";
+  nuxt: (context) => `import alchemy from "alchemy";
 import { Nuxt } from "alchemy/cloudflare";
 
 const app = await alchemy("${context.projectName}");
@@ -452,7 +467,7 @@ async function createAlchemyRunFile(context: InitContext): Promise<void> {
       ? "alchemy.run.ts"
       : "alchemy.run.js";
     const outputPath = resolve(context.cwd, outputFileName);
-    await fs.writeFile(outputPath, content, "utf-8");
+    await writeFile(outputPath, content, "utf-8");
   } catch (error) {
     throwWithContext(error, "Failed to create alchemy.run file");
   }
@@ -465,6 +480,7 @@ const FRAMEWORK_DEPENDENCIES: Record<TemplateType, DependencyVersionMap[]> = {
   sveltekit: ["alchemy", "@sveltejs/adapter-cloudflare"],
   typescript: ["alchemy"],
   vite: ["alchemy"],
+  "bun-spa": ["alchemy"],
   astro: ["alchemy", "@astrojs/cloudflare"],
   "react-router": ["alchemy", "@cloudflare/vite-plugin"],
   "tanstack-start": ["alchemy"],
@@ -507,11 +523,11 @@ async function updateGitignore(context: InitContext) {
   try {
     const gitignorePath = resolve(context.cwd, ".gitignore");
 
-    await fs.ensureFile(gitignorePath);
+    await ensureFile(gitignorePath);
 
     let gitignoreContent = "";
-    if (await fs.pathExists(gitignorePath)) {
-      gitignoreContent = await fs.readFile(gitignorePath, "utf-8");
+    if (await exists(gitignorePath)) {
+      gitignoreContent = await readFile(gitignorePath, "utf-8");
     }
 
     const lines = gitignoreContent.split("\n").map((line) => line.trim());
@@ -534,7 +550,7 @@ async function updateGitignore(context: InitContext) {
       }
     }
 
-    await fs.writeFile(gitignorePath, lines.join("\n"), "utf-8");
+    await writeFile(gitignorePath, lines.join("\n"), "utf-8");
   } catch (error) {
     throwWithContext(error, "Failed to update .gitignore");
   }
@@ -589,6 +605,7 @@ async function updateProjectConfiguration(context: InitContext): Promise<{
   return {
     typescript: () => updateTypescriptProject(context),
     vite: () => updateViteProject(context),
+    "bun-spa": () => updateBunSpaProject(context),
     astro: () => updateAstroProject(context),
     "react-router": () => updateReactRouterProject(context),
     sveltekit: () => updateSvelteKitProject(context),
@@ -601,7 +618,7 @@ async function updateProjectConfiguration(context: InitContext): Promise<{
 
 async function updateTypescriptProject(context: InitContext): Promise<void> {
   const tsConfigPath = resolve(context.cwd, "tsconfig.json");
-  if (await fs.pathExists(tsConfigPath)) {
+  if (await exists(tsConfigPath)) {
     await updateTsConfig(tsConfigPath, {
       include: ["alchemy.run.ts"],
     });
@@ -611,18 +628,43 @@ async function updateTypescriptProject(context: InitContext): Promise<void> {
 async function updateViteProject(_context: InitContext): Promise<void> {
   // const tsConfigPath = resolve(context.cwd, "tsconfig.json");
   // const tsConfigNodePath = resolve(context.cwd, "tsconfig.node.json");
-  // if (await fs.pathExists(tsConfigPath)) {
+  // if (await exists(tsConfigPath)) {
   //   await updateTsConfig(tsConfigPath, {
   //     exclude: ["alchemy.run.ts", "./types/env.d.ts"],
   //   });
   // }
-  // if ((await fs.pathExists(tsConfigNodePath)) || context.framework === "vite") {
+  // if ((await exists(tsConfigNodePath)) || context.framework === "vite") {
   //   await updateTsConfig(tsConfigNodePath, {
   //     include: ["alchemy.run.ts"],
   //   });
   // }
 }
 
+async function updateBunSpaProject(context: InitContext): Promise<void> {
+  // Validate bunfig.toml exists or create it
+  const bunfigPath = resolve(context.cwd, "bunfig.toml");
+  if (!(await exists(bunfigPath))) {
+    // Create bunfig.toml with required config
+    await writeFile(bunfigPath, `[serve.static]\nenv='BUN_PUBLIC_*'\n`);
+  } else {
+    // Validate bunfig.toml has required config
+    const bunfigContent = await readFile(bunfigPath, "utf8");
+    const hasBunPublicEnv =
+      bunfigContent.includes("env") &&
+      (bunfigContent.includes("BUN_PUBLIC_*") ||
+        bunfigContent.includes("PUBLIC_*"));
+
+    if (!hasBunPublicEnv) {
+      throw new Error(
+        "bunfig.toml must contain the following configuration:\n\n" +
+          "[serve.static]\n" +
+          "env='BUN_PUBLIC_*'\n\n" +
+          "This is required for Alchemy to work with Bun SPA.",
+      );
+    }
+  }
+}
+
 async function updateSvelteKitProject(context: InitContext): Promise<void> {
   await updateSvelteConfig(context);
 
@@ -667,10 +709,12 @@ async function updateNextjsProject(context: InitContext): Promise<void> {
     const candidates = ["ts", "js", "cjs", "mjs"].map((ext) =>
       resolve(context.cwd, `${name}.${ext}`),
     );
-    for (const candidate of candidates) {
-      if (await fs.pathExists(candidate)) {
-        return { path: candidate, exists: true };
-      }
+    const existenceChecks = await Promise.all(
+      candidates.map((candidate) => exists(candidate)),
+    );
+    const foundIdx = existenceChecks.findIndex((exists) => exists);
+    if (foundIdx !== -1) {
+      return { path: candidates[foundIdx], exists: true };
     }
     return { path: candidates[0], exists: false };
   };
@@ -679,7 +723,7 @@ async function updateNextjsProject(context: InitContext): Promise<void> {
   const openNextConfig = await resolveFile("open-next.config");
 
   if (nextConfig.exists) {
-    const fileContent = await fs.readFile(nextConfig.path, "utf-8");
+    const fileContent = await readFile(nextConfig.path, "utf-8");
     let updated = fileContent;
     if (
       !fileContent.includes(
@@ -691,9 +735,9 @@ async function updateNextjsProject(context: InitContext): Promise<void> {
     if (!fileContent.includes("initOpenNextCloudflareForDev()")) {
       updated += "\ninitOpenNextCloudflareForDev();\n";
     }
-    await fs.writeFile(nextConfig.path, updated);
+    await writeFile(nextConfig.path, updated);
   } else {
-    await fs.writeFile(
+    await writeFile(
       nextConfig.path,
       `import { initOpenNextCloudflareForDev } from "@opennextjs/cloudflare";
 import type { NextConfig } from "next";
@@ -710,7 +754,7 @@ initOpenNextCloudflareForDev();
   }
 
   if (!openNextConfig.exists) {
-    await fs.writeFile(
+    await writeFile(
       openNextConfig.path,
       `import { defineCloudflareConfig } from "@opennextjs/cloudflare";
 
@@ -724,7 +768,7 @@ export default defineCloudflareConfig({
 `,
     );
   }
-  await fs.writeFile(
+  await writeFile(
     resolve(context.cwd, "./env.d.ts"),
     `// Auto-generated Cloudflare binding types.
 // @see https://alchemy.run/concepts/bindings/#type-safe-bindings
@@ -759,17 +803,17 @@ async function updateReactRouterProject(context: InitContext): Promise<{
   const wranglerJsonPath = resolve(context.cwd, "wrangler.json");
   const envTsPath = resolve(workersDir, "env.ts");
 
-  await fs.ensureDir(workersDir);
+  await ensureDir(workersDir);
 
   let main: string | undefined;
-  if (await fs.pathExists(wranglerJsonCPath)) {
+  if (await exists(wranglerJsonCPath)) {
     const wranglerJsonC = await readJsonc(wranglerJsonCPath);
     main = wranglerJsonC.main;
-  } else if (await fs.pathExists(wranglerJsonPath)) {
+  } else if (await exists(wranglerJsonPath)) {
     const wranglerJson = await readJsonc(wranglerJsonPath);
     main = wranglerJson.main;
   } else {
-    await fs.writeFile(
+    await writeFile(
       resolve(workersDir, "app.ts"),
       `
       import { createRequestHandler } from "react-router";
@@ -799,7 +843,7 @@ export default {
     );
   }
 
-  await fs.writeFile(
+  await writeFile(
     envTsPath,
     `
     import type { website } from "../alchemy.run.ts";
@@ -837,7 +881,7 @@ declare module "cloudflare:workers" {
 
 async function updateViteConfig(context: InitContext): Promise<void> {
   const viteConfigPath = resolve(context.cwd, "vite.config.ts");
-  if (!(await fs.pathExists(viteConfigPath))) return;
+  if (!(await exists(viteConfigPath))) return;
 
   try {
     const project = new Project({
@@ -922,7 +966,7 @@ async function updateViteConfig(context: InitContext): Promise<void> {
 
 async function updateReactRouterConfigTS(context: InitContext): Promise<void> {
   const configPath = resolve(context.cwd, "react-router.config.ts");
-  if (!(await fs.pathExists(configPath))) return;
+  if (!(await exists(configPath))) return;
 
   try {
     const project = new Project({
@@ -1005,7 +1049,7 @@ async function updateTanStackStartProject(context: InitContext): Promise<void> {
 
 async function updateSvelteConfig(context: InitContext): Promise<void> {
   const svelteConfigPath = resolve(context.cwd, "svelte.config.js");
-  if (!(await fs.pathExists(svelteConfigPath))) return;
+  if (!(await exists(svelteConfigPath))) return;
 
   try {
     const project = new Project({
@@ -1079,7 +1123,7 @@ function updateAdapterInConfig(configObject: Node): void {
 
 async function updateEnvFile(context: InitContext): Promise<void> {
   const envPath = resolve(context.cwd, ".env");
-  await fs.ensureFile(envPath);
+  await ensureFile(envPath);
 
   const envVars = ["ALCHEMY_PASSWORD=change-me"];
   if (context.framework === "rwsdk") {
@@ -1087,9 +1131,9 @@ async function updateEnvFile(context: InitContext): Promise<void> {
   }
 
   let envContent = "";
-  if (await fs.pathExists(envPath)) {
+  if (await exists(envPath)) {
     try {
-      envContent = await fs.readFile(envPath, "utf-8");
+      envContent = await readFile(envPath, "utf-8");
     } catch (error) {
       console.warn("Failed to read .env:", error);
     }
@@ -1109,7 +1153,7 @@ async function updateEnvFile(context: InitContext): Promise<void> {
 
   if (needsUpdate) {
     try {
-      await fs.writeFile(envPath, envContent, "utf-8");
+      await writeFile(envPath, envContent, "utf-8");
     } catch (error) {
       console.warn("Failed to update .env:", error);
     }
@@ -1118,7 +1162,7 @@ async function updateEnvFile(context: InitContext): Promise<void> {
 
 async function updateNuxtConfig(context: InitContext): Promise<void> {
   const nuxtConfigPath = resolve(context.cwd, "nuxt.config.ts");
-  if (!(await fs.pathExists(nuxtConfigPath))) return;
+  if (!(await exists(nuxtConfigPath))) return;
 
   try {
     const project = new Project({
@@ -1193,7 +1237,7 @@ async function updateNuxtConfig(context: InitContext): Promise<void> {
 
 async function updateAstroConfig(context: InitContext): Promise<void> {
   const astroConfigPath = resolve(context.cwd, "astro.config.mjs");
-  if (!(await fs.pathExists(astroConfigPath))) return;
+  if (!(await exists(astroConfigPath))) return;
 
   try {
     const project = new Project({
@@ -1251,7 +1295,7 @@ async function updateAstroConfig(context: InitContext): Promise<void> {
 
 async function updateTanStackViteConfig(context: InitContext): Promise<void> {
   const viteConfigPath = resolve(context.cwd, "vite.config.ts");
-  if (!(await fs.pathExists(viteConfigPath))) return;
+  if (!(await exists(viteConfigPath))) return;
 
   try {
     const project = new Project({

package/bin/commands/util.ts

@@ -162,7 +162,9 @@ async function createCloudflareGodToken() {
 
   while (true) {
     const accountId = await text({
-      message: `Enter account ID ${accountIds.length > 0 ? "(or press enter to finish)" : ""}`,
+      message: `Enter account ID ${
+        accountIds.length > 0 ? "(or press enter to finish)" : ""
+      }`,
       placeholder: accountIds.length === 0 ? "account-id" : "",
       defaultValue: "",
       validate: (value) => {

package/bin/constants.ts

@@ -1,4 +1,4 @@
-import path from "node:path";
+import path from "pathe";
 import { fileURLToPath } from "node:url";
 import { getPackageVersion } from "./services/get-package-version.ts";
 
@@ -10,7 +10,7 @@ export const dependencyVersionMap = {
   alchemy:
     process.env.NODE_ENV === "test"
       ? `file:${path.resolve(PKG_ROOT)}`
-      : getPackageVersion(),
+      : await getPackageVersion(),
 
   miniflare: "^4.20250617.3",
 

package/bin/services/dependencies.ts

@@ -1,6 +1,6 @@
-import fs from "fs-extra";
-import path from "node:path";
+import path from "pathe";
 
+import { readJson, writeJson } from "fs-extra";
 import {
   type DependencyVersionMap,
   dependencyVersionMap,
@@ -15,7 +15,7 @@ export const addPackageDependencies = async (opts: {
 
   const pkgJsonPath = path.join(projectDir, "package.json");
 
-  const pkgJson = await fs.readJson(pkgJsonPath);
+  const pkgJson = await readJson(pkgJsonPath);
 
   if (!pkgJson.dependencies) pkgJson.dependencies = {};
   if (!pkgJson.devDependencies) pkgJson.devDependencies = {};
@@ -34,7 +34,7 @@ export const addPackageDependencies = async (opts: {
     }
   }
 
-  await fs.writeJson(pkgJsonPath, pkgJson, {
+  await writeJson(pkgJsonPath, pkgJson, {
     spaces: 2,
   });
 };

package/bin/services/execute-alchemy.ts

@@ -1,18 +1,18 @@
 import { log } from "@clack/prompts";
 import { spawn } from "node:child_process";
 import { once } from "node:events";
-import { resolve } from "node:path";
+import { resolve } from "pathe";
 import pc from "picocolors";
 import z from "zod";
 import { detectRuntime } from "../../src/util/detect-node-runtime.ts";
 import { detectPackageManager } from "../../src/util/detect-package-manager.ts";
 import { exists } from "../../src/util/exists.ts";
+import { findWorkspaceRoot } from "../../src/util/find-workspace-root.ts";
 import { promiseWithResolvers } from "../../src/util/promise-with-resolvers.ts";
 import { collectData } from "../../src/util/telemetry.ts";
 import { ExitSignal } from "../trpc.ts";
 import { CDPProxy } from "./cdp-manager/cdp-proxy.ts";
 import { CDPManager } from "./cdp-manager/server.ts";
-import { findWorkspaceRoot } from "./find-workspace-root.ts";
 
 export const entrypoint = z
   .string()
@@ -126,7 +126,9 @@ export async function execAlchemy(
 
   args.push(`--telemetry-session-id ${telemetryData.sessionId}`);
   args.push(
-    `--telemetry-ref ${telemetryData.referrer ? `${telemetryData.referrer}+cli` : "cli"}`,
+    `--telemetry-ref ${
+      telemetryData.referrer ? `${telemetryData.referrer}+cli` : "cli"
+    }`,
   );
 
   if (quiet) args.push("--quiet");

package/bin/services/get-package-version.ts

@@ -1,11 +1,11 @@
-import fs from "fs-extra";
-import path from "node:path";
+import { readJSON } from "fs-extra";
+import path from "pathe";
 import { PKG_ROOT } from "../constants.ts";
 
-export const getPackageVersion = () => {
+export const getPackageVersion = async () => {
   const packageJsonPath = path.join(PKG_ROOT, "package.json");
 
-  const packageJsonContent = fs.readJSONSync(packageJsonPath);
+  const packageJsonContent = await readJSON(packageJsonPath);
 
   return packageJsonContent.version ?? "1.0.0";
 };