@dbx-tools/cli 0.6.40 → 0.6.42

package/package.json

@@ -6,50 +6,75 @@
     "directory": "packages/cli/dbx-tools"
   },
   "bin": {
-    "dbx-tools": "./lib/bin/dbx-tools.js",
-    "dbxt": "./lib/bin/dbx-tools.js"
+    "dbx-tools": "./bin/dbx-tools.ts",
+    "dbxt": "./bin/dbx-tools.ts"
+  },
+  "scripts": {
+    "build": "projen build",
+    "compile": "projen compile",
+    "default": "projen default",
+    "package": "projen package",
+    "post-compile": "projen post-compile",
+    "pre-compile": "projen pre-compile",
+    "prepack": "projen prepack",
+    "test": "projen test",
+    "watch": "projen watch",
+    "projen": "projen"
   },
   "devDependencies": {
+    "@types/bun": "^1.3.14",
     "@types/node": "^24.6.0",
-    "tsx": "^4.23.0",
     "typescript": "^5.9.3"
   },
   "dependencies": {
     "@clack/prompts": "^1.7.0",
-    "commander": "^15.0.0",
-    "pnpm": "^11.0.6",
-    "@dbx-tools/core": "0.6.40",
-    "@dbx-tools/shared-core": "0.6.40"
+    "@dbx-tools/core": "0.6.42",
+    "@dbx-tools/shared-core": "0.6.42",
+    "commander": "^15.0.0"
   },
-  "main": "./lib/index.js",
+  "main": "index.ts",
   "license": "UNLICENSED",
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "main": "./lib/index.js",
+    "types": "./lib/index.d.ts",
+    "bin": {
+      "dbx-tools": "./lib/bin/dbx-tools.js",
+      "dbxt": "./lib/bin/dbx-tools.js"
+    },
+    "exports": {
+      ".": {
+        "types": "./lib/index.d.ts",
+        "default": "./lib/index.js"
+      },
+      "./bootstrap": {
+        "types": "./lib/src/bootstrap.d.ts",
+        "default": "./lib/src/bootstrap.js"
+      },
+      "./bun": {
+        "types": "./lib/src/bun.d.ts",
+        "default": "./lib/src/bun.js"
+      },
+      "./cli": {
+        "types": "./lib/src/cli.d.ts",
+        "default": "./lib/src/cli.js"
+      },
+      "./root": {
+        "types": "./lib/src/root.d.ts",
+        "default": "./lib/src/root.js"
+      },
+      "./package.json": "./package.json"
+    }
   },
-  "version": "0.6.40",
-  "types": "./lib/index.d.ts",
+  "version": "0.6.42",
+  "types": "index.ts",
   "type": "module",
   "exports": {
-    ".": {
-      "types": "./lib/index.d.ts",
-      "default": "./lib/index.js"
-    },
-    "./bootstrap": {
-      "types": "./lib/src/bootstrap.d.ts",
-      "default": "./lib/src/bootstrap.js"
-    },
-    "./cli": {
-      "types": "./lib/src/cli.d.ts",
-      "default": "./lib/src/cli.js"
-    },
-    "./pnpm": {
-      "types": "./lib/src/pnpm.d.ts",
-      "default": "./lib/src/pnpm.js"
-    },
-    "./root": {
-      "types": "./lib/src/root.d.ts",
-      "default": "./lib/src/root.js"
-    },
+    ".": "./index.ts",
+    "./bootstrap": "./src/bootstrap.ts",
+    "./bun": "./src/bun.ts",
+    "./cli": "./src/cli.ts",
+    "./root": "./src/root.ts",
     "./package.json": "./package.json"
   },
   "files": [
@@ -63,16 +88,5 @@
       "cli"
     ]
   },
