@dbx-tools/cli 0.6.15 → 0.6.34

package/lib/src/bootstrap.js

@@ -4,13 +4,16 @@
  * @module
  */
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
 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 { exec, project } from "@dbx-tools/core";
+import { json, log } from "@dbx-tools/shared-core";
+import { childEnv, resolvePnpmArgv, runPnpm } from "./pnpm.js";
 import { rootLabel } from "./root.js";
+const logger = log.logger("dbx-tools:bootstrap");
+/** Published package name used for Node's self-reference manifest resolution. */
+const CLI_PACKAGE = "@dbx-tools/cli";
 /** 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";
 /**
@@ -35,7 +38,12 @@ function defaultProjenSpecifier() {
 /** 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));
+        // Resolve through the package's exported `./package.json`, which works from
+        // both source (`src/bootstrap.ts`) and published output
+        // (`lib/src/bootstrap.js`). A relative URL is one level from the manifest
+        // in source but two levels away after compilation and silently fell back to
+        // `@latest` in every installed CLI.
+        const manifestPath = createRequire(import.meta.url).resolve(`${CLI_PACKAGE}/package.json`);
         const version = json.parseRecord(readFileSync(manifestPath, "utf8"))?.version;
         return typeof version === "string" && version !== "0.0.0" ? version : undefined;
     }
@@ -139,7 +147,50 @@ export function seedToolchain(root, projenSpecifier = defaultProjenSpecifier())
     if (!existsSync(workspaceFile)) {
         writeFileSync(workspaceFile, WORKSPACE_SEED);
     }
-    runPnpm(["add", "-D", "projen", "typescript@^5.9.3", "tsx@^4.23.0", projenSpecifier], root);
+    seedRegistry(root);
+    const kernelArch = exec.spawnSync("uname", ["-m"], {
+        stdin: "ignore",
+        stdout: "capture",
+        stderr: "ignore",
+    }).stdout;
+    logger.info("seeding toolchain", {
+        node: process.version,
+        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);
+}
+/**
+ * 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
+ * `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.
+ *
+ * Only writes for an actual override, never creates a file just to name npmjs,
+ * and never overwrites an existing `.npmrc` (the developer's own wins).
+ */
+function seedRegistry(root) {
+    const registry = project.npmRegistry(null, { overrideOnly: true, envVars: true })?.toString();
+    if (!registry)
+        return;
+    const npmrc = join(root, ".npmrc");
+    if (existsSync(npmrc))
+        return;
+    writeFileSync(npmrc, `registry=${registry}\n`);
 }
 /**
  * Make what `pnpm init` produced safe to synth against. Two corrections, both
@@ -177,10 +228,13 @@ function normalizeSeedManifest(manifestPath) {
  */
 export function runInitialSynth(root) {
     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"], {
         cwd: root,
-        env: { ...process.env, PROJEN_DISABLE_POST: "true" },
+        env: childEnv({ 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.ts\";\nimport { rootLabel } from \"./root.ts\";\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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bootstrap.js","sourceRoot":"","sources":["../../src/bootstrap.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAClE,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAEtC,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,qBAAqB,CAAC,CAAC;AAEjD,iFAAiF;AACjF,MAAM,WAAW,GAAG,gBAAgB,CAAC;AAErC,sFAAsF;AACtF,MAAM,yBAAyB,GAAG,0BAA0B,CAAC;AAE7D;;;;;;;;;;;;;;GAcG;AACH,SAAS,sBAAsB;IAC7B,MAAM,OAAO,GAAG,UAAU,EAAE,CAAC;IAC7B,OAAO,OAAO,CAAC,CAAC,CAAC,sBAAsB,OAAO,EAAE,CAAC,CAAC,CAAC,yBAAyB,CAAC;AAC/E,CAAC;AAED,oFAAoF;AACpF,SAAS,UAAU;IACjB,IAAI,CAAC;QACH,4EAA4E;QAC5E,wDAAwD;QACxD,0EAA0E;QAC1E,4EAA4E;QAC5E,oCAAoC;QACpC,MAAM,YAAY,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,GAAG,WAAW,eAAe,CAAC,CAAC;QAC3F,MAAM,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC,EAAE,OAAO,CAAC;QAC9E,OAAO,OAAO,OAAO,KAAK,QAAQ,IAAI,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC;IAClF,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAC;IACnB,CAAC;AACH,CAAC;AAED,+EAA+E;AAC/E,SAAS,eAAe,CAAC,CAAS,EAAE,CAAS;IAC3C,MAAM,KAAK,GAAG,CAAC,CAAS,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC;IAClF,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IACpC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AACnD,CAAC;AAED,mEAAmE;AACnE,SAAS,sBAAsB,CAAC,IAAY;IAC1C,IAAI,CAAC;QACH,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,EAAE,cAAc,EAAE,YAAY,EAAE,QAAQ,EAAE,cAAc,CAAC,CAAC;QACpF,MAAM,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,EAAE,OAAO,CAAC;QAC1E,OAAO,OAAO,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC;IAC3D,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAC;IACnB,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,mBAAmB,CAAC,IAAY;IAC9C,MAAM,QAAQ,GAAG,UAAU,EAAE,CAAC;IAC9B,IAAI,CAAC,QAAQ;QAAE,OAAO;IACtB,MAAM,SAAS,GAAG,sBAAsB,CAAC,IAAI,CAAC,CAAC;IAC/C,IAAI,SAAS,IAAI,eAAe,CAAC,SAAS,EAAE,QAAQ,CAAC,IAAI,CAAC;QAAE,OAAO;IACnE,OAAO,CAAC,CAAC,KAAK,EAAE,IAAI,EAAE,sBAAsB,EAAE,CAAC,EAAE,IAAI,CAAC,CAAC;AACzD,CAAC;AAED,8EAA8E;AAC9E,iFAAiF;AACjF,0EAA0E;AAC1E,4DAA4D;AAC5D,MAAM,iBAAiB,GAAG;;;;CAIzB,CAAC;AAEF,gGAAgG;AAChG,MAAM,cAAc,GAAG;;;CAGtB,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,kBAAkB,CAChC,IAAY,EACZ,kBAA0B,sBAAsB,EAAE;IAElD,KAAK,CAAC,wCAAwC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAEjE,aAAa,CAAC,IAAI,EAAE,eAAe,CAAC,CAAC;IAErC,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC;IAC5C,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC1B,aAAa,CAAC,QAAQ,EAAE,iBAAiB,CAAC,CAAC;IAC7C,CAAC;IAED,eAAe,CAAC,IAAI,CAAC,CAAC;IAEtB,OAAO,CAAC,CAAC,SAAS,EAAE,sBAAsB,EAAE,SAAS,CAAC,EAAE,IAAI,CAAC,CAAC;IAC9D,KAAK,CAAC,oEAAoE,CAAC,CAAC;AAC9E,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAC3B,IAAY,EACZ,kBAA0B,sBAAsB,EAAE;IAElD,MAAM,YAAY,GAAG,IAAI,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC;IAChD,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC,EAAE,CAAC;QAC9B,OAAO,CAAC,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,CAAC;QACxB,qBAAqB,CAAC,YAAY,CAAC,CAAC;IACtC,CAAC;IAED,MAAM,aAAa,GAAG,IAAI,CAAC,IAAI,EAAE,qBAAqB,CAAC,CAAC;IACxD,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,EAAE,CAAC;QAC/B,aAAa,CAAC,aAAa,EAAE,cAAc,CAAC,CAAC;IAC/C,CAAC;IAED,YAAY,CAAC,IAAI,CAAC,CAAC;IAEnB,MAAM,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,EAAE;QACjD,KAAK,EAAE,QAAQ;QACf,MAAM,EAAE,SAAS;QACjB,MAAM,EAAE,QAAQ;KACjB,CAAC,CAAC,MAAM,CAAC;IACV,MAAM,CAAC,IAAI,CAAC,mBAAmB,EAAE;QAC/B,IAAI,EAAE,OAAO,CAAC,OAAO;QACrB,QAAQ,EAAE,OAAO,CAAC,QAAQ;QAC1B,IAAI,EAAE,OAAO,CAAC,IAAI;QAClB,UAAU,EAAE,UAAU,IAAI,SAAS;QACnC,MAAM,EAAE,eAAe;KACxB,CAAC,CAAC;IACH,OAAO,CACL;QACE,KAAK;QACL,wBAAwB;QACxB,IAAI;QACJ,QAAQ;QACR,mBAAmB;QACnB,aAAa;QACb,eAAe;KAChB,EACD,IAAI,CACL,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAS,YAAY,CAAC,IAAY;IAChC,MAAM,QAAQ,GAAG,OAAO,CAAC,WAAW,CAAC,IAAI,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC;IAC9F,IAAI,CAAC,QAAQ;QAAE,OAAO;IACtB,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;IACnC,IAAI,UAAU,CAAC,KAAK,CAAC;QAAE,OAAO;IAC9B,aAAa,CAAC,KAAK,EAAE,YAAY,QAAQ,IAAI,CAAC,CAAC;AACjD,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAS,qBAAqB,CAAC,YAAoB;IACjD,IAAI,CAAC;QACH,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC,CAAC;QACtE,IAAI,CAAC,QAAQ;YAAE,OAAO;QACtB,OAAO,QAAQ,CAAC,UAAU,CAAC;QAC3B,QAAQ,CAAC,IAAI,GAAG,QAAQ,CAAC;QACzB,aAAa,CAAC,YAAY,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC;IACxE,CAAC;IAAC,MAAM,CAAC;QACP,iFAAiF;IACnF,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,eAAe,CAAC,IAAY;IAC1C,MAAM,CAAC,OAAO,EAAE,GAAG,MAAM,CAAC,GAAG,eAAe,EAAE,CAAC;IAC/C,gFAAgF;IAChF,8EAA8E;IAC9E,oBAAoB;IACpB,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC,GAAG,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,cAAc,CAAC,EAAE;QAClE,GAAG,EAAE,IAAI;QACT,GAAG,EAAE,QAAQ,CAAC,EAAE,mBAAmB,EAAE,MAAM,EAAE,CAAC;QAC9C,KAAK,EAAE,IAAI;KACZ,CAAC,CAAC;AACL,CAAC","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 { createRequire } from \"node:module\";\nimport { join } from \"node:path\";\nimport { intro, outro } from \"@clack/prompts\";\nimport { exec, project } from \"@dbx-tools/core\";\nimport { json, log } from \"@dbx-tools/shared-core\";\nimport { childEnv, resolvePnpmArgv, runPnpm } from \"./pnpm.ts\";\nimport { rootLabel } from \"./root.ts\";\n\nconst logger = log.logger(\"dbx-tools:bootstrap\");\n\n/** Published package name used for Node's self-reference manifest resolution. */\nconst CLI_PACKAGE = \"@dbx-tools/cli\";\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    // Resolve through the package's exported `./package.json`, which works from\n    // both source (`src/bootstrap.ts`) and published output\n    // (`lib/src/bootstrap.js`). A relative URL is one level from the manifest\n    // in source but two levels away after compilation and silently fell back to\n    // `@latest` in every installed CLI.\n    const manifestPath = createRequire(import.meta.url).resolve(`${CLI_PACKAGE}/package.json`);\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  seedRegistry(root);\n\n  const kernelArch = exec.spawnSync(\"uname\", [\"-m\"], {\n    stdin: \"ignore\",\n    stdout: \"capture\",\n    stderr: \"ignore\",\n  }).stdout;\n  logger.info(\"seeding toolchain\", {\n    node: process.version,\n    platform: process.platform,\n    arch: process.arch,\n    kernelArch: kernelArch || \"unknown\",\n    engine: projenSpecifier,\n  });\n  runPnpm(\n    [\n      \"add\",\n      \"--reporter=append-only\",\n      \"-D\",\n      \"projen\",\n      \"typescript@^5.9.3\",\n      \"tsx@^4.23.0\",\n      projenSpecifier,\n    ],\n    root,\n  );\n}\n\n/**\n * Pin a non-default registry into the new root's `.npmrc`.\n *\n * The CLI already forces `--registry` onto the pnpm invocations it makes itself,\n * but a bootstrapped workspace outlives this process: every later `pnpm install`\n * the developer (or projen's post-synth step) runs is on its own. pnpm ignores\n * `npm_config_registry` from the environment, so without a file on disk those\n * runs revert to `https://registry.npmjs.org/` - which is a hard failure where\n * the custom registry was the only reachable one.\n *\n * Only writes for an actual override, never creates a file just to name npmjs,\n * and never overwrites an existing `.npmrc` (the developer's own wins).\n */\nfunction seedRegistry(root: string): void {\n  const registry = project.npmRegistry(null, { overrideOnly: true, envVars: true })?.toString();\n  if (!registry) return;\n  const npmrc = join(root, \".npmrc\");\n  if (existsSync(npmrc)) return;\n  writeFileSync(npmrc, `registry=${registry}\\n`);\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  // No `--registry` here: this is `pnpm exec`, whose trailing arguments belong to\n  // tsx. The registry reaches anything nested through `childEnv` and the seeded\n  // `.npmrc` instead.\n  exec.spawnSync(command, [...prefix, \"exec\", \"tsx\", \".projenrc.ts\"], {\n    cwd: root,\n    env: childEnv({ PROJEN_DISABLE_POST: \"true\" }),\n    check: true,\n  });\n}\n"]}

package/lib/src/pnpm.d.ts

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

package/lib/src/pnpm.js

@@ -1,13 +1,110 @@
 /**
  * pnpm discovery, workspace install, and projen forwarding for the `dbx-tools` CLI.
  *
+ * ## Forcing a custom registry
+ *
+ * pnpm and npm do NOT agree on how a registry is configured, and getting this
+ * wrong is silent. Measured against pnpm 11.0.6 and npm 11:
+ *
+ * | mechanism                                | npm | pnpm |
+ * | ---------------------------------------- | --- | ---- |
+ * | `--registry <url>` CLI flag              | yes | yes  |
+ * | project `.npmrc`                         | yes | yes  |
+ * | `npm_config_registry` env var            | yes | NO   |
+ *
+ * So an env var alone reads back correctly from `npm config get registry` while
+ * pnpm ignores it and silently falls through to its built-in
+ * `https://registry.npmjs.org/`. That produced a bootstrap which logged the
+ * local registry and then tried to fetch `typescript` / `projen` / `tsx` from
+ * npmjs, failing with ECONNREFUSED on a machine that had no route to it.
+ *
+ * Hence all three channels, each where it actually applies:
+ *
+ *  - {@link pnpmRegistryArgs} passes `--registry` to pnpm, but only for the
+ *    subcommands that resolve packages. It must NOT be appended to
+ *    `pnpm exec <cmd>`, where trailing arguments belong to `<cmd>`, not pnpm.
+ *  - {@link npxRegistryArgs} passes `--registry` to npx, before the package
+ *    name, so the npx fallback can fetch pnpm itself from the same registry.
+ *  - {@link childEnv} keeps `npm_config_registry` set for npm-based children
+ *    (npx included), which is the only channel npm exposes to nested tools.
+ *
+ * `@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 { createRequire } from "node:module";
-import { dirname, join } from "node:path";
-import { exec } from "@dbx-tools/core";
-import { functionModule } from "@dbx-tools/shared-core";
+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.js";
+const logger = log.logger("dbx-tools:pnpm");
+/**
+ * pnpm subcommands that resolve packages from a registry, and therefore accept a
+ * meaningful `--registry`. Everything else (`exec`, `run`, `config`, ...) is left
+ * alone: `exec` in particular forwards trailing arguments to the command it runs,
+ * so a `--registry` appended there would land on projen or tsx instead.
+ */
+const REGISTRY_SUBCOMMANDS = new Set([
+    "add",
+    "create",
+    "dlx",
+    "i",
+    "import",
+    "install",
+    "link",
+    "up",
+    "update",
+]);
+/**
+ * The registry to force onto child package managers, 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 `npm config get` to read.
+ * Memoized: resolution shells out to npm.
+ */
+const registryOverride = functionModule.memoize(() => project.npmRegistry(null, { overrideOnly: true, envVars: true })?.toString());
+/** `--registry <url>` for npx, or `[]`. Placed BEFORE the package name by callers. */
+export function npxRegistryArgs() {
+    const url = registryOverride();
+    return url ? ["--registrsy", url] : [];
+}
+/** `--registry <url>` for a pnpm invocation, or `[]` when the subcommand does not resolve. */
+export function pnpmRegistryArgs(args) {
+    const url = registryOverride();
+    if (!url)
+        return [];
+    return pnpmUsesRegistry(args) ? ["--registry", url] : [];
+}
+/** Whether the first pnpm subcommand resolves packages and accepts `--registry`. */
+export function pnpmUsesRegistry(args) {
+    const subcommand = args.find((arg) => !arg.startsWith("-"));
+    return subcommand !== undefined && REGISTRY_SUBCOMMANDS.has(subcommand);
+}
+/**
+ * `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 function childEnv(extra) {
+    const env = { ...process.env, ...extra };
+    const nodeBin = dirname(process.execPath);
+    const pathEntries = (env.PATH ?? "").split(delimiter).filter(Boolean);
+    if (!pathEntries.includes(nodeBin)) {
+        env.PATH = [nodeBin, ...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;
+}
 /** True when `pnpm --version` runs, i.e. pnpm is already on PATH. */
 function pnpmOnPath() {
     try {
@@ -26,12 +123,14 @@ function pnpmOnPath() {
 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.
+    //    pnpm's own `--registry` rides in with the ARGS, after this entry point.
     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)];
+        if (bin)
+            return [process.execPath, join(dirname(pkgJsonPath), bin)];
     }
     catch {
         // fall through
@@ -59,14 +158,24 @@ function resolvePnpmArgvImpl() {
     // 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"];
+    //    npm-level flags, `--registry` among them, must precede the package name,
+    //    or npx forwards them to pnpm instead of acting on them itself.
+    return ["npx", ...npxRegistryArgs(), "-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`. */
+/** Run pnpm with inherited stdio from `cwd`, forcing the resolved registry. */
 export function runPnpm(args, cwd) {
     const [command, ...prefix] = resolvePnpmArgv();
-    exec.spawnSync(command, [...prefix, ...args], { cwd, check: true });
+    const registryArgs = pnpmRegistryArgs(args);
+    if (registryArgs.length > 0) {
+        logger.info(`running pnpm 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) {
@@ -78,4 +187,4 @@ export function ensureWorkspaceReady(root) {
 export function runProjen(args, root) {
     runPnpm(["exec", "projen", ...args], root);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pnpm.js","sourceRoot":"","sources":["../../src/pnpm.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * pnpm discovery, workspace install, and projen forwarding for the `dbx-tools` CLI.\n *\n * ## Forcing a custom registry\n *\n * pnpm and npm do NOT agree on how a registry is configured, and getting this\n * wrong is silent. Measured against pnpm 11.0.6 and npm 11:\n *\n * | mechanism                                | npm | pnpm |\n * | ---------------------------------------- | --- | ---- |\n * | `--registry <url>` CLI flag              | yes | yes  |\n * | project `.npmrc`                         | yes | yes  |\n * | `npm_config_registry` env var            | yes | NO   |\n *\n * So an env var alone reads back correctly from `npm config get registry` while\n * pnpm ignores it and silently falls through to its built-in\n * `https://registry.npmjs.org/`. That produced a bootstrap which logged the\n * local registry and then tried to fetch `typescript` / `projen` / `tsx` from\n * npmjs, failing with ECONNREFUSED on a machine that had no route to it.\n *\n * Hence all three channels, each where it actually applies:\n *\n *  - {@link pnpmRegistryArgs} passes `--registry` to pnpm, but only for the\n *    subcommands that resolve packages. It must NOT be appended to\n *    `pnpm exec <cmd>`, where trailing arguments belong to `<cmd>`, not pnpm.\n *  - {@link npxRegistryArgs} passes `--registry` to npx, before the package\n *    name, so the npx fallback can fetch pnpm itself from the same registry.\n *  - {@link childEnv} keeps `npm_config_registry` set for npm-based children\n *    (npx included), which is the only channel npm exposes to nested tools.\n *\n * `@dbx-tools/core`'s `npmRegistry({ overrideOnly: true })` returns nothing when\n * the effective registry IS npmjs, so none of this touches a default install.\n *\n * @module\n */\nimport { createRequire } from \"node:module\";\nimport { delimiter, dirname, join } from \"node:path\";\nimport { exec, project } from \"@dbx-tools/core\";\nimport { functionModule, log } from \"@dbx-tools/shared-core\";\nimport { needsInstall } from \"./root.ts\";\n\nconst logger = log.logger(\"dbx-tools:pnpm\");\n\n/** A package.json `bin` field: either a single command string, or a name -> path map. */\ntype BinField = string | Record<string, string>;\n\n/**\n * pnpm subcommands that resolve packages from a registry, and therefore accept a\n * meaningful `--registry`. Everything else (`exec`, `run`, `config`, ...) is left\n * alone: `exec` in particular forwards trailing arguments to the command it runs,\n * so a `--registry` appended there would land on projen or tsx instead.\n */\nconst REGISTRY_SUBCOMMANDS = new Set([\n  \"add\",\n  \"create\",\n  \"dlx\",\n  \"i\",\n  \"import\",\n  \"install\",\n  \"link\",\n  \"up\",\n  \"update\",\n]);\n\n/**\n * The registry to force onto child package managers, or `undefined` when the\n * effective one is already the public default.\n *\n * `envVars: true` also consults `npm_config_registry` directly, because a\n * container may export it without any `.npmrc` for `npm config get` to read.\n * Memoized: resolution shells out to npm.\n */\nconst registryOverride = functionModule.memoize((): string | undefined =>\n  project.npmRegistry(null, { overrideOnly: true, envVars: true })?.toString(),\n);\n\n/** `--registry <url>` for npx, or `[]`. Placed BEFORE the package name by callers. */\nexport function npxRegistryArgs(): string[] {\n  const url = registryOverride();\n  return url ? [\"--registrsy\", url] : [];\n}\n\n/** `--registry <url>` for a pnpm invocation, or `[]` when the subcommand does not resolve. */\nexport function pnpmRegistryArgs(args: readonly string[]): string[] {\n  const url = registryOverride();\n  if (!url) return [];\n  return pnpmUsesRegistry(args) ? [\"--registry\", url] : [];\n}\n\n/** Whether the first pnpm subcommand resolves packages and accepts `--registry`. */\nexport function pnpmUsesRegistry(args: readonly string[]): boolean {\n  const subcommand = args.find((arg) => !arg.startsWith(\"-\"));\n  return subcommand !== undefined && REGISTRY_SUBCOMMANDS.has(subcommand);\n}\n\n/**\n * `process.env` plus the current Node executable directory and registry aliases.\n *\n * The executable directory matters when this CLI was launched by absolute path\n * (for example from QuickJS or mise activation that was not exported): pnpm\n * itself runs, but lifecycle scripts invoke `node` by name and otherwise fail\n * with `sh: node: not found`.\n */\nexport function childEnv(extra?: Record<string, string>): NodeJS.ProcessEnv {\n  const env: NodeJS.ProcessEnv = { ...process.env, ...extra };\n  const nodeBin = dirname(process.execPath);\n  const pathEntries = (env.PATH ?? \"\").split(delimiter).filter(Boolean);\n  if (!pathEntries.includes(nodeBin)) {\n    env.PATH = [nodeBin, ...pathEntries].join(delimiter);\n  }\n  const url = registryOverride();\n  if (url) {\n    // Both cases: env is case-sensitive on POSIX, and npm lowercases when reading.\n    env.npm_config_registry = url;\n    env.NPM_CONFIG_REGISTRY = url;\n  }\n  return env;\n}\n\n/** True when `pnpm --version` runs, i.e. pnpm is already on PATH. */\nfunction pnpmOnPath(): boolean {\n  try {\n    exec.spawnSync(\"pnpm\", [\"--version\"], {\n      stderr: \"ignore\",\n      stdin: \"ignore\",\n      stdout: \"ignore\",\n      check: true,\n    });\n    return true;\n  } catch {\n    return false;\n  }\n}\n\nfunction resolvePnpmArgvImpl(): string[] {\n  // 1. A resolvable `pnpm` dependency (the normal in-workspace case): run its\n  //    bin directly with the current node - no PATH or package-manager shim.\n  //    pnpm's own `--registry` rides in with the ARGS, after this entry point.\n  try {\n    const require = createRequire(import.meta.url);\n    const pkgJsonPath = require.resolve(\"pnpm/package.json\");\n    const pkg = require(pkgJsonPath) as { bin: BinField };\n    const bin = typeof pkg.bin === \"string\" ? pkg.bin : pkg.bin.pnpm;\n    if (bin) return [process.execPath, join(dirname(pkgJsonPath), bin)];\n  } catch {\n    // fall through\n  }\n\n  // 2. A bare `pnpm` already on PATH (e.g. running under `pnpm dlx`). Prefer\n  //    this over the corepack/npx fallbacks so we never shell through npm -\n  //    `npx -y pnpm` runs under npm, which rejects a bootstrapped\n  //    `devEngines.packageManager: pnpm` manifest with EBADDEVENGINES.\n  if (pnpmOnPath()) return [\"pnpm\"];\n\n  // 3. Try to enable pnpm via corepack, then use it.\n  try {\n    exec.spawnSync(\"corepack\", [\"enable\", \"pnpm\"], {\n      stderr: \"ignore\",\n      stdin: \"ignore\",\n      stdout: \"ignore\",\n      check: true,\n    });\n    if (pnpmOnPath()) return [\"pnpm\"];\n  } catch {\n    // fall through\n  }\n\n  // 4. Last resort: fetch pnpm on demand via npx. Pass `--engine-strict=false`\n  //    (and skip npm's devEngines gate) so npm doesn't refuse to run just\n  //    because the target manifest declares `devEngines.packageManager: pnpm`.\n  //    npm-level flags, `--registry` among them, must precede the package name,\n  //    or npx forwards them to pnpm instead of acting on them itself.\n  return [\"npx\", ...npxRegistryArgs(), \"-y\", \"--engine-strict=false\", \"pnpm\"];\n}\n\n/** Memoized `[command, ...prefix]` argv prefix to run pnpm (resolved install, else corepack, else npx). */\nexport const resolvePnpmArgv = functionModule.memoize(resolvePnpmArgvImpl);\n\n/** Run pnpm with inherited stdio from `cwd`, forcing the resolved registry. */\nexport function runPnpm(args: string[], cwd: string): void {\n  const [command, ...prefix] = resolvePnpmArgv();\n  const registryArgs = pnpmRegistryArgs(args);\n  if (registryArgs.length > 0) {\n    logger.info(`running pnpm with registry: ${registryArgs[1]}`);\n  }\n  exec.spawnSync(command, [...prefix, ...args, ...registryArgs], {\n    cwd,\n    check: true,\n    env: childEnv(),\n  });\n}\n\n/** Install workspace dependencies when `node_modules` or projen is missing. */\nexport function ensureWorkspaceReady(root: string): void {\n  if (needsInstall(root)) {\n    runPnpm([\"install\", \"--no-frozen-lockfile\"], root);\n  }\n}\n\n/** Run `pnpm exec projen` with the given args from `root`. */\nexport function runProjen(args: string[], root: string): void {\n  runPnpm([\"exec\", \"projen\", ...args], root);\n}\n"]}

package/package.json

@@ -18,15 +18,15 @@
     "@clack/prompts": "^1.7.0",
     "commander": "^15.0.0",
     "pnpm": "^11.0.6",
-    "@dbx-tools/core": "0.6.15",
-    "@dbx-tools/shared-core": "0.6.15"
+    "@dbx-tools/core": "0.6.34",
+    "@dbx-tools/shared-core": "0.6.34"
   },
   "main": "./lib/index.js",
   "license": "UNLICENSED",
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.6.15",
+  "version": "0.6.34",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {

package/src/bootstrap.ts

@@ -4,14 +4,19 @@
  * @module
  */
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
 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.ts";
+import { exec, project } from "@dbx-tools/core";
+import { json, log } from "@dbx-tools/shared-core";
+import { childEnv, resolvePnpmArgv, runPnpm } from "./pnpm.ts";
 import { rootLabel } from "./root.ts";
 
+const logger = log.logger("dbx-tools:bootstrap");
+
+/** Published package name used for Node's self-reference manifest resolution. */
+const CLI_PACKAGE = "@dbx-tools/cli";
+
 /** 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";
 
@@ -38,7 +43,12 @@ function defaultProjenSpecifier(): string {
 /** 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));
+    // Resolve through the package's exported `./package.json`, which works from
+    // both source (`src/bootstrap.ts`) and published output
+    // (`lib/src/bootstrap.js`). A relative URL is one level from the manifest
+    // in source but two levels away after compilation and silently fell back to
+    // `@latest` in every installed CLI.
+    const manifestPath = createRequire(import.meta.url).resolve(`${CLI_PACKAGE}/package.json`);
     const version = json.parseRecord(readFileSync(manifestPath, "utf8"))?.version;
     return typeof version === "string" && version !== "0.0.0" ? version : undefined;
   } catch {
@@ -157,7 +167,53 @@ export function seedToolchain(
     writeFileSync(workspaceFile, WORKSPACE_SEED);
   }
 
-  runPnpm(["add", "-D", "projen", "typescript@^5.9.3", "tsx@^4.23.0", projenSpecifier], root);
+  seedRegistry(root);
+
+  const kernelArch = exec.spawnSync("uname", ["-m"], {
+    stdin: "ignore",
+    stdout: "capture",
+    stderr: "ignore",
+  }).stdout;
+  logger.info("seeding toolchain", {
+    node: process.version,
+    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,
+  );
+}
+
+/**
+ * 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
+ * `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.
+ *
+ * Only writes for an actual override, never creates a file just to name npmjs,
+ * and never overwrites an existing `.npmrc` (the developer's own wins).
+ */
+function seedRegistry(root: string): void {
+  const registry = project.npmRegistry(null, { overrideOnly: true, envVars: true })?.toString();
+  if (!registry) return;
+  const npmrc = join(root, ".npmrc");
+  if (existsSync(npmrc)) return;
+  writeFileSync(npmrc, `registry=${registry}\n`);
 }
 
 /**
@@ -195,9 +251,12 @@ function normalizeSeedManifest(manifestPath: string): void {
  */
 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"], {
     cwd: root,
-    env: { ...process.env, PROJEN_DISABLE_POST: "true" },
+    env: childEnv({ PROJEN_DISABLE_POST: "true" }),
     check: true,
   });
 }

package/src/pnpm.ts

@@ -1,17 +1,122 @@
 /**
  * pnpm discovery, workspace install, and projen forwarding for the `dbx-tools` CLI.
  *
+ * ## Forcing a custom registry
+ *
+ * pnpm and npm do NOT agree on how a registry is configured, and getting this
+ * wrong is silent. Measured against pnpm 11.0.6 and npm 11:
+ *
+ * | mechanism                                | npm | pnpm |
+ * | ---------------------------------------- | --- | ---- |
+ * | `--registry <url>` CLI flag              | yes | yes  |
+ * | project `.npmrc`                         | yes | yes  |
+ * | `npm_config_registry` env var            | yes | NO   |
+ *
+ * So an env var alone reads back correctly from `npm config get registry` while
+ * pnpm ignores it and silently falls through to its built-in
+ * `https://registry.npmjs.org/`. That produced a bootstrap which logged the
+ * local registry and then tried to fetch `typescript` / `projen` / `tsx` from
+ * npmjs, failing with ECONNREFUSED on a machine that had no route to it.
+ *
+ * Hence all three channels, each where it actually applies:
+ *
+ *  - {@link pnpmRegistryArgs} passes `--registry` to pnpm, but only for the
+ *    subcommands that resolve packages. It must NOT be appended to
+ *    `pnpm exec <cmd>`, where trailing arguments belong to `<cmd>`, not pnpm.
+ *  - {@link npxRegistryArgs} passes `--registry` to npx, before the package
+ *    name, so the npx fallback can fetch pnpm itself from the same registry.
+ *  - {@link childEnv} keeps `npm_config_registry` set for npm-based children
+ *    (npx included), which is the only channel npm exposes to nested tools.
+ *
+ * `@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 { createRequire } from "node:module";
-import { dirname, join } from "node:path";
-import { exec } from "@dbx-tools/core";
-import { functionModule } from "@dbx-tools/shared-core";
+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:pnpm");
+
 /** A package.json `bin` field: either a single command string, or a name -> path map. */
 type BinField = string | Record<string, string>;
 
+/**
+ * pnpm subcommands that resolve packages from a registry, and therefore accept a
+ * meaningful `--registry`. Everything else (`exec`, `run`, `config`, ...) is left
+ * alone: `exec` in particular forwards trailing arguments to the command it runs,
+ * so a `--registry` appended there would land on projen or tsx instead.
+ */
+const REGISTRY_SUBCOMMANDS = new Set([
+  "add",
+  "create",
+  "dlx",
+  "i",
+  "import",
+  "install",
+  "link",
+  "up",
+  "update",
+]);
+
+/**
+ * The registry to force onto child package managers, 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 `npm config get` to read.
+ * Memoized: resolution shells out to npm.
+ */
+const registryOverride = functionModule.memoize((): string | undefined =>
+  project.npmRegistry(null, { overrideOnly: true, envVars: true })?.toString(),
+);
+
+/** `--registry <url>` for npx, or `[]`. Placed BEFORE the package name by callers. */
+export function npxRegistryArgs(): string[] {
+  const url = registryOverride();
+  return url ? ["--registrsy", url] : [];
+}
+
+/** `--registry <url>` for a pnpm invocation, or `[]` when the subcommand does not resolve. */
+export function pnpmRegistryArgs(args: readonly string[]): string[] {
+  const url = registryOverride();
+  if (!url) return [];
+  return pnpmUsesRegistry(args) ? ["--registry", url] : [];
+}
+
+/** Whether the first pnpm subcommand resolves packages and accepts `--registry`. */
+export function pnpmUsesRegistry(args: readonly string[]): boolean {
+  const subcommand = args.find((arg) => !arg.startsWith("-"));
+  return subcommand !== undefined && REGISTRY_SUBCOMMANDS.has(subcommand);
+}
+
+/**
+ * `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 function childEnv(extra?: Record<string, string>): NodeJS.ProcessEnv {
+  const env: NodeJS.ProcessEnv = { ...process.env, ...extra };
+  const nodeBin = dirname(process.execPath);
+  const pathEntries = (env.PATH ?? "").split(delimiter).filter(Boolean);
+  if (!pathEntries.includes(nodeBin)) {
+    env.PATH = [nodeBin, ...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;
+}
+
 /** True when `pnpm --version` runs, i.e. pnpm is already on PATH. */
 function pnpmOnPath(): boolean {
   try {
@@ -30,12 +135,13 @@ function pnpmOnPath(): boolean {
 function resolvePnpmArgvImpl(): string[] {
   // 1. A resolvable `pnpm` dependency (the normal in-workspace case): run its
   //    bin directly with the current node - no PATH or package-manager shim.
+  //    pnpm's own `--registry` rides in with the ARGS, after this entry point.
   try {
     const require = createRequire(import.meta.url);
     const pkgJsonPath = require.resolve("pnpm/package.json");
     const pkg = require(pkgJsonPath) as { bin: BinField };
     const bin = typeof pkg.bin === "string" ? pkg.bin : pkg.bin.pnpm;
-    return [process.execPath, join(dirname(pkgJsonPath), bin)];
+    if (bin) return [process.execPath, join(dirname(pkgJsonPath), bin)];
   } catch {
     // fall through
   }
@@ -62,16 +168,26 @@ function resolvePnpmArgvImpl(): string[] {
   // 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"];
+  //    npm-level flags, `--registry` among them, must precede the package name,
+  //    or npx forwards them to pnpm instead of acting on them itself.
+  return ["npx", ...npxRegistryArgs(), "-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`. */
+/** Run pnpm with inherited stdio from `cwd`, forcing the resolved registry. */
 export function runPnpm(args: string[], cwd: string): void {
   const [command, ...prefix] = resolvePnpmArgv();
-  exec.spawnSync(command, [...prefix, ...args], { cwd, check: true });
+  const registryArgs = pnpmRegistryArgs(args);
+  if (registryArgs.length > 0) {
+    logger.info(`running pnpm 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. */