@dbx-tools/projen 0.9.19 → 0.9.28

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/databricks-cli-assets.ts

@@ -0,0 +1,129 @@
+#!/usr/bin/env -S bun
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { parseArgs } from "node:util";
+
+import * as projectUtils from "@dbx-tools/core/project-utils";
+
+import { makeReadonly, makeWritable } from "../src/generated.ts";
+
+const MINIMUM_VERSION = "0.296.0";
+const REPOSITORY = "databricks/cli";
+const PLATFORM_ASSETS = {
+  "darwin-arm64": "darwin_arm64",
+  "darwin-x64": "darwin_amd64",
+  "linux-arm64": "linux_arm64",
+  "linux-x64": "linux_amd64",
+  "win32-arm64": "windows_arm64",
+  "win32-x64": "windows_amd64",
+} as const;
+
+interface GitHubAsset {
+  readonly browser_download_url: string;
+  readonly digest?: string;
+  readonly name: string;
+}
+
+interface GitHubRelease {
+  readonly assets: GitHubAsset[];
+  readonly published_at: string;
+  readonly tag_name: string;
+}
+
+interface CliAsset {
+  readonly sha256: string;
+  readonly url: string;
+}
+
+interface CliAssetManifest {
+  readonly schemaVersion: 1;
+  readonly dbxToolsVersion: string;
+  readonly minimumVersion: string;
+  readonly version: string;
+  readonly publishedAt: string;
+  readonly assets: Record<keyof typeof PLATFORM_ASSETS, CliAsset>;
+}
+
+function validManifest(value: unknown, dbxToolsVersion: string): value is CliAssetManifest {
+  if (!value || typeof value !== "object") return false;
+  const manifest = value as Partial<CliAssetManifest>;
+  return (
+    manifest.schemaVersion === 1 &&
+    manifest.dbxToolsVersion === dbxToolsVersion &&
+    manifest.minimumVersion === MINIMUM_VERSION &&
+    typeof manifest.version === "string" &&
+    typeof manifest.publishedAt === "string" &&
+    Boolean(manifest.assets) &&
+    Object.keys(PLATFORM_ASSETS).every((key) => {
+      const asset = manifest.assets?.[key as keyof typeof PLATFORM_ASSETS];
+      return (
+        typeof asset?.url === "string" &&
+        typeof asset.sha256 === "string" &&
+        /^[0-9a-f]{64}$/.test(asset.sha256)
+      );
+    })
+  );
+}
+
+async function latestManifest(dbxToolsVersion: string): Promise<CliAssetManifest> {
+  const response = await fetch(`https://api.github.com/repos/${REPOSITORY}/releases/latest`, {
+    headers: {
+      accept: "application/vnd.github+json",
+      "user-agent": `dbx-tools/${dbxToolsVersion}`,
+    },
+  });
+  if (!response.ok) {
+    throw new Error(`Could not resolve the latest Databricks CLI release (${response.status})`);
+  }
+  const release = (await response.json()) as GitHubRelease;
+  const version = release.tag_name.replace(/^v/, "");
+  const assets = Object.fromEntries(
+    Object.entries(PLATFORM_ASSETS).map(([platform, suffix]) => {
+      const name = `databricks_cli_${version}_${suffix}.tar.gz`;
+      const asset = release.assets.find((candidate) => candidate.name === name);
+      const sha256 = asset?.digest?.match(/^sha256:([0-9a-f]{64})$/i)?.[1]?.toLowerCase();
+      if (!asset || !sha256)
+        throw new Error(`Release ${release.tag_name} has no digest for ${name}`);
+      return [platform, { url: asset.browser_download_url, sha256 }];
+    }),
+  ) as CliAssetManifest["assets"];
+  return {
+    schemaVersion: 1,
+    dbxToolsVersion,
+    minimumVersion: MINIMUM_VERSION,
+    version,
+    publishedAt: release.published_at,
+    assets,
+  };
+}
+
+const { values } = parseArgs({
+  options: {
+    check: { type: "boolean", default: false },
+    root: { type: "string" },
+  },
+  strict: true,
+});
+const root = resolve(values.root ?? projectUtils.root() ?? process.cwd());
+const output = join(root, "packages/js/node/auth/src/generated/databricks-cli-assets.json");
+const dbxToolsVersion = readFileSync(join(root, "VERSION"), "utf8").trim();
+let current: unknown;
+if (existsSync(output)) {
+  try {
+    current = JSON.parse(readFileSync(output, "utf8"));
+  } catch {
+    current = undefined;
+  }
+}
+if (validManifest(current, dbxToolsVersion)) {
+  console.log(`verified ${output.slice(root.length + 1)}`);
+} else if (values.check) {
+  throw new Error("Databricks CLI asset manifest is missing or stale");
+} else {
+  const manifest = await latestManifest(dbxToolsVersion);
+  mkdirSync(dirname(output), { recursive: true });
+  makeWritable(output);
+  writeFileSync(output, `${JSON.stringify(manifest, undefined, 2)}\n`);
+  makeReadonly(output);
+  console.log(`generated ${output.slice(root.length + 1)}`);
+}

