@dbx-tools/cli 0.6.27 → 0.6.35

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, project } from "@dbx-tools/core";
-import { json } from "@dbx-tools/shared-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;
     }
@@ -140,7 +148,27 @@ export function seedToolchain(root, projenSpecifier = defaultProjenSpecifier())
         writeFileSync(workspaceFile, WORKSPACE_SEED);
     }
     seedRegistry(root);
-    runPnpm(["add", "-D", "projen", "typescript@^5.9.3", "tsx@^4.23.0", projenSpecifier], 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`.
@@ -209,4 +237,4 @@ export function runInitialSynth(root) {
         check: true,
     });
 }
-//# 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,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAEtC,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,MAAM,YAAY,GAAG,aAAa,CAAC,IAAI,GAAG,CAAC,iBAAiB,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;QAChF,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,OAAO,CAAC,CAAC,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,mBAAmB,EAAE,aAAa,EAAE,eAAe,CAAC,EAAE,IAAI,CAAC,CAAC;AAC9F,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 { join } from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\nimport { intro, outro } from \"@clack/prompts\";\nimport { exec, project } from \"@dbx-tools/core\";\nimport { json } from \"@dbx-tools/shared-core\";\nimport { childEnv, 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  seedRegistry(root);\n\n  runPnpm([\"add\", \"-D\", \"projen\", \"typescript@^5.9.3\", \"tsx@^4.23.0\", projenSpecifier], root);\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"]}
+//# 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 { 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

@@ -2,10 +2,15 @@
 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 registry under npm's env-var convention, for children
- * that read it (npm, npx, and anything they spawn). pnpm ignores it, which is
- * why the CLI flags above exist.
+ * `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). */

package/lib/src/pnpm.js

@@ -34,7 +34,7 @@
  * @module
  */
 import { createRequire } from "node:module";