-  "//": "~~ Generated by projen. To modify, edit .projenrc.js and run \"pnpm exec projen\".",
-  "scripts": {
-    "build": "projen build",
-    "compile": "projen compile",
-    "default": "projen default",
-    "package": "projen package",
-    "post-compile": "projen post-compile",
-    "pre-compile": "projen pre-compile",
-    "test": "projen test",
-    "watch": "projen watch",
-    "projen": "projen"
-  }
-}
+  "//": "~~ Generated by projen. To modify, edit .projenrc.js and run \"bunx projen\"."
+}

package/src/bootstrap.ts

@@ -9,7 +9,7 @@ import { join } from "node:path";
 import { intro, outro } from "@clack/prompts";
 import { exec, project } from "@dbx-tools/core";
 import { json, log } from "@dbx-tools/shared-core";
-import { childEnv, resolvePnpmArgv, runPnpm } from "./pnpm.ts";
+import { childEnv, resolveBunArgv, runBun } from "./bun.ts";
 import { rootLabel } from "./root.ts";
 
 const logger = log.logger("dbx-tools:bootstrap");
@@ -25,15 +25,10 @@ const FALLBACK_PROJEN_SPECIFIER = "@dbx-tools/projen@latest";
  * the root `bump`, so the matching engine always exists on the registry.
  *
  * Not `@latest`, and not a bare `@dbx-tools/projen`. A bare specifier can land on
