@dbx-tools/cli 0.3.43 → 0.4.0

package/index.ts

@@ -6,7 +6,7 @@ export * as bootstrap from "./src/bootstrap";
 export * as cli from "./src/cli";
 export * as pnpm from "./src/pnpm";
 export * as root from "./src/root";
-export { bootstrapWorkspace, seedToolchain, runInitialSynth } from "./src/bootstrap";
+export { ensureEngineCurrent, bootstrapWorkspace, seedToolchain, runInitialSynth } from "./src/bootstrap";
 export { runCli } from "./src/cli";
 export { resolvePnpmArgv, runPnpm, ensureWorkspaceReady, runProjen } from "./src/pnpm";
 export { findWorkspaceRoot, needsBootstrap, needsInstall, needsToolchain, workspaceRoot, rootLabel } from "./src/root";

package/lib/bin/dbx-tools.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env -S npx tsx
+export {};

package/lib/bin/dbx-tools.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env -S npx tsx
+/**
+ * `dbx-tools` bootstraps uninitialized workspaces, then forwards to projen.
+ */
+import { runCli } from "../src/cli.js";
+runCli(process.argv).catch((err) => {
+    console.error(err);
+    process.exit(1);
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGJ4LXRvb2xzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vYmluL2RieC10b29scy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQ0E7O0dBRUc7QUFDSCxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sWUFBWSxDQUFDO0FBRXBDLE1BQU0sQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsS0FBSyxDQUFDLENBQUMsR0FBWSxFQUFFLEVBQUU7SUFDMUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUNuQixPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDO0FBQ2xCLENBQUMsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiIyEvdXNyL2Jpbi9lbnYgLVMgbnB4IHRzeFxuLyoqXG4gKiBgZGJ4LXRvb2xzYCBib290c3RyYXBzIHVuaW5pdGlhbGl6ZWQgd29ya3NwYWNlcywgdGhlbiBmb3J3YXJkcyB0byBwcm9qZW4uXG4gKi9cbmltcG9ydCB7IHJ1bkNsaSB9IGZyb20gXCIuLi9zcmMvY2xpXCI7XG5cbnJ1bkNsaShwcm9jZXNzLmFyZ3YpLmNhdGNoKChlcnI6IHVua25vd24pID0+IHtcbiAgY29uc29sZS5lcnJvcihlcnIpO1xuICBwcm9jZXNzLmV4aXQoMSk7XG59KTtcbiJdfQ==

package/lib/index.d.ts

@@ -0,0 +1,8 @@
+export * as bootstrap from "./src/bootstrap.js";
+export * as cli from "./src/cli.js";
+export * as pnpm from "./src/pnpm.js";
+export * as root from "./src/root.js";
+export { ensureEngineCurrent, bootstrapWorkspace, seedToolchain, runInitialSynth } from "./src/bootstrap.js";
+export { runCli } from "./src/cli.js";
+export { resolvePnpmArgv, runPnpm, ensureWorkspaceReady, runProjen } from "./src/pnpm.js";
+export { findWorkspaceRoot, needsBootstrap, needsInstall, needsToolchain, workspaceRoot, rootLabel } from "./src/root.js";

package/lib/index.js

@@ -0,0 +1,12 @@
+// GENERATED by projen watch - DO NOT EDIT.
+// Regenerated from the exporting modules in ./src.
+// Hand edits are overwritten on the next watch; this file is read-only.
+export * as bootstrap from "./src/bootstrap.js";
+export * as cli from "./src/cli.js";
+export * as pnpm from "./src/pnpm.js";
+export * as root from "./src/root.js";
+export { ensureEngineCurrent, bootstrapWorkspace, seedToolchain, runInitialSynth } from "./src/bootstrap.js";
+export { runCli } from "./src/cli.js";
+export { resolvePnpmArgv, runPnpm, ensureWorkspaceReady, runProjen } from "./src/pnpm.js";
+export { findWorkspaceRoot, needsBootstrap, needsInstall, needsToolchain, workspaceRoot, rootLabel } from "./src/root.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyQ0FBMkM7QUFDM0MsbURBQW1EO0FBQ25ELHdFQUF3RTtBQUV4RSxPQUFPLEtBQUssU0FBUyxNQUFNLGlCQUFpQixDQUFDO0FBQzdDLE9BQU8sS0FBSyxHQUFHLE1BQU0sV0FBVyxDQUFDO0FBQ2pDLE9BQU8sS0FBSyxJQUFJLE1BQU0sWUFBWSxDQUFDO0FBQ25DLE9BQU8sS0FBSyxJQUFJLE1BQU0sWUFBWSxDQUFDO0FBQ25DLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxrQkFBa0IsRUFBRSxhQUFhLEVBQUUsZUFBZSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDMUcsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLFdBQVcsQ0FBQztBQUNuQyxPQUFPLEVBQUUsZUFBZSxFQUFFLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxTQUFTLEVBQUUsTUFBTSxZQUFZLENBQUM7QUFDdkYsT0FBTyxFQUFFLGlCQUFpQixFQUFFLGNBQWMsRUFBRSxZQUFZLEVBQUUsY0FBYyxFQUFFLGFBQWEsRUFBRSxTQUFTLEVBQUUsTUFBTSxZQUFZLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBHRU5FUkFURUQgYnkgcHJvamVuIHdhdGNoIC0gRE8gTk9UIEVESVQuXG4vLyBSZWdlbmVyYXRlZCBmcm9tIHRoZSBleHBvcnRpbmcgbW9kdWxlcyBpbiAuL3NyYy5cbi8vIEhhbmQgZWRpdHMgYXJlIG92ZXJ3cml0dGVuIG9uIHRoZSBuZXh0IHdhdGNoOyB0aGlzIGZpbGUgaXMgcmVhZC1vbmx5LlxuXG5leHBvcnQgKiBhcyBib290c3RyYXAgZnJvbSBcIi4vc3JjL2Jvb3RzdHJhcFwiO1xuZXhwb3J0ICogYXMgY2xpIGZyb20gXCIuL3NyYy9jbGlcIjtcbmV4cG9ydCAqIGFzIHBucG0gZnJvbSBcIi4vc3JjL3BucG1cIjtcbmV4cG9ydCAqIGFzIHJvb3QgZnJvbSBcIi4vc3JjL3Jvb3RcIjtcbmV4cG9ydCB7IGVuc3VyZUVuZ2luZUN1cnJlbnQsIGJvb3RzdHJhcFdvcmtzcGFjZSwgc2VlZFRvb2xjaGFpbiwgcnVuSW5pdGlhbFN5bnRoIH0gZnJvbSBcIi4vc3JjL2Jvb3RzdHJhcFwiO1xuZXhwb3J0IHsgcnVuQ2xpIH0gZnJvbSBcIi4vc3JjL2NsaVwiO1xuZXhwb3J0IHsgcmVzb2x2ZVBucG1Bcmd2LCBydW5QbnBtLCBlbnN1cmVXb3Jrc3BhY2VSZWFkeSwgcnVuUHJvamVuIH0gZnJvbSBcIi4vc3JjL3BucG1cIjtcbmV4cG9ydCB7IGZpbmRXb3Jrc3BhY2VSb290LCBuZWVkc0Jvb3RzdHJhcCwgbmVlZHNJbnN0YWxsLCBuZWVkc1Rvb2xjaGFpbiwgd29ya3NwYWNlUm9vdCwgcm9vdExhYmVsIH0gZnJvbSBcIi4vc3JjL3Jvb3RcIjtcbiJdfQ==

package/lib/src/bootstrap.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Upgrade an established workspace whose installed engine predates this CLI.
+ *
+ * Bootstrapping pins the engine once, and nothing afterwards revisits it - so a
+ * workspace created months ago kept resolving its original engine no matter how
+ * current the CLI invoking it was, and failed inside the OLD engine's code
+ * (`sync --watch` dying on a `concurrently` that engine never declared). The two
+ * are released in lockstep, so this CLI's version is exactly the engine it
+ * expects.
+ *
+ * Only ever moves FORWARD: an engine at or ahead of this CLI is left alone, so
+ * an older CLI cannot downgrade a workspace.
+ */
+export declare function ensureEngineCurrent(root: string): void;
+/**
+ * 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.
+ *
+ * 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}.
+ */
+export declare function bootstrapWorkspace(root: string, projenSpecifier?: string): void;
+/**
+ * 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.
+ */
+export declare function seedToolchain(root: string, projenSpecifier?: string): void;
+/**
+ * Run the initial synth by executing `.projenrc.ts` directly with tsx (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 declare function runInitialSynth(root: string): void;

package/lib/src/bootstrap.js

@@ -0,0 +1,186 @@
+/**
+ * Bootstrap a brand-new folder into a working dbx-tools workspace before projen runs.
+ *
+ * @module
+ */
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { intro, outro } from "@clack/prompts";
+import { exec } from "@dbx-tools/core";
+import { json } from "@dbx-tools/shared-core";
+import { resolvePnpmArgv, runPnpm } from "./pnpm.js";
+import { rootLabel } from "./root.js";
+/** Fallback when this CLI's own version isn't a real release (an in-repo `0.0.0`). */
+const FALLBACK_PROJEN_SPECIFIER = "@dbx-tools/projen@latest";
+/**
+ * Install the engine at THIS CLI's own version. The two are released together by
+ * 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.
+ */
+function defaultProjenSpecifier() {
+    const version = ownVersion();
+    return version ? `@dbx-tools/projen@^${version}` : FALLBACK_PROJEN_SPECIFIER;
+}
+/** This CLI's own released version, or `undefined` for an in-repo `0.0.0` build. */
+function ownVersion() {
+    try {
+        const manifestPath = fileURLToPath(new URL("../package.json", import.meta.url));
+        const version = json.parseRecord(readFileSync(manifestPath, "utf8"))?.version;
+        return typeof version === "string" && version !== "0.0.0" ? version : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Compare `x.y.z` triples; returns <0, 0, or >0. Missing parts count as 0. */
+function compareVersions(a, b) {
+    const parts = (v) => v.split(".").map((p) => Number.parseInt(p, 10) || 0);
+    const [x, y] = [parts(a), parts(b)];
+    return x[0] - y[0] || x[1] - y[1] || x[2] - y[2];
+}
+/** Version of the engine currently installed at `root`, if any. */
+function installedEngineVersion(root) {
+    try {
+        const manifest = join(root, "node_modules", "@dbx-tools", "projen", "package.json");
+        const version = json.parseRecord(readFileSync(manifest, "utf8"))?.version;
+        return typeof version === "string" ? version : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Upgrade an established workspace whose installed engine predates this CLI.
+ *
+ * Bootstrapping pins the engine once, and nothing afterwards revisits it - so a
+ * workspace created months ago kept resolving its original engine no matter how
+ * current the CLI invoking it was, and failed inside the OLD engine's code
+ * (`sync --watch` dying on a `concurrently` that engine never declared). The two
+ * are released in lockstep, so this CLI's version is exactly the engine it
+ * expects.
+ *
+ * Only ever moves FORWARD: an engine at or ahead of this CLI is left alone, so
+ * an older CLI cannot downgrade a workspace.
+ */
+export function ensureEngineCurrent(root) {
+    const expected = ownVersion();
+    if (!expected)
+        return;
+    const installed = installedEngineVersion(root);
+    if (installed && compareVersions(installed, expected) >= 0)
+        return;
+    runPnpm(["add", "-D", defaultProjenSpecifier()], root);
+}
+// Reach the class through its module NAMESPACE. Current engines also hoist it
+// flat, but every engine ever published exports the namespace, and this template
+// is resolved against `@latest` - a flat import dies on an older one with
+// "does not provide an export named 'DBXToolsNodeProject'".
+const PROJENRC_TEMPLATE = `import { project as projectApi } from "@dbx-tools/projen";
+
+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.
+ *
+ * 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}.
+ */
+export function bootstrapWorkspace(root, projenSpecifier = defaultProjenSpecifier()) {
+    intro(`Bootstrapping dbx-tools workspace in ${rootLabel(root)}`);
+    seedToolchain(root, projenSpecifier);
+    const projenrc = join(root, ".projenrc.ts");
+    if (!existsSync(projenrc)) {
+        writeFileSync(projenrc, PROJENRC_TEMPLATE);
+    }
+    runInitialSynth(root);
+    runPnpm(["install", "--no-frozen-lockfile", "--force"], 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.
+ */
+export function seedToolchain(root, projenSpecifier = defaultProjenSpecifier()) {
+    const manifestPath = join(root, "package.json");
+    if (!existsSync(manifestPath)) {
+        runPnpm(["init"], root);
+        normalizeSeedManifest(manifestPath);
+    }
+    const workspaceFile = join(root, "pnpm-workspace.yaml");
+    if (!existsSync(workspaceFile)) {
+        writeFileSync(workspaceFile, WORKSPACE_SEED);
+    }
+    runPnpm(["add", "-D", "projen", "typescript@^5.9.3", "tsx@^4.23.0", projenSpecifier], root);
+}
+/**
+ * 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.
+ */
+function normalizeSeedManifest(manifestPath) {
+    try {
+        const manifest = json.parseRecord(readFileSync(manifestPath, "utf8"));
+        if (!manifest)
+            return;
+        delete manifest.devEngines;
+        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.
+    }
+}
+/**
+ * Run the initial synth by executing `.projenrc.ts` directly with tsx (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) {
+    const [command, ...prefix] = resolvePnpmArgv();
+    exec.spawnSync(command, [...prefix, "exec", "tsx", ".projenrc.ts"], {
+        cwd: root,
+        env: { ...process.env, PROJEN_DISABLE_POST: "true" },
+        check: true,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bootstrap.js","sourceRoot":"","sources":["../../src/bootstrap.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Bootstrap a brand-new folder into a working dbx-tools workspace before projen runs.\n *\n * @module\n */\nimport { existsSync, readFileSync, writeFileSync } from \"node:fs\";\nimport { join } from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\nimport { intro, outro } from \"@clack/prompts\";\nimport { exec } from \"@dbx-tools/core\";\nimport { json } from \"@dbx-tools/shared-core\";\nimport { resolvePnpmArgv, runPnpm } from \"./pnpm\";\nimport { rootLabel } from \"./root\";\n\n/** Fallback when this CLI's own version isn't a real release (an in-repo `0.0.0`). */\nconst FALLBACK_PROJEN_SPECIFIER = \"@dbx-tools/projen@latest\";\n\n/**\n * Install the engine at THIS CLI's own version. The two are released together by\n * the root `bump`, so the matching engine always exists on the registry.\n *\n * Not `@latest`, and not a bare `@dbx-tools/projen`. A bare specifier can land on\n * a stray `0.0.0`, whose `^0.0.0` caret then reaches no real release. `@latest`\n * has a subtler failure: pnpm 11 applies a `minimumReleaseAge` delay, so for the\n * first day after a release it deliberately resolves a dist-tag to the newest\n * version OLDER than the threshold and merely notes the newer one\n * (`+ @dbx-tools/projen 0.1.24 (0.3.42 is available)`). A bootstrap run right\n * after a release therefore installed a months-old engine against a current CLI,\n * which is how `sync --watch` died on an engine predating its `concurrently`\n * dependency. An explicit range admits only the version we want, so the age\n * heuristic has nothing older to fall back to.\n */\nfunction defaultProjenSpecifier(): string {\n  const version = ownVersion();\n  return version ? `@dbx-tools/projen@^${version}` : FALLBACK_PROJEN_SPECIFIER;\n}\n\n/** This CLI's own released version, or `undefined` for an in-repo `0.0.0` build. */\nfunction ownVersion(): string | undefined {\n  try {\n    const manifestPath = fileURLToPath(new URL(\"../package.json\", import.meta.url));\n    const version = json.parseRecord(readFileSync(manifestPath, \"utf8\"))?.version;\n    return typeof version === \"string\" && version !== \"0.0.0\" ? version : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\n/** Compare `x.y.z` triples; returns <0, 0, or >0. Missing parts count as 0. */\nfunction compareVersions(a: string, b: string): number {\n  const parts = (v: string) => v.split(\".\").map((p) => Number.parseInt(p, 10) || 0);\n  const [x, y] = [parts(a), parts(b)];\n  return x[0] - y[0] || x[1] - y[1] || x[2] - y[2];\n}\n\n/** Version of the engine currently installed at `root`, if any. */\nfunction installedEngineVersion(root: string): string | undefined {\n  try {\n    const manifest = join(root, \"node_modules\", \"@dbx-tools\", \"projen\", \"package.json\");\n    const version = json.parseRecord(readFileSync(manifest, \"utf8\"))?.version;\n    return typeof version === \"string\" ? version : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Upgrade an established workspace whose installed engine predates this CLI.\n *\n * Bootstrapping pins the engine once, and nothing afterwards revisits it - so a\n * workspace created months ago kept resolving its original engine no matter how\n * current the CLI invoking it was, and failed inside the OLD engine's code\n * (`sync --watch` dying on a `concurrently` that engine never declared). The two\n * are released in lockstep, so this CLI's version is exactly the engine it\n * expects.\n *\n * Only ever moves FORWARD: an engine at or ahead of this CLI is left alone, so\n * an older CLI cannot downgrade a workspace.\n */\nexport function ensureEngineCurrent(root: string): void {\n  const expected = ownVersion();\n  if (!expected) return;\n  const installed = installedEngineVersion(root);\n  if (installed && compareVersions(installed, expected) >= 0) return;\n  runPnpm([\"add\", \"-D\", defaultProjenSpecifier()], root);\n}\n\n// Reach the class through its module NAMESPACE. Current engines also hoist it\n// flat, but every engine ever published exports the namespace, and this template\n// is resolved against `@latest` - a flat import dies on an older one with\n// \"does not provide an export named 'DBXToolsNodeProject'\".\nconst PROJENRC_TEMPLATE = `import { project as projectApi } from \"@dbx-tools/projen\";\n\nconst project = new projectApi.DBXToolsNodeProject();\nproject.synth();\n`;\n\n/** Seed `pnpm-workspace.yaml` so the first \\`pnpm add\\` can allow esbuild non-interactively. */\nconst WORKSPACE_SEED = `packages: []\nallowBuilds:\n  esbuild: true\n`;\n\n/**\n * Turn a folder into a functioning dbx-tools workspace: `pnpm init`, seed\n * `pnpm-workspace.yaml`, add `projen`/`typescript`/`tsx` + the engine package,\n * write a minimal `.projenrc.ts`, synth once (with `PROJEN_DISABLE_POST`), then\n * install. Does not run barrels - run `pnpm run barrels` or a full projen synth\n * post-install to generate package barrels.\n *\n * Every step is idempotent and self-guarded, so this is safe to run against a\n * folder that ALREADY has a hand-authored `.projenrc.ts` (and even a committed\n * `package.json`) but is missing the installed toolchain - e.g. a freshly copied\n * project whose generated files (including manifests) are gitignored. In that\n * case `pnpm init` and the `.projenrc.ts` scaffold are skipped, but the engine +\n * projen + tsx are (re)installed so the subsequent synth can regenerate\n * everything. See {@link seedToolchain}.\n */\nexport function bootstrapWorkspace(\n  root: string,\n  projenSpecifier: string = defaultProjenSpecifier(),\n): void {\n  intro(`Bootstrapping dbx-tools workspace in ${rootLabel(root)}`);\n\n  seedToolchain(root, projenSpecifier);\n\n  const projenrc = join(root, \".projenrc.ts\");\n  if (!existsSync(projenrc)) {\n    writeFileSync(projenrc, PROJENRC_TEMPLATE);\n  }\n\n  runInitialSynth(root);\n\n  runPnpm([\"install\", \"--no-frozen-lockfile\", \"--force\"], root);\n  outro(\"Workspace ready - re-run dbx-tools or add packages under packages/\");\n}\n\n/**\n * Install the toolchain a synth needs (`projen`, `typescript`, `tsx`, and the\n * dbx-tools engine), seeding a `package.json` and `pnpm-workspace.yaml` first\n * when absent. Idempotent: run it whenever the engine is missing, so a copied\n * project with a `.projenrc.ts` but no `node_modules`/manifests can be brought\n * up to a synth-ready state without full bootstrapping.\n */\nexport function seedToolchain(\n  root: string,\n  projenSpecifier: string = defaultProjenSpecifier(),\n): void {\n  const manifestPath = join(root, \"package.json\");\n  if (!existsSync(manifestPath)) {\n    runPnpm([\"init\"], root);\n    normalizeSeedManifest(manifestPath);\n  }\n\n  const workspaceFile = join(root, \"pnpm-workspace.yaml\");\n  if (!existsSync(workspaceFile)) {\n    writeFileSync(workspaceFile, WORKSPACE_SEED);\n  }\n\n  runPnpm([\"add\", \"-D\", \"projen\", \"typescript@^5.9.3\", \"tsx@^4.23.0\", projenSpecifier], root);\n}\n\n/**\n * Make what `pnpm init` produced safe to synth against. Two corrections, both\n * because that output varies by pnpm version:\n *\n *   - drop `devEngines`, which pnpm 11 seeds as `packageManager: { name: \"pnpm\",\n *     onFail: \"download\" }`. Any npm-based tool later in the chain (an\n *     `npx`/dlx fallback) then refuses with EBADDEVENGINES, its runner being npm;\n *   - force `type: \"module\"`, which pnpm 11 writes and pnpm 10 does not. tsx\n *     picks the entry's format from the nearest manifest, so without it\n *     `.projenrc.ts` loads as CJS and the first dependency using top-level await\n *     dies on \"not supported with the cjs output format\".\n *\n * projen regenerates the whole manifest at synth, so this only has to hold the\n * seed together long enough to get there.\n */\nfunction normalizeSeedManifest(manifestPath: string): void {\n  try {\n    const manifest = json.parseRecord(readFileSync(manifestPath, \"utf8\"));\n    if (!manifest) return;\n    delete manifest.devEngines;\n    manifest.type = \"module\";\n    writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\\n`);\n  } catch {\n    // A malformed/absent manifest here just means the later `pnpm add` recreates it.\n  }\n}\n\n/**\n * Run the initial synth by executing `.projenrc.ts` directly with tsx (with\n * `PROJEN_DISABLE_POST` set), NOT `projen <task>`. Use right after seeding a\n * fresh workspace: the projen TASKS (`sync`, `barrels`, ...) only exist once\n * `.projenrc.ts` has run once, so `projen sync` can't be the bootstrapping step.\n */\nexport function runInitialSynth(root: string): void {\n  const [command, ...prefix] = resolvePnpmArgv();\n  exec.spawnSync(command, [...prefix, \"exec\", \"tsx\", \".projenrc.ts\"], {\n    cwd: root,\n    env: { ...process.env, PROJEN_DISABLE_POST: \"true\" },\n    check: true,\n  });\n}\n"]}

package/lib/src/cli.d.ts

@@ -0,0 +1,2 @@
+/** Parse `argv` with commander and forward remaining args to projen. */
+export declare function runCli(argv: string[]): Promise<void>;

package/lib/src/cli.js

@@ -0,0 +1,52 @@
+/**
+ * `dbx-tools` commander entry: detect root, bootstrap or install, forward to projen.
+ *
+ * @module
+ */
+import { Command } from "commander";
+import { bootstrapWorkspace, ensureEngineCurrent, runInitialSynth, seedToolchain, } from "./bootstrap.js";
+import { ensureWorkspaceReady, runPnpm, runProjen } from "./pnpm.js";
+import { findWorkspaceRoot, needsBootstrap, needsToolchain } from "./root.js";
+/**
+ * Prepare the workspace at `root`, then run `pnpm exec projen` with `projenArgs`.
+ *
+ * Three cases, in order:
+ *   - no `.projenrc.ts` at all -> full bootstrap (scaffold + install + synth),
+ *     which already runs the initial synth; nothing more to forward.
+ *   - a `.projenrc.ts` but the engine/toolchain isn't installed (e.g. a freshly
+ *     copied project whose generated files + manifests are gitignored) -> seed
+ *     the toolchain, then run the INITIAL synth directly (the projen tasks the
+ *     args would name, like `sync`, don't exist until `.projenrc.ts` has run
+ *     once), and install. Don't forward `projenArgs` - the synth is the work.
+ *   - otherwise (established workspace) -> ensure deps, bring the engine up to
+ *     this CLI's version, then forward to projen.
+ */
+async function prepareAndRunProjen(projenArgs, startDir) {
+    const root = await findWorkspaceRoot(startDir);
+    if (needsBootstrap(root)) {
+        bootstrapWorkspace(root);
+        return;
+    }
+    if (needsToolchain(root)) {
+        seedToolchain(root);
+        runInitialSynth(root);
+        runPnpm(["install", "--no-frozen-lockfile", "--force"], root);
+        return;
+    }
+    ensureWorkspaceReady(root);
+    ensureEngineCurrent(root);
+    runProjen(projenArgs, root);
+}
+/** Parse `argv` with commander and forward remaining args to projen. */
+export async function runCli(argv) {
+    const program = new Command()
+        .name("dbx-tools")
+        .description("Bootstrap dbx-tools workspaces and forward to projen")
+        .allowUnknownOption()
+        .allowExcessArguments()
+        .showHelpAfterError()
+        .helpOption("-h, --help", "Show dbx-tools help");
+    program.parse(argv);
+    await prepareAndRunProjen(program.args);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/pnpm.d.ts

@@ -0,0 +1,8 @@
+/** 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`. */
+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;

package/lib/src/pnpm.js

@@ -0,0 +1,81 @@
+/**
+ * pnpm discovery, workspace install, and projen forwarding for the `dbx-tools` CLI.
+ *
+ * @module
+ */
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { exec } from "@dbx-tools/core";
+import { functionModule } from "@dbx-tools/shared-core";
+import { needsInstall } from "./root.js";
+/** True when `pnpm --version` runs, i.e. pnpm is already on PATH. */
+function pnpmOnPath() {
+    try {
+        exec.spawnSync("pnpm", ["--version"], {
+            stderr: "ignore",
+            stdin: "ignore",
+            stdout: "ignore",
+            check: true,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function resolvePnpmArgvImpl() {
+    // 1. A resolvable `pnpm` dependency (the normal in-workspace case): run its
+    //    bin directly with the current node - no PATH or package-manager shim.
+    try {
+        const require = createRequire(import.meta.url);
+        const pkgJsonPath = require.resolve("pnpm/package.json");
+        const pkg = require(pkgJsonPath);
+        const bin = typeof pkg.bin === "string" ? pkg.bin : pkg.bin.pnpm;
+        return [process.execPath, join(dirname(pkgJsonPath), bin)];
+    }
+    catch {
+        // fall through
+    }
+    // 2. A bare `pnpm` already on PATH (e.g. running under `pnpm dlx`). Prefer
+    //    this over the corepack/npx fallbacks so we never shell through npm -
+    //    `npx -y pnpm` runs under npm, which rejects a bootstrapped
+    //    `devEngines.packageManager: pnpm` manifest with EBADDEVENGINES.
+    if (pnpmOnPath())
+        return ["pnpm"];
+    // 3. Try to enable pnpm via corepack, then use it.
+    try {
+        exec.spawnSync("corepack", ["enable", "pnpm"], {
+            stderr: "ignore",
+            stdin: "ignore",
+            stdout: "ignore",
+            check: true,
+        });
+        if (pnpmOnPath())
+            return ["pnpm"];
+    }
+    catch {
+        // fall through
+    }
+    // 4. Last resort: fetch pnpm on demand via npx. Pass `--engine-strict=false`
+    //    (and skip npm's devEngines gate) so npm doesn't refuse to run just
+    //    because the target manifest declares `devEngines.packageManager: pnpm`.
+    return ["npx", "-y", "--engine-strict=false", "pnpm"];
+}
+/** Memoized `[command, ...prefix]` argv prefix to run pnpm (resolved install, else corepack, else npx). */
+export const resolvePnpmArgv = functionModule.memoize(resolvePnpmArgvImpl);
+/** Run pnpm with inherited stdio from `cwd`. */
+export function runPnpm(args, cwd) {
+    const [command, ...prefix] = resolvePnpmArgv();
+    exec.spawnSync(command, [...prefix, ...args], { cwd, check: true });
+}
+/** Install workspace dependencies when `node_modules` or projen is missing. */
+export function ensureWorkspaceReady(root) {
+    if (needsInstall(root)) {
+        runPnpm(["install", "--no-frozen-lockfile"], root);
+    }
+}
+/** Run `pnpm exec projen` with the given args from `root`. */
+export function runProjen(args, root) {
+    runPnpm(["exec", "projen", ...args], root);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/root.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Walk upward from `startDir` for `.projenrc.ts`. If none is found, try git
+ * top-level only when that directory also contains `.projenrc.ts`; otherwise return
+ * `resolve(startDir)` (which may not be a workspace root).
+ */
+export declare function findWorkspaceRoot(startDir?: string): Promise<string>;
+/**
+ * True when the folder has no `.projenrc.ts` yet and needs full bootstrapping.
+ * Keying off `.projenrc.ts` (not `package.json`) avoids clobbering a cleaned
+ * workspace that still has a hand-authored projenrc.
+ */
+export declare function needsBootstrap(root: string): boolean;
+/** True when `node_modules` or projen itself is missing under `root`. */
+export declare function needsInstall(root: string): boolean;
+/**
+ * True when the synth TOOLCHAIN isn't installed yet: no `node_modules`, or the
+ * dbx-tools engine / `projen` aren't resolvable under it. Distinct from a full
+ * bootstrap (which keys off a MISSING `.projenrc.ts`): here the projenrc exists
+ * but its dependencies don't - e.g. a copied project whose generated manifests
+ * and `node_modules` are gitignored. Seeding the toolchain (not scaffolding)
+ * makes it synth-ready without touching the hand-authored `.projenrc.ts`.
+ */
+export declare function needsToolchain(root: string): boolean;
+/** Async, memoized root lookup from the process cwd at first use. */
+export declare const workspaceRoot: () => Promise<string>;
+/** Short label for log output (`basename` of the resolved root). */
+export declare function rootLabel(root: string): string;

package/lib/src/root.js

@@ -0,0 +1,77 @@
+/**
+ * Workspace root detection for the `dbx-tools` CLI.
+ *
+ * @module
+ */
+import { existsSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { exec } from "@dbx-tools/core";
+import { functionModule } from "@dbx-tools/shared-core";
+async function gitToplevel() {
+    const { exitCode, stdout } = await exec.spawn("git", ["rev-parse", "--show-toplevel"], {
+        stdout: "capture",
+        stderr: "ignore",
+        stdin: "ignore",
+    });
+    if (exitCode !== 0)
+        return undefined;
+    return stdout || undefined;
+}
+/**
+ * Walk upward from `startDir` for `.projenrc.ts`. If none is found, try git
+ * top-level only when that directory also contains `.projenrc.ts`; otherwise return
+ * `resolve(startDir)` (which may not be a workspace root).
+ */
+export async function findWorkspaceRoot(startDir = process.cwd()) {
+    let dir = resolve(startDir);
+    while (true) {
+        if (existsSync(join(dir, ".projenrc.ts")))
+            return dir;
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    const fromGit = await gitToplevel();
+    if (fromGit && existsSync(join(fromGit, ".projenrc.ts")))
+        return fromGit;
+    return resolve(startDir);
+}
+/**
+ * True when the folder has no `.projenrc.ts` yet and needs full bootstrapping.
+ * Keying off `.projenrc.ts` (not `package.json`) avoids clobbering a cleaned
+ * workspace that still has a hand-authored projenrc.
+ */
+export function needsBootstrap(root) {
+    return !existsSync(join(root, ".projenrc.ts"));
+}
+/** True when `node_modules` or projen itself is missing under `root`. */
+export function needsInstall(root) {
+    if (!existsSync(join(root, "node_modules")))
+        return true;
+    if (existsSync(join(root, ".projenrc.ts")) && !existsSync(join(root, "node_modules", "projen"))) {
+        return true;
+    }
+    return false;
+}
+/**
+ * True when the synth TOOLCHAIN isn't installed yet: no `node_modules`, or the
+ * dbx-tools engine / `projen` aren't resolvable under it. Distinct from a full
+ * bootstrap (which keys off a MISSING `.projenrc.ts`): here the projenrc exists
+ * but its dependencies don't - e.g. a copied project whose generated manifests
+ * and `node_modules` are gitignored. Seeding the toolchain (not scaffolding)
+ * makes it synth-ready without touching the hand-authored `.projenrc.ts`.
+ */
+export function needsToolchain(root) {
+    const modules = join(root, "node_modules");
+    if (!existsSync(modules))
+        return true;
+    return !existsSync(join(modules, "projen")) || !existsSync(join(modules, "@dbx-tools", "projen"));
+}
+/** Async, memoized root lookup from the process cwd at first use. */
+export const workspaceRoot = functionModule.memoize(() => findWorkspaceRoot());
+/** Short label for log output (`basename` of the resolved root). */
+export function rootLabel(root) {
+    return basename(root) || root;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/bootstrap.ts","../src/cli.ts","../src/pnpm.ts","../src/root.ts","../index.ts","../bin/dbx-tools.ts"],"version":"5.9.3"}

package/package.json

@@ -18,29 +18,45 @@
     "commander": "^15.0.0",
     "pnpm": "^11.0.6",
     "tsx": "^4.23.0",
-    "@dbx-tools/shared-core": "0.3.43",
-    "@dbx-tools/core": "0.3.43"
+    "@dbx-tools/core": "0.4.0",
+    "@dbx-tools/shared-core": "0.4.0"
   },
-  "main": "index.ts",
+  "main": "./lib/index.js",
   "license": "UNLICENSED",
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.3.43",
-  "types": "index.ts",
+  "version": "0.4.0",
+  "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {
-    ".": "./index.ts",
-    "./bootstrap": "./src/bootstrap.ts",
-    "./cli": "./src/cli.ts",
-    "./pnpm": "./src/pnpm.ts",
-    "./root": "./src/root.ts",
+    ".": {
+      "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"
+    },
     "./package.json": "./package.json"
   },
   "files": [
     "index.ts",
     "src",
-    "bin"
+    "bin",
+    "lib"
   ],
   "dbxToolsConfig": {
     "tags": [

package/src/bootstrap.ts

@@ -31,17 +31,60 @@ const FALLBACK_PROJEN_SPECIFIER = "@dbx-tools/projen@latest";
  * heuristic has nothing older to fall back to.
  */
 function defaultProjenSpecifier(): string {
+  const version = ownVersion();
+  return version ? `@dbx-tools/projen@^${version}` : FALLBACK_PROJEN_SPECIFIER;
+}
+
+/** This CLI's own released version, or `undefined` for an in-repo `0.0.0` build. */
+function ownVersion(): string | undefined {
   try {
     const manifestPath = fileURLToPath(new URL("../package.json", import.meta.url));
     const version = json.parseRecord(readFileSync(manifestPath, "utf8"))?.version;
-    return typeof version === "string" && version !== "0.0.0"
-      ? `@dbx-tools/projen@^${version}`
-      : FALLBACK_PROJEN_SPECIFIER;
+    return typeof version === "string" && version !== "0.0.0" ? version : undefined;
   } catch {
-    return FALLBACK_PROJEN_SPECIFIER;
+    return undefined;
   }
 }
 
+/** Compare `x.y.z` triples; returns <0, 0, or >0. Missing parts count as 0. */
+function compareVersions(a: string, b: string): number {
+  const parts = (v: string) => v.split(".").map((p) => Number.parseInt(p, 10) || 0);
+  const [x, y] = [parts(a), parts(b)];
+  return x[0] - y[0] || x[1] - y[1] || x[2] - y[2];
+}
+
+/** Version of the engine currently installed at `root`, if any. */
+function installedEngineVersion(root: string): string | undefined {
+  try {
+    const manifest = join(root, "node_modules", "@dbx-tools", "projen", "package.json");
+    const version = json.parseRecord(readFileSync(manifest, "utf8"))?.version;
+    return typeof version === "string" ? version : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Upgrade an established workspace whose installed engine predates this CLI.
+ *
+ * Bootstrapping pins the engine once, and nothing afterwards revisits it - so a
+ * workspace created months ago kept resolving its original engine no matter how
+ * current the CLI invoking it was, and failed inside the OLD engine's code
+ * (`sync --watch` dying on a `concurrently` that engine never declared). The two
+ * are released in lockstep, so this CLI's version is exactly the engine it
+ * expects.
+ *
+ * Only ever moves FORWARD: an engine at or ahead of this CLI is left alone, so
+ * an older CLI cannot downgrade a workspace.
+ */
+export function ensureEngineCurrent(root: string): void {
+  const expected = ownVersion();
+  if (!expected) return;
+  const installed = installedEngineVersion(root);
+  if (installed && compareVersions(installed, expected) >= 0) return;
+  runPnpm(["add", "-D", defaultProjenSpecifier()], root);
+}
+
 // Reach the class through its module NAMESPACE. Current engines also hoist it
 // flat, but every engine ever published exports the namespace, and this template
 // is resolved against `@latest` - a flat import dies on an older one with

package/src/cli.ts

@@ -4,7 +4,12 @@
  * @module
  */
 import { Command } from "commander";
-import { bootstrapWorkspace, runInitialSynth, seedToolchain } from "./bootstrap";
+import {
+  bootstrapWorkspace,
+  ensureEngineCurrent,
+  runInitialSynth,
+  seedToolchain,
+} from "./bootstrap";
 import { ensureWorkspaceReady, runPnpm, runProjen } from "./pnpm";
 import { findWorkspaceRoot, needsBootstrap, needsToolchain } from "./root";
 
@@ -19,7 +24,8 @@ import { findWorkspaceRoot, needsBootstrap, needsToolchain } from "./root";
  *     the toolchain, then run the INITIAL synth directly (the projen tasks the
  *     args would name, like `sync`, don't exist until `.projenrc.ts` has run
  *     once), and install. Don't forward `projenArgs` - the synth is the work.
- *   - otherwise (established workspace) -> ensure deps, then forward to projen.
+ *   - otherwise (established workspace) -> ensure deps, bring the engine up to
+ *     this CLI's version, then forward to projen.
  */
 async function prepareAndRunProjen(projenArgs: string[], startDir?: string): Promise<void> {
   const root = await findWorkspaceRoot(startDir);
@@ -34,6 +40,7 @@ async function prepareAndRunProjen(projenArgs: string[], startDir?: string): Pro
     return;
   }
   ensureWorkspaceReady(root);
+  ensureEngineCurrent(root);
   runProjen(projenArgs, root);
 }