@dbx-tools/projen 0.9.18 → 0.9.21

package/src/scaffold.ts

@@ -2,7 +2,7 @@
  * Runs a projen re-synth, for the `sync` task and its watchers.
  */
 import { join } from "node:path";
-import * as exec from "@dbx-tools/core/exec";
+import { runTaskCommand } from "./_task-command.ts";
 import { repoRoot } from "./packages.ts";
 
 /**
@@ -34,9 +34,5 @@ export function runSynth(options: { post?: boolean } = {}): void {
   else env.PROJEN_DISABLE_POST = "true";
   const projenrc = join(repoRoot, ".projenrc.ts");
   const args = process.versions.bun ? [projenrc] : ["--import", "tsx", projenrc];
-  exec.spawnSync(process.execPath, args, {
-    cwd: repoRoot,
-    env,
-    check: true,
-  });
+  runTaskCommand(repoRoot, process.execPath, args, { env });
 }

package/src/workspace-version.ts

@@ -8,22 +8,17 @@
  * DEFAULT_VERSION} when it is absent on a fresh tree); it never rewrites it, so an
  * ordinary `bunx projen` cannot move a package version up or down.
  *
- * Only two callers change the number: the pure `bump` task used while preparing
- * a reviewed release PR, and the one-time bootstrap of a workspace that has no
- * `VERSION` yet. Both resolve the base from remote git tags first ({@link
- * resolveRemoteVersion}) so a release cut elsewhere is respected, and fall back
- * to the local file (or {@link DEFAULT_VERSION}) when the remote is unreachable
- * or has no tags. The remote is consulted only on those paths.
+ * Only the pure `bump` task changes the number. It increments the checked-in
+ * file while release preparation owns the surrounding Git transaction.
  */
 import { chmodSync, existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { parse as parseVersion } from "semver";
-import { captureTaskCommand } from "./_task-command.ts";
 
 /** Name of the repo-root file holding the workspace version. */
 export const VERSION_FILE = "VERSION";
 
-/** Version a fresh workspace starts at when no `VERSION` file and no remote tag exist. */
+/** Version a fresh workspace reads before its first explicit VERSION write. */
 export const DEFAULT_VERSION = "0.0.1";
 
 const SEMVER = /^\d+\.\d+\.\d+$/;
@@ -115,127 +110,20 @@ export function syncWorkspaceManifestVersion(manifestPath: string, version: stri
   return true;
 }
 
-/** Run git in `cwd`, capturing stdout and swallowing failure (offline, no repo). */
-function gitCapture(cwd: string, args: string[]): string {
-  try {
-    return captureTaskCommand(cwd, "git", args);
-  } catch {
-    return "";
-  }
-}
-
-/** Highest tag matching `<prefix><semver>` in the local tag list, or `undefined`. */
-export function latestTagVersion(cwd: string, prefix: string): Semver | undefined {
-  const out = gitCapture(cwd, [
-    "-c",
-    "versionsort.suffix=-",
-    "tag",
-    "--sort=-version:refname",
-    "--list",
-    `${prefix}*`,
-  ]);
-  for (const tag of out.split("\n")) {
-    if (!tag.startsWith(prefix)) continue;
-    const v = parseSemver(tag.slice(prefix.length));
-    if (v) return v;
-  }
-  return undefined;
-}
-
-/** Highest historical `<component>-<prefix><semver>` tag, or `undefined`. */
-export function latestComponentTagVersion(cwd: string, prefix: string): Semver | undefined {
-  const marker = `-${prefix}`;
-  const out = gitCapture(cwd, [
-    "-c",
-    "versionsort.suffix=-",
-    "tag",
-    "--sort=-version:refname",
-    "--list",
-    `*${marker}*`,
-  ]);
-  let best: Semver | undefined;
-  for (const tag of out.split("\n")) {
-    const index = tag.lastIndexOf(marker);
-    const raw = index >= 0 ? tag.slice(index + marker.length) : "";
-    if (!/^\d+\.\d+\.\d+$/.test(raw)) continue;
-    const version = parseSemver(raw);
-    if (version && (!best || compareSemver(version, best) > 0)) best = version;
-  }
-  return best;
-}
-
-/**
- * Highest published version across repository and historical component tags,
- * or `undefined` when the remote is unreachable or no matching tag exists.
- * Fetches tags first (best effort) so a release made elsewhere is respected; a
- * fetch failure just means the local tag list is used, and callers fall back to
- * the `VERSION` file.
- */
-export function resolveRemoteVersion(
-  cwd: string,
-  prefixes: readonly string[],
-  {
-    fetch = true,
-    includeComponentTags = true,
-  }: { fetch?: boolean; includeComponentTags?: boolean } = {},
-): string | undefined {
-  if (fetch) gitCapture(cwd, ["fetch", "--tags", "--quiet"]);
-  let best: Semver | undefined;
-  for (const prefix of prefixes) {
-    const versions = [
-      latestTagVersion(cwd, prefix),
-      ...(includeComponentTags ? [latestComponentTagVersion(cwd, prefix)] : []),
-    ];
-    for (const version of versions) {
-      if (version && (!best || compareSemver(version, best) > 0)) best = version;
-    }
-  }
-  return best ? best.join(".") : undefined;
-}
-
-/**
- * The base version a `bump` increments from: the highest remote tag if any exists
- * (a local file that is ahead does NOT win), else the local `VERSION` file, else
- * {@link DEFAULT_VERSION}.
- */
-export function resolveBaseVersion(
-  root: string,
-  prefixes: readonly string[],
-  options: { fetch?: boolean; includeComponentTags?: boolean } = {},
-): { version: string; source: "remote" | "local" } {
-  const remote = resolveRemoteVersion(root, prefixes, options);
-  if (remote) return { version: remote, source: "remote" };
-  return { version: readWorkspaceVersion(root), source: "local" };
+/** The checked-in version a release increment starts from. */
+export function resolveBaseVersion(root: string): string {
+  return readWorkspaceVersion(root);
 }
 
 /** Resolve the next release version without mutating the workspace. */
 export function resolveNextVersion(
   root: string,
-  prefixes: readonly string[],
   level: VersionLevel,
-  options: { fetch?: boolean; includeComponentTags?: boolean } = {},
-): { base: string; version: string; source: "remote" | "local" } {
-  const base = resolveBaseVersion(root, prefixes, options);
-  const parsed = parseSemver(base.version) ?? [0, 0, 1];
+): { base: string; version: string } {
+  const base = resolveBaseVersion(root);
+  const parsed = parseSemver(base) ?? [0, 0, 1];
   return {
     base: parsed.join("."),
     version: incrementSemver(parsed, level).join("."),
-    source: base.source,
   };
 }
-
-/**
- * Create the `VERSION` file when it does not yet exist, seeding it from the remote
- * tags (or {@link DEFAULT_VERSION} when the remote is unreachable / has no tag). An
- * existing file is left untouched - only `bump` moves an established version, so
- * bootstrap never upgrades or downgrades one. Returns the current version.
- */
-export function ensureWorkspaceVersion(
-  root: string,
-  { prefixes = ["v"], fetch = true }: { prefixes?: readonly string[]; fetch?: boolean } = {},
-): string {
-  if (!existsSync(versionPath(root))) {
-    writeWorkspaceVersion(root, resolveRemoteVersion(root, prefixes, { fetch }) ?? DEFAULT_VERSION);
-  }
-  return readWorkspaceVersion(root);
-}

package/tasks/bump.ts

@@ -4,7 +4,6 @@
  * generated version surface. This task has no git, registry, or publication
  * side effects; release preparation owns those operations.
  */
-import * as exec from "@dbx-tools/core/exec";
 import * as projectUtils from "@dbx-tools/core/project-utils";
 import { log } from "@dbx-tools/shared-core";
 import { Command } from "commander";
@@ -17,6 +16,7 @@ import {
   type ReleaseOs,
   type VersionLevel,
 } from "../src/_release-platform.ts";
+import { runTaskCommand } from "../src/_task-command.ts";
 import { resolveNextVersion, writeWorkspaceVersion } from "../src/workspace-version.ts";
 
 const logger = log.logger("projen:bump");
@@ -25,43 +25,26 @@ const program = new Command();
 program
   .description("Increment VERSION and synchronize generated workspace versions")
   .addOption(releaseLevelOption())
-  .option("--prefix <prefix>", "git tag prefix used to resolve the published base", "v")
   .addOption(releaseOperatingSystemOption())
   .addOption(releaseArchitectureOption())
   .option("--no-synth", "write VERSION without synchronizing generated files")
-  .action(
-    (opts: {
-      level: VersionLevel;
-      prefix: string;
-      os: ReleaseOs[];
-      arch: ReleaseArch[];
-      synth: boolean;
-    }) => {
-      const root = projectUtils.root() ?? process.cwd();
-      const next = resolveNextVersion(root, [opts.prefix], opts.level);
-      const releasePlatforms = releasePlatformFilter(opts.os, opts.arch);
+  .action((opts: { level: VersionLevel; os: ReleaseOs[]; arch: ReleaseArch[]; synth: boolean }) => {
+    const root = projectUtils.root() ?? process.cwd();
+    const next = resolveNextVersion(root, opts.level);
+    const releasePlatforms = releasePlatformFilter(opts.os, opts.arch);
 
-      logger.info(
-        `bump ${next.base} -> ${next.version} (${opts.level})` +
-          `${next.source === "remote" ? "" : " [no remote tag; used local VERSION]"}`,
-      );
-      writeWorkspaceVersion(root, next.version);
+    logger.info(`bump ${next.base} -> ${next.version} (${opts.level})`);
+    writeWorkspaceVersion(root, next.version);
 
-      if (opts.synth) {
-        exec.spawnSync(process.execPath, [".projenrc.ts"], {
-          cwd: root,
-          stdout: "inherit",
-          stderr: "inherit",
-          stdin: "ignore",
-          check: true,
-          env: {
-            ...process.env,
-            ...(releasePlatforms ? { DBX_TOOLS_RELEASE_PLATFORMS: releasePlatforms } : {}),
-          },
-        });
-      }
-      logger.success(`workspace version synchronized at ${next.version}`);
-    },
-  );
+    if (opts.synth) {
+      runTaskCommand(root, process.execPath, [".projenrc.ts"], {
+        env: {
+          ...process.env,
+          ...(releasePlatforms ? { DBX_TOOLS_RELEASE_PLATFORMS: releasePlatforms } : {}),
+        },
+      });
+    }
+    logger.success(`workspace version synchronized at ${next.version}`);
+  });
 
 await program.parseAsync();

package/tasks/local-publish.ts

@@ -1,29 +1,31 @@
-/** Local registry preflight shared by release preparation. */
-import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
+/** Publish one verified release candidate to configured loopback registries. */
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import * as exec from "@dbx-tools/core/exec";
 import * as projectUtils from "@dbx-tools/core/project-utils";
 import { log, net } from "@dbx-tools/shared-core";
+import { Command } from "commander";
 import { activePythonIndexes, resolveLocalPypi } from "./python-registry.ts";
+import { verifyReleaseManifest } from "./release-manifest.ts";
+import { runTaskCommandAsync } from "../src/_task-command.ts";
 import { readDbxToolsConfig } from "../src/packages.ts";
 
 const logger = log.logger("projen:local-publish");
 
-/** Options for publishing one release candidate to configured loopback registries. */
+/** Options for publishing an immutable release candidate to local registries. */
 export interface LocalPublishOptions {
+  readonly candidateDirectory: string;
+  readonly gitSha: string;
+  readonly localCargo: boolean;
+  readonly localPypi: string;
+  readonly localRegistry: string;
   readonly root: string;
+  readonly tag: string;
   readonly version: string;
-  readonly localRegistry: string;
-  readonly localPypi: string;
-  readonly pythonRoot?: string;
-  readonly localCargo: boolean;
-  /** Reuse the root TypeScript compile that immediately preceded local publication. */
-  readonly reuseValidatedNodeCompile?: boolean;
 }
 
-function resolveLocalRegistry(value: string): string | undefined {
+export function resolveLocalRegistry(value: string): string | undefined {
   const trimmed = value.trim();
   if (!trimmed || trimmed.toLowerCase() === "false") return undefined;
   if (trimmed.toLowerCase() === "auto") {
@@ -33,7 +35,7 @@ function resolveLocalRegistry(value: string): string | undefined {
   return trimmed;
 }
 
-function localCargoRegistry(): string | undefined {
+export function localCargoRegistry(): string | undefined {
   if (process.env.LOCAL_CARGO_REGISTRY) return process.env.LOCAL_CARGO_REGISTRY;
   const config = join(homedir(), ".cargo", "config.toml");
   if (!existsSync(config)) return undefined;
@@ -48,28 +50,32 @@ function localCargoRegistry(): string | undefined {
   return undefined;
 }
 
-/** Arguments for the workspace npm publisher used by local release preflight. */
-export function localNodePublishArguments(
-  publishScript: string,
-  options: Pick<LocalPublishOptions, "version" | "reuseValidatedNodeCompile">,
-  registry: string,
-): string[] {
-  return [
-    publishScript,
-    options.version,
-    "--registry",
-    registry,
-    ...(options.reuseValidatedNodeCompile ? ["--skip-compile"] : []),
-  ];
+function hasRustCrates(root: string): boolean {
+  const rust = readDbxToolsConfig(root)?.rust;
+  return Boolean(
+    rust &&
+    typeof rust === "object" &&
+    !Array.isArray(rust) &&
+    Array.isArray((rust as { crates?: unknown }).crates) &&
+    (rust as { crates: unknown[] }).crates.length > 0,
+  );
 }
 
-/** Publish the exact release candidate to local npm, PyPI, and Cargo mirrors. */
+/** Publish the exact candidate archives before they are attached to the draft release. */
 export async function publishLocalRelease(options: LocalPublishOptions): Promise<void> {
+  const root = resolve(options.root);
+  const candidateDirectory = resolve(options.candidateDirectory);
+  verifyReleaseManifest({
+    directory: candidateDirectory,
+    gitSha: options.gitSha,
+    tag: options.tag,
+    version: options.version,
+  });
+
   const localRegistry = resolveLocalRegistry(options.localRegistry);
   const activeIndexes = activePythonIndexes();
   const localPypi = resolveLocalPypi(options.localPypi, activeIndexes);
-  const pythonRoot = options.pythonRoot ? resolve(options.root, options.pythonRoot) : undefined;
-  const localPublishes: Promise<unknown>[] = [];
+  const publishes: Promise<unknown>[] = [];
 
   if (
     options.localPypi.toLowerCase() === "auto" &&
@@ -82,103 +88,104 @@ export async function publishLocalRelease(options: LocalPublishOptions): Promise
   }
 
   if (localRegistry) {
-    const publishScript = fileURLToPath(new URL("./publish.ts", import.meta.url));
-    logger.info(`publishing ${options.version} to local registry ${localRegistry}`);
-    localPublishes.push(
-      exec
-        .spawn(process.execPath, localNodePublishArguments(publishScript, options, localRegistry), {
-          cwd: options.root,
-          stdout: "inherit",
-          stderr: "inherit",
-          stdin: "ignore",
-          check: true,
-        })
-        .then(() => logger.success(`published ${options.version} to ${localRegistry}`)),
+    const publishNpmScript = fileURLToPath(new URL("./publish-npm.ts", import.meta.url));
+    logger.info(`publishing approved npm archives to ${localRegistry}`);
+    publishes.push(
+      runTaskCommandAsync(root, process.execPath, [
+        publishNpmScript,
+        "--directory",
+        candidateDirectory,
+        "--version",
+        options.version,
+        "--registry",
+        localRegistry,
+      ]),
     );
   }
 
-  if (localPypi && pythonRoot && existsSync(pythonRoot)) {
-    const publishPythonScript = fileURLToPath(new URL("./publish-python.ts", import.meta.url));
-    logger.info(`publishing Python ${options.version} to local devpi ${localPypi.publishUrl}`);
-    localPublishes.push(
-      exec
-        .spawn(
-          process.execPath,
-          [
-            publishPythonScript,
-            options.version,
-            "--root",
-            pythonRoot,
-            "--index-url",
-            localPypi.indexUrl,
-            "--publish-url",
-            localPypi.publishUrl,
-          ],
-          {
-            cwd: options.root,
-            stdout: "inherit",
-            stderr: "inherit",
-            stdin: "ignore",
-            check: true,
-          },
-        )
-        .then(() =>
-          logger.success(`published Python ${options.version} to ${localPypi.publishUrl}`),
-        ),
+  if (localPypi) {
+    const pythonDirectory = mkdtempSync(join(tmpdir(), "dbx-tools-local-pypi-"));
+    verifyReleaseManifest({
+      directory: candidateDirectory,
+      gitSha: options.gitSha,
+      kind: "pypi",
+      output: pythonDirectory,
+      tag: options.tag,
+      version: options.version,
+    });
+    logger.info(`publishing approved Python distributions to ${localPypi.publishUrl}`);
+    publishes.push(
+      runTaskCommandAsync(
+        root,
+        "uvx",
+        [
+          "--from",
+          "devpi-client",
+          "devpi",
+          "upload",
+          "--index",
+          localPypi.publishUrl,
+          "--from-dir",
+          pythonDirectory,
+        ],
+        { env: { ...process.env, UV_DEFAULT_INDEX: localPypi.indexUrl } },
+      ).finally(() => rmSync(pythonDirectory, { recursive: true, force: true })),
     );
   }
 
-  await Promise.all(localPublishes);
-  if (localRegistry || localPypi) {
-    const publishUniFFIScript = fileURLToPath(
-      new URL("./publish-uniffi-local.ts", import.meta.url),
-    );
-    await exec.spawn(
-      process.execPath,
-      [
-        publishUniFFIScript,
-        "--version",
-        options.version,
-        ...(localRegistry ? ["--registry", localRegistry] : []),
-        ...(localPypi ? ["--pypi-publish-url", localPypi.publishUrl] : []),
-      ],
-      {
-        cwd: options.root,
-        stdout: "inherit",
-        stderr: "inherit",
-        stdin: "ignore",
-        check: true,
-      },
-    );
-    logger.success(`published host-native bindings for ${options.version}`);
-  }
+  await Promise.all(publishes);
 
-  const rust = readDbxToolsConfig(options.root)?.rust;
-  const hasRustCrates = Boolean(
-    rust &&
-    typeof rust === "object" &&
-    !Array.isArray(rust) &&
-    Array.isArray((rust as { crates?: unknown }).crates) &&
-    (rust as { crates: unknown[] }).crates.length > 0,
-  );
-  if (options.localCargo && hasRustCrates) {
-    const cargoRegistry = localCargoRegistry();
-    if (cargoRegistry) {
-      const publishUniFFIScript = fileURLToPath(
+  if (options.localCargo && hasRustCrates(root)) {
+    const registry = localCargoRegistry();
+    if (registry) {
+      const publishCargoScript = fileURLToPath(
         new URL("./publish-uniffi-local.ts", import.meta.url),
       );
-      await exec.spawn(
-        process.execPath,
-        [publishUniFFIScript, "--version", options.version, "--cargo-registry", cargoRegistry],
-        {
-          cwd: options.root,
-          stdout: "inherit",
-          stderr: "inherit",
-          stdin: "ignore",
-          check: true,
-        },
-      );
-      logger.success(`published Rust ${options.version} to ${cargoRegistry}`);
+      await runTaskCommandAsync(root, process.execPath, [
+        publishCargoScript,
+        "--version",
+        options.version,
+        "--cargo-registry",
+        registry,
+      ]);
+      logger.success(`published Rust ${options.version} to ${registry}`);
     }
   }
+
+  logger.success(`published approved local candidate ${options.tag}`);
+}
+
+if (import.meta.main) {
+  await new Command()
+    .requiredOption("--candidate-directory <path>", "verified release candidate directory")
+    .requiredOption("--sha <sha>", "exact release commit")
+    .requiredOption("--tag <tag>", "annotated release tag")
+    .requiredOption("--version <version>", "release version")
+    .option("--root <path>", "repository root")
+    .option("--local-registry <url>", "local npm registry", "auto")
+    .option("--local-pypi <url>", "local devpi index", "auto")
+    .option("--local-cargo", "publish Cargo crates to a configured local registry")
+    .action(
+      (options: {
+        candidateDirectory: string;
+        sha: string;
+        tag: string;
+        version: string;
+        root?: string;
+        localRegistry: string;
+        localPypi: string;
+        localCargo?: boolean;
+      }) =>
+        publishLocalRelease({
+          candidateDirectory: options.candidateDirectory,
+          gitSha: options.sha,
+          localCargo: Boolean(options.localCargo),
+          localPypi: options.localPypi,
+          localRegistry: options.localRegistry,
+          root: options.root ?? projectUtils.root() ?? process.cwd(),
+          tag: options.tag,
+          version: options.version,
+        }),
+    )
+    .parseAsync();
 }