package/tasks/local-publish.ts

@@ -1,29 +1,24 @@
-/** Local registry preflight shared by release preparation. */
-import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join, resolve } from "node:path";
+/** Build and publish the current workspace to configured loopback registries. */
+import { 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 { readDbxToolsConfig } from "../src/packages.ts";
+import { runTaskCommandAsync } from "../src/_task-command.ts";
 
 const logger = log.logger("projen:local-publish");
 
-/** Options for publishing one release candidate to configured loopback registries. */
+/** Options for publishing the current workspace to local registries. */
 export interface LocalPublishOptions {
+  readonly localPypi: string;
+  readonly localRegistry: string;
+  readonly pythonRoot: string;
   readonly root: 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,43 +28,13 @@ function resolveLocalRegistry(value: string): string | undefined {
   return trimmed;
 }
 
-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;
-  const source = readFileSync(config, "utf8");
-  const sections = [
-    ...source.matchAll(/^\[registries\.([^\]]+)\]\s*\n([\s\S]*?)(?=^\[|(?![\s\S]))/gm),
-  ];
-  for (const section of sections) {
-    const index = section[2]?.match(/^\s*index\s*=\s*["']([^"']+)["']/m)?.[1];
-    if (index && net.isLoopbackHost(index.replace(/^sparse\+/, ""))) return section[1];
-  }
-  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"] : []),
-  ];
-}
-
-/** Publish the exact release candidate to local npm, PyPI, and Cargo mirrors. */
+/** Build and publish the current workspace directly to local registries. */
 export async function publishLocalRelease(options: LocalPublishOptions): Promise<void> {
+  const root = resolve(options.root);
   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 +47,61 @@ 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.ts", import.meta.url));
+    logger.info(`building and publishing npm workspace to ${localRegistry}`);
+    publishes.push(
+      runTaskCommandAsync(root, process.execPath, [
+        publishNpmScript,
+        options.version,
+        "--registry",
+        localRegistry,
+      ]),
     );
   }
 
-  if (localPypi && pythonRoot && existsSync(pythonRoot)) {
+  if (localPypi) {
     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}`),
-        ),
-    );
-  }
-
-  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",
+    logger.info(`building and publishing Python workspace to ${localPypi.publishUrl}`);
+    publishes.push(
+      runTaskCommandAsync(root, process.execPath, [
+        publishPythonScript,
         options.version,
-        ...(localRegistry ? ["--registry", localRegistry] : []),
-        ...(localPypi ? ["--pypi-publish-url", localPypi.publishUrl] : []),
-      ],
-      {
-        cwd: options.root,
-        stdout: "inherit",
-        stderr: "inherit",
-        stdin: "ignore",
-        check: true,
-      },
+        "--root",
+        options.pythonRoot,
+        "--index-url",
+        localPypi.indexUrl,
+        "--publish-url",
+        localPypi.publishUrl,
+      ]),
     );
-    logger.success(`published host-native bindings for ${options.version}`);
   }
 
-  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(
-        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 Promise.all(publishes);
+  logger.success(`published local workspace ${options.version}`);
+}
+
+if (import.meta.main) {
+  await new Command()
+    .requiredOption("--version <version>", "release version")
+    .option("--root <path>", "repository root")
+    .option("--python-root <path>", "Python package root", "packages/py")
+    .option("--local-registry <url>", "local npm registry", "auto")
+    .option("--local-pypi <url>", "local devpi index", "auto")
+    .action(
+      (options: {
+        version: string;
+        root?: string;
+        pythonRoot: string;
+        localRegistry: string;
+        localPypi: string;
+      }) =>
+        publishLocalRelease({
+          localPypi: options.localPypi,
+          localRegistry: options.localRegistry,
+          pythonRoot: options.pythonRoot,
+          root: options.root ?? projectUtils.root() ?? process.cwd(),
+          version: options.version,
+        }),
+    )
+    .parseAsync();
 }