- * a stray `0.0.0`, whose `^0.0.0` caret then reaches no real release. `@latest`
- * has a subtler failure: pnpm 11 applies a `minimumReleaseAge` delay, so for the
- * first day after a release it deliberately resolves a dist-tag to the newest
- * version OLDER than the threshold and merely notes the newer one
- * (`+ @dbx-tools/projen 0.1.24 (0.3.42 is available)`). A bootstrap run right
- * after a release therefore installed a months-old engine against a current CLI,
- * which is how `sync --watch` died on an engine predating its `concurrently`
- * dependency. An explicit range admits only the version we want, so the age
- * heuristic has nothing older to fall back to.
+ * a stray `0.0.0`, whose `^0.0.0` caret then reaches no real release. An explicit
+ * range pinned to this CLI's own version admits only the matching engine, so the
+ * CLI and the engine it drives never drift across a release (they are cut
+ * together by the root `bump`).
  */
 function defaultProjenSpecifier(): string {
   const version = ownVersion();
@@ -92,7 +87,7 @@ export function ensureEngineCurrent(root: string): void {
   if (!expected) return;
   const installed = installedEngineVersion(root);
   if (installed && compareVersions(installed, expected) >= 0) return;
-  runPnpm(["add", "-D", defaultProjenSpecifier()], root);
+  runBun(["add", "-D", defaultProjenSpecifier()], root);
 }
 
 // Reach the class through its module NAMESPACE. Current engines also hoist it
@@ -105,26 +100,21 @@ const project = new projectApi.DBXToolsNodeProject();
 project.synth();
 `;
 
-/** Seed `pnpm-workspace.yaml` so the first \`pnpm add\` can allow esbuild non-interactively. */
-const WORKSPACE_SEED = `packages: []
-allowBuilds:
-  esbuild: true
-`;
-
 /**
- * Turn a folder into a functioning dbx-tools workspace: `pnpm init`, seed
- * `pnpm-workspace.yaml`, add `projen`/`typescript`/`tsx` + the engine package,
- * write a minimal `.projenrc.ts`, synth once (with `PROJEN_DISABLE_POST`), then
- * install. Does not run barrels - run `pnpm run barrels` or a full projen synth
- * post-install to generate package barrels.
+ * Turn a folder into a functioning dbx-tools workspace: `bun init`, seed the
+ * `package.json` workspace fields (bun reads `workspaces`/`trustedDependencies`
+ * from the manifest), add `projen`/`typescript` + the engine package, write a
+ * minimal `.projenrc.ts`, synth once (with `PROJEN_DISABLE_POST`), then install.
+ * Does not run barrels - run `bun run barrels` or a full projen synth post-install
+ * to generate package barrels.
  *
  * Every step is idempotent and self-guarded, so this is safe to run against a
  * folder that ALREADY has a hand-authored `.projenrc.ts` (and even a committed
  * `package.json`) but is missing the installed toolchain - e.g. a freshly copied
  * project whose generated files (including manifests) are gitignored. In that
- * case `pnpm init` and the `.projenrc.ts` scaffold are skipped, but the engine +
- * projen + tsx are (re)installed so the subsequent synth can regenerate
- * everything. See {@link seedToolchain}.
+ * case `bun init` and the `.projenrc.ts` scaffold are skipped, but the engine +
+ * projen are (re)installed so the subsequent synth can regenerate everything.
+ * See {@link seedToolchain}.
  */
 export function bootstrapWorkspace(
   root: string,
@@ -141,16 +131,18 @@ export function bootstrapWorkspace(
 
   runInitialSynth(root);
 
-  runPnpm(["install", "--no-frozen-lockfile", "--force"], root);
+  runBun(["install"], root);
   outro("Workspace ready - re-run dbx-tools or add packages under packages/");
 }
 
 /**
- * Install the toolchain a synth needs (`projen`, `typescript`, `tsx`, and the
- * dbx-tools engine), seeding a `package.json` and `pnpm-workspace.yaml` first
- * when absent. Idempotent: run it whenever the engine is missing, so a copied
- * project with a `.projenrc.ts` but no `node_modules`/manifests can be brought
- * up to a synth-ready state without full bootstrapping.
+ * Install the toolchain a synth needs (`projen`, `typescript`, and the dbx-tools
+ * engine), seeding a `package.json` first when absent. bun reads its workspace
+ * config (`workspaces`/`trustedDependencies`) from the manifest, so there is no
+ * separate workspace file to seed - the engine writes `pnpm-workspace.yaml` at
+ * synth for the Databricks Apps platform. Idempotent: run it whenever the engine
+ * is missing, so a copied project with a `.projenrc.ts` but no
+ * `node_modules`/manifest can be brought up to a synth-ready state.
  */
 export function seedToolchain(
   root: string,
@@ -158,15 +150,10 @@ export function seedToolchain(
 ): void {
   const manifestPath = join(root, "package.json");
   if (!existsSync(manifestPath)) {
-    runPnpm(["init"], root);
+    runBun(["init", "-y"], root);
     normalizeSeedManifest(manifestPath);
   }
 
-  const workspaceFile = join(root, "pnpm-workspace.yaml");
-  if (!existsSync(workspaceFile)) {
-    writeFileSync(workspaceFile, WORKSPACE_SEED);
-  }
-
   seedRegistry(root);
 
   const kernelArch = exec.spawnSync("uname", ["-m"], {
@@ -176,31 +163,21 @@ export function seedToolchain(
   }).stdout;
   logger.info("seeding toolchain", {
     node: process.version,
+    bun: process.versions.bun,
     platform: process.platform,
     arch: process.arch,
     kernelArch: kernelArch || "unknown",
     engine: projenSpecifier,
   });
-  runPnpm(
-    [
-      "add",
-      "--reporter=append-only",
-      "-D",
-      "projen",
-      "typescript@^5.9.3",
-      "tsx@^4.23.0",
-      projenSpecifier,
-    ],
-    root,
-  );
+  runBun(["add", "-D", "projen", "typescript@^5.9.3", "@types/bun", projenSpecifier], root);
 }
 
 /**
  * Pin a non-default registry into the new root's `.npmrc`.
  *
- * The CLI already forces `--registry` onto the pnpm invocations it makes itself,
- * but a bootstrapped workspace outlives this process: every later `pnpm install`
- * the developer (or projen's post-synth step) runs is on its own. pnpm ignores
+ * The CLI already forces `--registry` onto the bun invocations it makes itself,
+ * but a bootstrapped workspace outlives this process: every later `bun install`
+ * the developer (or projen's post-synth step) runs is on its own. bun ignores
  * `npm_config_registry` from the environment, so without a file on disk those
  * runs revert to `https://registry.npmjs.org/` - which is a hard failure where
  * the custom registry was the only reachable one.
@@ -217,44 +194,36 @@ function seedRegistry(root: string): void {
 }
 
 /**
- * Make what `pnpm init` produced safe to synth against. Two corrections, both
- * because that output varies by pnpm version:
- *
- *   - drop `devEngines`, which pnpm 11 seeds as `packageManager: { name: "pnpm",
- *     onFail: "download" }`. Any npm-based tool later in the chain (an
- *     `npx`/dlx fallback) then refuses with EBADDEVENGINES, its runner being npm;
- *   - force `type: "module"`, which pnpm 11 writes and pnpm 10 does not. tsx
- *     picks the entry's format from the nearest manifest, so without it
- *     `.projenrc.ts` loads as CJS and the first dependency using top-level await
- *     dies on "not supported with the cjs output format".
- *
- * projen regenerates the whole manifest at synth, so this only has to hold the
- * seed together long enough to get there.
+ * Make what `bun init` produced safe to synth against: force `type: "module"`
+ * (bun runs `.projenrc.ts` fine either way, but projen's ESM sources and the
+ * emitted config assume module type) and drop any `packageManager`/`devEngines`
+ * field that would pin a different manager. projen regenerates the whole manifest
+ * at synth, so this only has to hold the seed together long enough to get there.
  */
 function normalizeSeedManifest(manifestPath: string): void {
   try {
     const manifest = json.parseRecord(readFileSync(manifestPath, "utf8"));
     if (!manifest) return;
     delete manifest.devEngines;
+    delete manifest.packageManager;
     manifest.type = "module";
     writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
   } catch {
-    // A malformed/absent manifest here just means the later `pnpm add` recreates it.
+    // A malformed/absent manifest here just means the later `bun add` recreates it.
   }
 }
 
 /**
- * Run the initial synth by executing `.projenrc.ts` directly with tsx (with
+ * Run the initial synth by executing `.projenrc.ts` directly with bun (with
  * `PROJEN_DISABLE_POST` set), NOT `projen <task>`. Use right after seeding a
  * fresh workspace: the projen TASKS (`sync`, `barrels`, ...) only exist once
  * `.projenrc.ts` has run once, so `projen sync` can't be the bootstrapping step.
  */
 export function runInitialSynth(root: string): void {
-  const [command, ...prefix] = resolvePnpmArgv();
-  // No `--registry` here: this is `pnpm exec`, whose trailing arguments belong to
-  // tsx. The registry reaches anything nested through `childEnv` and the seeded
-  // `.npmrc` instead.
-  exec.spawnSync(command, [...prefix, "exec", "tsx", ".projenrc.ts"], {
+  const [command, ...prefix] = resolveBunArgv();
+  // bun runs the `.ts` directly. The registry reaches anything nested through
+  // `childEnv` and the seeded `.npmrc`.
+  exec.spawnSync(command, [...prefix, ".projenrc.ts"], {
     cwd: root,
     env: childEnv({ PROJEN_DISABLE_POST: "true" }),
     check: true,

package/src/bun.ts

@@ -0,0 +1,136 @@
+/**
+ * bun discovery, workspace install, and projen forwarding for the `dbx-tools` CLI.
+ *
+ * ## Forcing a custom registry
+ *
+ * bun honors a `--registry <url>` flag on `bun install`/`bun add` and a project
+ * `.npmrc`, but (like pnpm) ignores the `npm_config_registry` env var for its own
+ * resolution. So a custom registry is forced through TWO channels, each where it
+ * applies:
+ *
+ *  - {@link bunRegistryArgs} passes `--registry` to the package-resolving
+ *    subcommands (`install`/`add`/`update`), never to `bun run`/`bunx`, whose
+ *    trailing args belong to the script.
+ *  - {@link childEnv} keeps `.npmrc`-style env aliases set for any nested
+ *    npm-based tool, and (critically) puts the bun/node executable dir on PATH so
+ *    a lifecycle script can invoke the runtime by bare name.
+ *
+ * `@dbx-tools/core`'s `npmRegistry({ overrideOnly: true })` returns nothing when
+ * the effective registry IS npmjs, so none of this touches a default install.
+ *
+ * @module
+ */
+import { existsSync } from "node:fs";
+import { delimiter, dirname, join } from "node:path";
+import { exec, project } from "@dbx-tools/core";
+import { functionModule, log } from "@dbx-tools/shared-core";
+import { needsInstall } from "./root.ts";
+
+const logger = log.logger("dbx-tools:bun");
+
+/**
+ * bun subcommands that resolve packages from a registry, and therefore accept a
+ * meaningful `--registry`. Everything else (`run`, `x`, `pm`, ...) is left alone:
+ * `run`/`x` forward trailing arguments to the script they run.
+ */
+const REGISTRY_SUBCOMMANDS = new Set(["add", "install", "i", "update", "up"]);
+
+/**
+ * The registry to force onto child installs, or `undefined` when the effective
+ * one is already the public default.
+ *
+ * `envVars: true` also consults `npm_config_registry` directly, because a
+ * container may export it without any `.npmrc` for lookup. Memoized: resolution
+ * shells out.
+ */
+const registryOverride = functionModule.memoize((): string | undefined =>
+  project.npmRegistry(null, { overrideOnly: true, envVars: true })?.toString(),
+);
+
+/** `--registry <url>` for a bun invocation, or `[]` when the subcommand doesn't resolve. */
+export function bunRegistryArgs(args: readonly string[]): string[] {
+  const url = registryOverride();
+  if (!url) return [];
+  return bunUsesRegistry(args) ? ["--registry", url] : [];
+}
+
+/** Whether the first bun subcommand resolves packages and accepts `--registry`. */
+export function bunUsesRegistry(args: readonly string[]): boolean {
+  const subcommand = args.find((arg) => !arg.startsWith("-"));
+  return subcommand !== undefined && REGISTRY_SUBCOMMANDS.has(subcommand);
+}
+
+/**
+ * `process.env` plus the runtime executable directory and registry aliases.
+ *
+ * The executable directory matters when this CLI was launched by absolute path:
+ * bun runs, but a lifecycle script that invokes `bun`/`node` by bare name would
+ * otherwise fail with `command not found`. Prepending `dirname(process.execPath)`
+ * (the running bun binary's dir) puts the runtime back on PATH.
+ */
+export function childEnv(extra?: Record<string, string>): NodeJS.ProcessEnv {
+  const env: NodeJS.ProcessEnv = { ...process.env, ...extra };
+  const runtimeBin = dirname(process.execPath);
+  const pathEntries = (env.PATH ?? "").split(delimiter).filter(Boolean);
+  if (!pathEntries.includes(runtimeBin)) {
+    env.PATH = [runtimeBin, ...pathEntries].join(delimiter);
+  }
+  const url = registryOverride();
+  if (url) {
+    // Both cases: env is case-sensitive on POSIX, and npm lowercases when reading.
+    env.npm_config_registry = url;
+    env.NPM_CONFIG_REGISTRY = url;
+  }
+  return env;
+}
+
+/**
+ * Resolve the argv prefix to run bun: the `bun` package's own bin when this CLI
+ * is itself running under bun (`process.execPath` is the bun binary), else a bare
+ * `bun` on PATH. No corepack/npx fallback - bun is the ambient runtime this
+ * toolchain requires.
+ */
+function resolveBunArgvImpl(): string[] {
+  // The running process IS bun in every supported path (the bin is `bun <file>`),
+  // so reuse it directly - no PATH lookup, no package-manager shim.
+  if (/\bbun\b/.test(process.execPath)) return [process.execPath];
+  return ["bun"];
+}
+
+/** Memoized `[command, ...prefix]` argv prefix to run bun. */
+export const resolveBunArgv = functionModule.memoize(resolveBunArgvImpl);
+
+/** Run bun with inherited stdio from `cwd`, forcing the resolved registry. */
+export function runBun(args: string[], cwd: string): void {
+  const [command, ...prefix] = resolveBunArgv();
+  const registryArgs = bunRegistryArgs(args);
+  if (registryArgs.length > 0) {
+    logger.info(`running bun with registry: ${registryArgs[1]}`);
+  }
+  exec.spawnSync(command, [...prefix, ...args, ...registryArgs], {
+    cwd,
+    check: true,
+    env: childEnv(),
+  });
+}
+
+/** Install workspace dependencies when `node_modules` or projen is missing. */
+export function ensureWorkspaceReady(root: string): void {
+  if (needsInstall(root)) {
+    runBun(["install"], root);
+  }
+}
+
+/**
+ * Run projen with the given args from `root`. Prefers the installed `projen` bin
+ * via `bun run`, so the workspace's own engine + tasks are used.
+ */
+export function runProjen(args: string[], root: string): void {
+  const projenBin = join(root, "node_modules", ".bin", "projen");
+  if (existsSync(projenBin)) {
+    runBun([projenBin, ...args], root);
+    return;
+  }
+  // Fallback: resolve projen through bun's package runner.
+  runBun(["x", "projen", ...args], root);
+}

package/src/cli.ts

@@ -10,11 +10,11 @@ import {
   runInitialSynth,
   seedToolchain,
 } from "./bootstrap.ts";
-import { ensureWorkspaceReady, runPnpm, runProjen } from "./pnpm.ts";
+import { ensureWorkspaceReady, runBun, runProjen } from "./bun.ts";
 import { findWorkspaceRoot, needsBootstrap, needsToolchain } from "./root.ts";
 
 /**
- * Prepare the workspace at `root`, then run `pnpm exec projen` with `projenArgs`.
+ * Prepare the workspace at `root`, then run projen (via bun) with `projenArgs`.
  *
  * Three cases, in order:
  *   - no `.projenrc.ts` at all -> full bootstrap (scaffold + install + synth),
@@ -36,7 +36,7 @@ async function prepareAndRunProjen(projenArgs: string[], startDir?: string): Pro
   if (needsToolchain(root)) {
     seedToolchain(root);
     runInitialSynth(root);
-    runPnpm(["install", "--no-frozen-lockfile", "--force"], root);
+    runBun(["install"], root);
     return;
   }
   ensureWorkspaceReady(root);

package/lib/src/pnpm.d.ts

@@ -1,23 +0,0 @@
-/** `--registry <url>` for npx, or `[]`. Placed BEFORE the package name by callers. */
-export declare function npxRegistryArgs(): string[];
-/** `--registry <url>` for a pnpm invocation, or `[]` when the subcommand does not resolve. */
-export declare function pnpmRegistryArgs(args: readonly string[]): string[];
-/** Whether the first pnpm subcommand resolves packages and accepts `--registry`. */
-export declare function pnpmUsesRegistry(args: readonly string[]): boolean;
-/**
- * `process.env` plus the current Node executable directory and registry aliases.
- *
- * The executable directory matters when this CLI was launched by absolute path
- * (for example from QuickJS or mise activation that was not exported): pnpm
- * itself runs, but lifecycle scripts invoke `node` by name and otherwise fail
- * with `sh: node: not found`.
- */
-export declare function childEnv(extra?: Record<string, string>): NodeJS.ProcessEnv;
-/** Memoized `[command, ...prefix]` argv prefix to run pnpm (resolved install, else corepack, else npx). */
-export declare const resolvePnpmArgv: () => string[];
-/** Run pnpm with inherited stdio from `cwd`, forcing the resolved registry. */
-export declare function runPnpm(args: string[], cwd: string): void;
-/** Install workspace dependencies when `node_modules` or projen is missing. */
-export declare function ensureWorkspaceReady(root: string): void;
-/** Run `pnpm exec projen` with the given args from `root`. */
-export declare function runProjen(args: string[], root: string): void;