@chat-js/cli 0.6.0 → 0.6.1

package/dist/index.js

@@ -3844,7 +3844,7 @@ var {
 // package.json
 var package_default = {
   name: "@chat-js/cli",
-  version: "0.6.0",
+  version: "0.6.1",
   description: "CLI for creating and extending ChatJS apps",
   license: "Apache-2.0",
   repository: {
@@ -3883,9 +3883,10 @@ var package_default = {
   },
   scripts: {
     start: "bun src/index.ts",
-    build: "bun build ./src/index.ts --target=node --format=esm --outfile ./dist/index.js",
+    build: "bun run template:sync && bun build ./src/index.ts --target=node --format=esm --outfile ./dist/index.js",
+    "test:unit": "bun run template:sync && bun test src",
     "template:sync": "bun ../../scripts/sync-template.ts",
-    prepublishOnly: "bun run template:sync && bun run build && node ./dist/index.js --help >/dev/null"
+    prepublishOnly: "bun run build && node ./dist/index.js --help >/dev/null"
   },
   type: "module",
   devDependencies: {
@@ -19748,9 +19749,134 @@ async function promptInstall(packageManager, skipPrompt) {
 // src/helpers/scaffold.ts
 import { existsSync } from "node:fs";
 import { cp, readFile, rm, writeFile } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
+import { dirname, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 
+// src/helpers/package-manifest.ts
+var ESBUILD_VERSION = "^0.28.0";
+var BETTER_AUTH_PACKAGES = [
+  "@better-auth/core",
+  "@better-auth/electron",
+  "better-auth"
+];
+function toExactVersion(range) {
+  return range.replace(/^[~^]/, "");
+}
+function resolveBetterAuthVersion(packageJson) {
+  for (const dependencyGroup of [
+    packageJson.dependencies,
+    packageJson.devDependencies
+  ]) {
+    if (!dependencyGroup) {
+      continue;
+    }
+    for (const packageName of BETTER_AUTH_PACKAGES) {
+      const version2 = dependencyGroup[packageName];
+      if (version2) {
+        return toExactVersion(version2);
+      }
+    }
+  }
+  return null;
+}
+function pinBetterAuthVersions(dependencyGroup, version2) {
+  if (!dependencyGroup) {
+    return;
+  }
+  for (const packageName of BETTER_AUTH_PACKAGES) {
+    if (dependencyGroup[packageName]) {
+      dependencyGroup[packageName] = version2;
+    }
+  }
+}
+function normalizeChatAppScripts(scripts) {
+  const defaultBranchName = "$" + "{1:-dev-local}";
+  scripts.prebuild = "tsx scripts/check-env.ts";
+  scripts.dev = "tsx scripts/check-env.ts && bash scripts/with-db.sh next dev";
+  scripts["dev:inspect"] = "tsx scripts/check-env.ts && bash scripts/with-db.sh next dev --inspect";
+  scripts.prod = "tsx scripts/check-env.ts && tsx lib/db/migrate.ts && next build && next start";
+  scripts.lint = "ultracite check";
+  scripts.format = "ultracite fix";
+  scripts["check-env"] = "tsx scripts/check-env.ts";
+  scripts["db:migrate"] = "export VERCEL_ENV=production && bash scripts/with-db.sh tsx lib/db/migrate.ts";
+  scripts["db:backfill-parts"] = "tsx lib/db/backfill-parts.ts";
+  scripts["db:branch:start"] = `bash -c 'N=${defaultBranchName}; bash scripts/db-branch-create.sh "$N" && bash scripts/db-branch-use.sh "$N"' --`;
+  scripts["db:branch:stop"] = `bash -c 'N=${defaultBranchName}; bash scripts/db-branch-use.sh main && bash scripts/db-branch-delete.sh "$N"' --`;
+  scripts["db:branch:list"] = "npx neonctl branches list";
+  scripts["skiller:apply"] = "npx skiller@latest apply";
+  scripts.test = "export PLAYWRIGHT=True && playwright test --workers=4 && vitest run";
+  scripts["test:e2e"] = "export PLAYWRIGHT=True && playwright test --workers=4";
+  scripts["ai:devtools"] = "npx @ai-sdk/devtools";
+  scripts["fetch:models"] = "tsx scripts/fetch-models.ts && ultracite fix";
+}
+function normalizeElectronScripts(scripts) {
+  const prebuild = "tsx scripts/write-branding.ts && tsx scripts/generate-icons.ts";
+  const build = "esbuild src/main.ts --bundle --platform=node --format=cjs --outfile=dist/main.js --external:electron --external:electron-updater --alias:@=.. && esbuild src/preload.ts --bundle --platform=browser --format=cjs --outfile=dist/preload.js --external:electron --alias:@=..";
+  scripts.forge = "node ./scripts/run-forge.cjs";
+  scripts["generate-icons"] = "tsx scripts/generate-icons.ts";
+  scripts.prebuild = prebuild;
+  scripts.build = build;
+  scripts.start = "node ./scripts/run-forge.cjs start";
+  scripts.dev = "node ./scripts/run-forge.cjs start";
+  scripts.package = "node ./scripts/run-forge.cjs package";
+  scripts.make = "node ./scripts/run-forge.cjs make";
+  scripts["make:mac"] = "node ./scripts/run-forge.cjs make --platform=darwin --arch=universal";
+  scripts["make:win"] = "node ./scripts/run-forge.cjs make --platform=win32 --arch=x64";
+  scripts["make:linux"] = "node ./scripts/run-forge.cjs make --platform=linux --arch=x64";
+  scripts.publish = "node ./scripts/run-forge.cjs publish";
+  scripts["electron:build"] = build;
+  scripts["electron:dev"] = scripts.dev;
+  scripts["electron:make"] = scripts.make;
+  scripts["electron:publish"] = scripts.publish;
+  delete scripts["dist:mac"];
+  delete scripts["dist:win"];
+  delete scripts["dist:linux"];
+  delete scripts["publish:mac"];
+  delete scripts["publish:win"];
+}
+function normalizeElectronDevDependencies(devDependencies, tsxVersion) {
+  if (!devDependencies) {
+    return;
+  }
+  devDependencies.esbuild = ESBUILD_VERSION;
+  if (tsxVersion) {
+    devDependencies.tsx = tsxVersion;
+  }
+}
+function normalizeScaffoldedPackageJson(packageJson, options) {
+  const betterAuthVersion = resolveBetterAuthVersion(packageJson);
+  if (betterAuthVersion) {
+    pinBetterAuthVersions(packageJson.dependencies, betterAuthVersion);
+    pinBetterAuthVersions(packageJson.devDependencies, betterAuthVersion);
+    packageJson.overrides = {
+      ...packageJson.overrides ?? {},
+      "@better-auth/core": betterAuthVersion
+    };
+  }
+  switch (options?.template) {
+    case "chat-app":
+      if (packageJson.scripts) {
+        normalizeChatAppScripts(packageJson.scripts);
+      }
+      break;
+    case "electron":
+      if (packageJson.scripts) {
+        normalizeElectronScripts(packageJson.scripts);
+      }
+      normalizeElectronDevDependencies(packageJson.devDependencies, options?.tsxVersion);
+      break;
+    default:
+      break;
+  }
+  if (options?.persistPackageManager !== false) {
+    const packageManager = options?.packageManager ?? "bun";
+    if (packageManager !== "bun") {
+      delete packageJson.packageManager;
+    }
+  }
+  return packageJson;
+}
+
 // src/utils/run-command.ts
 import { spawn as spawn2 } from "node:child_process";
 async function runCommand(command, args, cwd) {
@@ -19772,26 +19898,273 @@ ${stderr.join("")}`.trim()));
 }
 
 // src/helpers/scaffold.ts
-function findTemplateDir(name) {
+var CHAT_APP_EXCLUDED_SEGMENTS = new Set([
+  "node_modules",
+  ".next",
+  ".turbo",
+  "playwright",
+  "playwright-report",
+  "test-results",
+  "blob-report",
+  "dist",
+  "build"
+]);
+var CHAT_APP_EXCLUDED_FILES = new Set([
+  ".env.local",
+  ".DS_Store",
+  "bun.lock",
+  "bun.lockb"
+]);
+var ELECTRON_EXCLUDED_SEGMENTS = new Set([
+  "node_modules",
+  ".turbo",
+  "build",
+  "dist",
+  "release"
+]);
+var ELECTRON_EXCLUDED_FILES = new Set([
+  ".DS_Store",
+  "bun.lock",
+  "bun.lockb",
+  "branding.json"
+]);
+function getCliPackageRoot() {
   const __dir = dirname(fileURLToPath(import.meta.url));
-  for (const relative of [`../templates/${name}`, `../../templates/${name}`]) {
-    const candidate = resolve(__dir, relative);
-    if (existsSync(candidate))
+  for (const relative2 of ["..", "../.."]) {
+    const candidate = resolve(__dir, relative2);
+    if (existsSync(join(candidate, "package.json"))) {
       return candidate;
+    }
+  }
+  throw new Error("Could not locate the @chat-js/cli package root.");
+}
+function getRepoRoot() {
+  return resolve(getCliPackageRoot(), "../..");
+}
+function findTemplateDir(name) {
+  const cliRoot = getCliPackageRoot();
+  const candidate = join(cliRoot, "templates", name);
+  return existsSync(candidate) ? candidate : null;
+}
+function shouldCopyChatAppFilePath(sourceDir, filePath) {
+  const relativePath = relative(sourceDir, filePath);
+  const segments = relativePath.split(sep);
+  if (segments.some((segment) => CHAT_APP_EXCLUDED_SEGMENTS.has(segment))) {
+    return false;
   }
-  throw new Error(`Template "${name}" not found. Run \`bun template:sync\` to generate templates.`);
+  const fileName = segments.at(-1);
+  return !(fileName && CHAT_APP_EXCLUDED_FILES.has(fileName));
+}
+function shouldCopyElectronFilePath(sourceDir, filePath) {
+  const relativePath = relative(sourceDir, filePath);
+  const segments = relativePath.split(sep);
+  if (segments.some((segment) => ELECTRON_EXCLUDED_SEGMENTS.has(segment))) {
+    return false;
+  }
+  const fileName = segments.at(-1);
+  return !(fileName && ELECTRON_EXCLUDED_FILES.has(fileName));
+}
+function runScript(packageManager, script) {
+  return `${packageManager} run ${script}`;
+}
+function execCommand(packageManager) {
+  switch (packageManager) {
+    case "bun":
+      return "bunx";
+    case "pnpm":
+      return "pnpm dlx";
+    case "yarn":
+      return "yarn dlx";
+    case "npm":
+      return "npx";
+  }
+}
+async function replaceInFile(filePath, replacements) {
+  if (!existsSync(filePath)) {
+    return;
+  }
+  let content = await readFile(filePath, "utf8");
+  for (const [search, replacement] of replacements) {
+    content = content.replaceAll(search, replacement);
+  }
+  await writeFile(filePath, content);
+}
+async function applyChatTemplateSourceTransforms(destination) {
+  await Promise.all(["components/github-link.tsx", "components/docs-link.tsx"].map((file2) => rm(join(destination, file2), { force: true })));
+  const headerPath = join(destination, "components", "header-actions.tsx");
+  await replaceInFile(headerPath, [
+    [`import { DocsLink } from "@/components/docs-link";
+`, ""],
+    [`import { GitHubLink } from "@/components/github-link";
+`, ""],
+    ["<DocsLink />", ""],
+    ["<GitHubLink />", ""]
+  ]);
+  const globalsCssPath = join(destination, "app", "globals.css");
+  await replaceInFile(globalsCssPath, [
+    [
+      `@source "../node_modules/streamdown/dist/*.js";
+@source "../../../node_modules/streamdown/dist/*.js";`,
+      '@source "../node_modules/streamdown/dist/*.js";'
+    ]
+  ]);
+  const repoPackageJsonPath = join(getRepoRoot(), "package.json");
+  const rootPackageJson = JSON.parse(await readFile(repoPackageJsonPath, "utf8"));
+  const packageJsonPath = join(destination, "package.json");
+  const packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
+  packageJson.packageManager = rootPackageJson.packageManager;
+  await writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
+`);
 }
-async function scaffoldFromTemplate(destination) {
+async function applyElectronTemplateSourceTransforms(destination) {
+  const tsconfigPath = join(destination, "tsconfig.json");
+  await replaceInFile(tsconfigPath, [['"../chat/*"', '"../*"']]);
+  const packageJsonPath = join(destination, "package.json");
+  await replaceInFile(packageJsonPath, [
+    ['"name": "@chatjs/electron"', '"name": "__PROJECT_NAME__-electron"'],
+    [
+      '"url": "https://github.com/FranciscoMoretti/chat-js.git"',
+      '"url": "https://github.com/__GITHUB_OWNER__/__GITHUB_REPO__.git"'
+    ]
+  ]);
+}
+async function copyChatTemplateFromRepoSource(destination) {
+  const sourceDir = join(getRepoRoot(), "apps", "chat");
+  await cp(sourceDir, destination, {
+    recursive: true,
+    filter: (filePath) => shouldCopyChatAppFilePath(sourceDir, filePath)
+  });
+  await applyChatTemplateSourceTransforms(destination);
+}
+async function copyElectronTemplateFromRepoSource(destination) {
+  const sourceDir = join(getRepoRoot(), "apps", "electron");
+  await cp(sourceDir, destination, {
+    recursive: true,
+    filter: (filePath) => shouldCopyElectronFilePath(sourceDir, filePath)
+  });
+  await applyElectronTemplateSourceTransforms(destination);
+}
+async function normalizeChatAppFiles(destination, packageManager) {
+  await replaceInFile(join(destination, "playwright.config.ts"), [
+    ['command: "bun dev"', `command: "${runScript(packageManager, "dev")}"`]
+  ]);
+  await replaceInFile(join(destination, "scripts", "check-env.ts"), [
+    [
+      " * Run via `bun run check-env` or automatically in prebuild.",
+      ` * Run via \`${runScript(packageManager, "check-env")}\` or automatically in prebuild.`
+    ],
+    [
+      "bun fetch:models",
+      runScript(packageManager, "fetch:models")
+    ]
+  ]);
+  await replaceInFile(join(destination, "lib", "ai", "gateways", "fallback-models.ts"), [
+    [
+      "bun fetch:models",
+      runScript(packageManager, "fetch:models")
+    ]
+  ]);
+  await replaceInFile(join(destination, "scripts", "with-db.sh"), [
+    ["bunx neonctl", `${execCommand(packageManager)} neonctl`],
+    ["filter out bun's package resolution output", `filter out ${execCommand(packageManager)} resolution output`],
+    [
+      "Run: bun db:branch:use main  (to switch back to main)",
+      "Run: bash scripts/db-branch-use.sh main  (to switch back to main)"
+    ]
+  ]);
+  await replaceInFile(join(destination, "scripts", "db-branch-create.sh"), [
+    ["bunx neonctl", `${execCommand(packageManager)} neonctl`],
+    [
+      'echo "To use it: bun db:branch:use $BRANCH_NAME"',
+      'echo "To use it: bash scripts/db-branch-use.sh $BRANCH_NAME"'
+    ]
+  ]);
+  await replaceInFile(join(destination, "scripts", "db-branch-use.sh"), [
+    ["bunx neonctl", `${execCommand(packageManager)} neonctl`],
+    ['echo "Usage: bun db:branch:use <branch-name>"', 'echo "Usage: bash scripts/db-branch-use.sh <branch-name>"'],
+    [
+      'echo "       bun db:branch:use main  (switch to production)"',
+      'echo "       bash scripts/db-branch-use.sh main  (switch to production)"'
+    ],
+    ['echo "Available branches: bun db:branch:list"', `echo "Available branches: ${execCommand(packageManager)} neonctl branches list"`],
+    ['echo "Create branch: bun db:branch:create"', 'echo "Create branch: bash scripts/db-branch-create.sh"']
+  ]);
+  await replaceInFile(join(destination, "scripts", "db-branch-delete.sh"), [
+    ["bunx neonctl", `${execCommand(packageManager)} neonctl`]
+  ]);
+  await replaceInFile(join(destination, "scripts", "worktree-setup.sh"), [
+    ["bun i", `${packageManager} install`]
+  ]);
+  const vercelJsonPath = join(destination, "vercel.json");
+  const vercelJson = JSON.parse(await readFile(vercelJsonPath, "utf8"));
+  vercelJson.installCommand = `${packageManager} install`;
+  vercelJson.buildCommand = runScript(packageManager, "build");
+  await writeFile(vercelJsonPath, `${JSON.stringify(vercelJson, null, 2)}
+`);
+}
+async function normalizeElectronFiles(destination, packageManager) {
+  const scriptPlaceholder = "$" + "{script}";
+  await replaceInFile(join(destination, "forge.config.ts"), [
+    ["Run \\`bun run prebuild\\`", "Run \\`" + runScript(packageManager, "prebuild") + "\\`"],
+    ["function runBunScript", "function runPackageManagerScript"],
+    ['spawnSync("bun", ["run", script], {', `spawnSync("${packageManager}", ["run", script], {`],
+    [`bun run ${scriptPlaceholder} failed`, `${packageManager} run ${scriptPlaceholder} failed`],
+    ['  runBunScript("prebuild");', '  runPackageManagerScript("prebuild");'],
+    [
+      '        runBunScript("build", { NODE_ENV: "development" });',
+      '        runPackageManagerScript("build", { NODE_ENV: "development" });'
+    ],
+    [
+      '        runBunScript("build", { NODE_ENV: "production" });',
+      '        runPackageManagerScript("build", { NODE_ENV: "production" });'
+    ]
+  ]);
+  await replaceInFile(join(destination, "README.md"), [
+    ["bun install", `${packageManager} install`],
+    ["bun run dev", runScript(packageManager, "dev")],
+    ["bun run generate-icons", runScript(packageManager, "generate-icons")],
+    ["bun run make:mac", runScript(packageManager, "make:mac")],
+    ["bun run make:win", runScript(packageManager, "make:win")],
+    ["bun run make:linux", runScript(packageManager, "make:linux")]
+  ]);
+}
+async function scaffoldFromTemplate(destination, options) {
+  const packageManager = options?.packageManager ?? "bun";
   const templateDir = findTemplateDir("chat-app");
-  await cp(templateDir, destination, { recursive: true });
+  if (templateDir) {
+    await cp(templateDir, destination, { recursive: true });
+  } else {
+    await copyChatTemplateFromRepoSource(destination);
+  }
+  const packageJsonPath = join(destination, "package.json");
+  const packageJson = normalizeScaffoldedPackageJson(JSON.parse(await readFile(packageJsonPath, "utf8")), {
+    packageManager,
+    template: "chat-app"
+  });
+  await writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
+`);
+  await normalizeChatAppFiles(destination, packageManager);
 }
 async function scaffoldElectron(projectDir, opts) {
-  const templateDir = findTemplateDir("electron");
+  const packageManager = opts.packageManager ?? "bun";
+  const rootPackageJsonPath = join(projectDir, "package.json");
+  const rootPackageJson = JSON.parse(await readFile(rootPackageJsonPath, "utf8"));
   const destination = join(projectDir, "electron");
-  await cp(templateDir, destination, { recursive: true });
+  const templateDir = findTemplateDir("electron");
+  if (templateDir) {
+    await cp(templateDir, destination, { recursive: true });
+  } else {
+    await copyElectronTemplateFromRepoSource(destination);
+  }
   const packageJsonPath = join(destination, "package.json");
-  const packageJson = (await readFile(packageJsonPath, "utf8")).replace("__PROJECT_NAME__-electron", `${opts.projectName}-electron`).replace("__GITHUB_OWNER__", "your-github-username").replace("__GITHUB_REPO__", opts.projectName);
-  await writeFile(packageJsonPath, packageJson);
+  const packageJson = normalizeScaffoldedPackageJson(JSON.parse((await readFile(packageJsonPath, "utf8")).replace("__PROJECT_NAME__-electron", `${opts.projectName}-electron`).replace("__GITHUB_OWNER__", "your-github-username").replace("__GITHUB_REPO__", opts.projectName)), {
+    packageManager,
+    template: "electron",
+    tsxVersion: rootPackageJson.devDependencies?.tsx
+  });
+  await writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
+`);
+  await normalizeElectronFiles(destination, packageManager);
 }
 async function scaffoldFromGit(url2, destination) {
   await runCommand("git", ["clone", "--depth", "1", url2, destination], process.cwd());
@@ -21197,15 +21570,16 @@ var createOptionsSchema = exports_external.object({
   yes: exports_external.boolean(),
   install: exports_external.boolean(),
   electron: exports_external.boolean().optional(),
-  fromGit: exports_external.string().optional()
+  fromGit: exports_external.string().optional(),
+  packageManager: exports_external.enum(["bun", "npm", "pnpm", "yarn"]).optional()
 });
-var create = new Command().name("create").description("scaffold a new ChatJS chat application").argument("[directory]", "target directory for the project").option("-y, --yes", "skip prompts and use defaults", false).option("--no-install", "skip dependency installation").option("--electron", "include the Electron desktop app").option("--no-electron", "do not include the Electron desktop app").option("--from-git <url>", "clone from a git repository instead of the built-in scaffold").action(async (directory, opts) => {
+var create = new Command().name("create").description("scaffold a new ChatJS chat application").argument("[directory]", "target directory for the project").option("-y, --yes", "skip prompts and use defaults", false).option("--no-install", "skip dependency installation").option("--electron", "include the Electron desktop app").option("--no-electron", "do not include the Electron desktop app").option("--package-manager <manager>", "package manager for install + next steps (bun, npm, pnpm, yarn)").option("--from-git <url>", "clone from a git repository instead of the built-in scaffold").action(async (directory, opts) => {
   try {
     const options = createOptionsSchema.parse({
       target: directory,
       ...opts
     });
-    const packageManager = inferPackageManager();
+    const packageManager = options.packageManager ?? inferPackageManager();
     if (!options.yes) {
       mt("Create ChatJS App");
     }
@@ -21225,11 +21599,12 @@ var create = new Command().name("create").description("scaffold a new ChatJS cha
       if (options.fromGit) {
         await scaffoldFromGit(options.fromGit, targetDir);
       } else {
-        await scaffoldFromTemplate(targetDir);
+        await scaffoldFromTemplate(targetDir, { packageManager });
       }
       if (withElectron) {
         await scaffoldElectron(targetDir, {
-          projectName
+          projectName,
+          packageManager
         });
       }
       scaffoldSpinner.succeed("Project scaffolded.");
@@ -21287,7 +21662,7 @@ var create = new Command().name("create").description("scaffold a new ChatJS cha
     if (withElectron) {
       logger.break();
       logger.info("Electron desktop app:");
-      logger.log(`  Run the web app first, then: ${highlighter.info(`cd electron && bun install && bun run dev`)}`);
+      logger.log(`  Run the web app first, then: ${highlighter.info(`cd electron && ${packageManager} install && ${packageManager} run dev`)}`);
     }
     logger.break();
     printEnvChecklist(envEntries);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@chat-js/cli",
-	"version": "0.6.0",
+	"version": "0.6.1",
 	"description": "CLI for creating and extending ChatJS apps",
 	"license": "Apache-2.0",
 	"repository": {
@@ -39,9 +39,10 @@
 	},
 	"scripts": {
 		"start": "bun src/index.ts",
-		"build": "bun build ./src/index.ts --target=node --format=esm --outfile ./dist/index.js",
+		"build": "bun run template:sync && bun build ./src/index.ts --target=node --format=esm --outfile ./dist/index.js",
+		"test:unit": "bun run template:sync && bun test src",
 		"template:sync": "bun ../../scripts/sync-template.ts",
-		"prepublishOnly": "bun run template:sync && bun run build && node ./dist/index.js --help >/dev/null"
+		"prepublishOnly": "bun run build && node ./dist/index.js --help >/dev/null"
 	},
 	"type": "module",
 	"devDependencies": {

package/templates/chat-app/package.json

@@ -184,5 +184,6 @@
     "ultracite": "7.4.3",
     "vite-tsconfig-paths": "^6.1.1",
     "vitest": "^4.0.0"
-  }
+  },
+  "packageManager": "bun@1.3.1"
 }

package/templates/electron/forge.config.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, rmSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { spawnSync } from "node:child_process";
 import type { ForgeConfig } from "@electron-forge/shared-types";
@@ -61,10 +61,6 @@ function ensurePrebuild(): void {
   prebuildComplete = true;
 }
 
-function removeLocalNodeModules(): void {
-  rmSync(join(appRoot, "node_modules"), { recursive: true, force: true });
-}
-
 function createForgeConfig(): ForgeConfig {
   const branding = loadBranding();
   const { appName, appPrefix, orgName, orgEmail } = branding;
@@ -146,7 +142,6 @@ function createForgeConfig(): ForgeConfig {
       },
       prePackage: async () => {
         runBunScript("build", { NODE_ENV: "production" });
-        removeLocalNodeModules();
       },
     },
   };