-import { dirname, join } from "node:path";
+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";
@@ -51,7 +51,6 @@ const REGISTRY_SUBCOMMANDS = new Set([
     "dlx",
     "i",
     "import",
-    "init",
     "install",
     "link",
     "up",
@@ -69,23 +68,35 @@ const registryOverride = functionModule.memoize(() => project.npmRegistry(null,
 /** `--registry <url>` for npx, or `[]`. Placed BEFORE the package name by callers. */
 export function npxRegistryArgs() {
     const url = registryOverride();
-    return url ? ["--registry", url] : [];
+    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 && REGISTRY_SUBCOMMANDS.has(subcommand) ? ["--registry", url] : [];
+    return subcommand !== undefined && REGISTRY_SUBCOMMANDS.has(subcommand);
 }
 /**
- * `process.env` plus the registry under npm's env-var convention, for children
- * that read it (npm, npx, and anything they spawn). pnpm ignores it, which is
- * why the CLI flags above exist.
+ * `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.
@@ -176,4 +187,4 @@ export function ensureWorkspaceReady(root) {
 export function runProjen(args, root) {
     runPnpm(["exec", "projen", ...args], root);
 }
-//# 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 { 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  \"init\",\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 ? [\"--registry\", 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  const subcommand = args.find((arg) => !arg.startsWith(\"-\"));\n  return subcommand && REGISTRY_SUBCOMMANDS.has(subcommand) ? [\"--registry\", url] : [];\n}\n\n/**\n * `process.env` plus the registry under npm's env-var convention, for children\n * that read it (npm, npx, and anything they spawn). pnpm ignores it, which is\n * why the CLI flags above exist.\n */\nexport function childEnv(extra?: Record<string, string>): NodeJS.ProcessEnv {\n  const env: NodeJS.ProcessEnv = { ...process.env, ...extra };\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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pnpm.js","sourceRoot":"","sources":["../../src/pnpm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACrD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAEzC,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC;AAK5C;;;;;GAKG;AACH,MAAM,oBAAoB,GAAG,IAAI,GAAG,CAAC;IACnC,KAAK;IACL,QAAQ;IACR,KAAK;IACL,GAAG;IACH,QAAQ;IACR,SAAS;IACT,MAAM;IACN,IAAI;IACJ,QAAQ;CACT,CAAC,CAAC;AAEH;;;;;;;GAOG;AACH,MAAM,gBAAgB,GAAG,cAAc,CAAC,OAAO,CAAC,GAAuB,EAAE,CACvE,OAAO,CAAC,WAAW,CAAC,IAAI,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,CAC7E,CAAC;AAEF,sFAAsF;AACtF,MAAM,UAAU,eAAe;IAC7B,MAAM,GAAG,GAAG,gBAAgB,EAAE,CAAC;IAC/B,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC,aAAa,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;AACzC,CAAC;AAED,8FAA8F;AAC9F,MAAM,UAAU,gBAAgB,CAAC,IAAuB;IACtD,MAAM,GAAG,GAAG,gBAAgB,EAAE,CAAC;IAC/B,IAAI,CAAC,GAAG;QAAE,OAAO,EAAE,CAAC;IACpB,OAAO,gBAAgB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,YAAY,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;AAC3D,CAAC;AAED,oFAAoF;AACpF,MAAM,UAAU,gBAAgB,CAAC,IAAuB;IACtD,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC;IAC5D,OAAO,UAAU,KAAK,SAAS,IAAI,oBAAoB,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;AAC1E,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,QAAQ,CAAC,KAA8B;IACrD,MAAM,GAAG,GAAsB,EAAE,GAAG,OAAO,CAAC,GAAG,EAAE,GAAG,KAAK,EAAE,CAAC;IAC5D,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC1C,MAAM,WAAW,GAAG,CAAC,GAAG,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IACtE,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;QACnC,GAAG,CAAC,IAAI,GAAG,CAAC,OAAO,EAAE,GAAG,WAAW,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IACvD,CAAC;IACD,MAAM,GAAG,GAAG,gBAAgB,EAAE,CAAC;IAC/B,IAAI,GAAG,EAAE,CAAC;QACR,+EAA+E;QAC/E,GAAG,CAAC,mBAAmB,GAAG,GAAG,CAAC;QAC9B,GAAG,CAAC,mBAAmB,GAAG,GAAG,CAAC;IAChC,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,qEAAqE;AACrE,SAAS,UAAU;IACjB,IAAI,CAAC;QACH,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC,WAAW,CAAC,EAAE;YACpC,MAAM,EAAE,QAAQ;YAChB,KAAK,EAAE,QAAQ;YACf,MAAM,EAAE,QAAQ;YAChB,KAAK,EAAE,IAAI;SACZ,CAAC,CAAC;QACH,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED,SAAS,mBAAmB;IAC1B,4EAA4E;IAC5E,2EAA2E;IAC3E,6EAA6E;IAC7E,IAAI,CAAC;QACH,MAAM,OAAO,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC/C,MAAM,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC;QACzD,MAAM,GAAG,GAAG,OAAO,CAAC,WAAW,CAAsB,CAAC;QACtD,MAAM,GAAG,GAAG,OAAO,GAAG,CAAC,GAAG,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC;QACjE,IAAI,GAAG;YAAE,OAAO,CAAC,OAAO,CAAC,QAAQ,EAAE,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;IACtE,CAAC;IAAC,MAAM,CAAC;QACP,eAAe;IACjB,CAAC;IAED,2EAA2E;IAC3E,0EAA0E;IAC1E,gEAAgE;IAChE,qEAAqE;IACrE,IAAI,UAAU,EAAE;QAAE,OAAO,CAAC,MAAM,CAAC,CAAC;IAElC,mDAAmD;IACnD,IAAI,CAAC;QACH,IAAI,CAAC,SAAS,CAAC,UAAU,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC,EAAE;YAC7C,MAAM,EAAE,QAAQ;YAChB,KAAK,EAAE,QAAQ;YACf,MAAM,EAAE,QAAQ;YAChB,KAAK,EAAE,IAAI;SACZ,CAAC,CAAC;QACH,IAAI,UAAU,EAAE;YAAE,OAAO,CAAC,MAAM,CAAC,CAAC;IACpC,CAAC;IAAC,MAAM,CAAC;QACP,eAAe;IACjB,CAAC;IAED,6EAA6E;IAC7E,wEAAwE;IACxE,6EAA6E;IAC7E,8EAA8E;IAC9E,oEAAoE;IACpE,OAAO,CAAC,KAAK,EAAE,GAAG,eAAe,EAAE,EAAE,IAAI,EAAE,uBAAuB,EAAE,MAAM,CAAC,CAAC;AAC9E,CAAC;AAED,2GAA2G;AAC3G,MAAM,CAAC,MAAM,eAAe,GAAG,cAAc,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC;AAE3E,+EAA+E;AAC/E,MAAM,UAAU,OAAO,CAAC,IAAc,EAAE,GAAW;IACjD,MAAM,CAAC,OAAO,EAAE,GAAG,MAAM,CAAC,GAAG,eAAe,EAAE,CAAC;IAC/C,MAAM,YAAY,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAC;IAC5C,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC5B,MAAM,CAAC,IAAI,CAAC,+BAA+B,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IAChE,CAAC;IACD,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC,GAAG,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,YAAY,CAAC,EAAE;QAC7D,GAAG;QACH,KAAK,EAAE,IAAI;QACX,GAAG,EAAE,QAAQ,EAAE;KAChB,CAAC,CAAC;AACL,CAAC;AAED,+EAA+E;AAC/E,MAAM,UAAU,oBAAoB,CAAC,IAAY;IAC/C,IAAI,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC;QACvB,OAAO,CAAC,CAAC,SAAS,EAAE,sBAAsB,CAAC,EAAE,IAAI,CAAC,CAAC;IACrD,CAAC;AACH,CAAC;AAED,8DAA8D;AAC9D,MAAM,UAAU,SAAS,CAAC,IAAc,EAAE,IAAY;IACpD,OAAO,CAAC,CAAC,MAAM,EAAE,QAAQ,EAAE,GAAG,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC;AAC7C,CAAC","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.27",
-    "@dbx-tools/shared-core": "0.6.27"
+    "@dbx-tools/core": "0.6.35",
+    "@dbx-tools/shared-core": "0.6.35"
   },
   "main": "./lib/index.js",
   "license": "UNLICENSED",
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.6.27",
+  "version": "0.6.35",
   "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, project } from "@dbx-tools/core";
-import { json } from "@dbx-tools/shared-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 {
@@ -159,7 +169,30 @@ export function seedToolchain(
 
   seedRegistry(root);
 
-  runPnpm(["add", "-D", "projen", "typescript@^5.9.3", "tsx@^4.23.0", projenSpecifier], 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,
+  );
 }
 
 /**

package/src/pnpm.ts

@@ -34,7 +34,7 @@
  * @module
  */
 import { createRequire } from "node:module";
-import { dirname, join } from "node:path";
+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";
@@ -56,7 +56,6 @@ const REGISTRY_SUBCOMMANDS = new Set([
   "dlx",
   "i",
   "import",
-  "init",
   "install",
   "link",
   "up",
@@ -78,24 +77,37 @@ const registryOverride = functionModule.memoize((): string | undefined =>
 /** `--registry <url>` for npx, or `[]`. Placed BEFORE the package name by callers. */
 export function npxRegistryArgs(): string[] {
   const url = registryOverride();
-  return url ? ["--registry", url] : [];
+  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 && REGISTRY_SUBCOMMANDS.has(subcommand) ? ["--registry", url] : [];
+  return subcommand !== undefined && REGISTRY_SUBCOMMANDS.has(subcommand);
 }
 
 /**
- * `process.env` plus the registry under npm's env-var convention, for children
- * that read it (npm, npx, and anything they spawn). pnpm ignores it, which is
- * why the CLI flags above exist.
+ * `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.