@dbx-tools/cli 0.3.42 → 0.3.44

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/package.json

@@ -18,15 +18,15 @@
     "commander": "^15.0.0",
     "pnpm": "^11.0.6",
     "tsx": "^4.23.0",
-    "@dbx-tools/shared-core": "0.3.42",
-    "@dbx-tools/core": "0.3.42"
+    "@dbx-tools/core": "0.3.44",
+    "@dbx-tools/shared-core": "0.3.44"
   },
   "main": "index.ts",
   "license": "UNLICENSED",
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.3.42",
+  "version": "0.3.44",
   "types": "index.ts",
   "type": "module",
   "exports": {

package/src/bootstrap.ts

@@ -5,16 +5,85 @@
  */
 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";
 import { rootLabel } from "./root";
 
-// Pin to `@latest` explicitly: a bare `@dbx-tools/projen` can land on a stray
-// `0.0.0` (whose `^0.0.0` caret then can't reach any real release), leaving the
-// workspace on a stale engine. `@latest` always takes the newest published.
-const DEFAULT_PROJEN_SPECIFIER = "@dbx-tools/projen@latest";
+/** 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(): 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" ? version : undefined;
+  } catch {
+    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
@@ -49,7 +118,7 @@ allowBuilds:
  */
 export function bootstrapWorkspace(
   root: string,
-  projenSpecifier: string = DEFAULT_PROJEN_SPECIFIER,
+  projenSpecifier: string = defaultProjenSpecifier(),
 ): void {
   intro(`Bootstrapping dbx-tools workspace in ${rootLabel(root)}`);
 
@@ -75,7 +144,7 @@ export function bootstrapWorkspace(
  */
 export function seedToolchain(
   root: string,
-  projenSpecifier: string = DEFAULT_PROJEN_SPECIFIER,
+  projenSpecifier: string = defaultProjenSpecifier(),
 ): void {
   const manifestPath = join(root, "package.json");
   if (!existsSync(manifestPath)) {

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);
 }