@dbx-tools/projen 0.9.17 → 0.9.19

package/tasks/release-pr.ts

@@ -15,6 +15,7 @@ import * as projectUtils from "@dbx-tools/core/project-utils";
 import { asyncUtils, json, log, object } from "@dbx-tools/shared-core";
 import { Command } from "commander";
 import { publishLocalRelease } from "./local-publish.ts";
+import { hasLocalReleaseTargets, missingLocalReleaseTools } from "./release-assets.ts";
 import { generateReleaseSummary } from "./release-summary.ts";
 import {
   releaseArchitectureOption,
@@ -38,7 +39,9 @@ import {
   githubAccountSupportsWorkflowChanges,
   githubAuthenticatedAccounts,
   githubRepositoryApiPath,
+  githubRepositoryCanManage,
   githubRepositoryIdentity,
+  githubRepositoryPermissions,
   githubRepositorySpecifier,
   githubTokenArguments,
   githubTokenEnvironmentName,
@@ -77,6 +80,34 @@ async function waitForPullRequestMerge(
   env: NodeJS.ProcessEnv,
   timeoutMs: number,
 ): Promise<string> {
+  const checksDeadline = Date.now() + timeoutMs;
+  let checksReported = false;
+  while (Date.now() < checksDeadline) {
+    const count = Number(
+      captureTaskCommand(
+        root,
+        "gh",
+        [
+          "pr",
+          "view",
+          releaseBranch,
+          "--json",
+          "statusCheckRollup",
+          "--jq",
+          ".statusCheckRollup | length",
+        ],
+        { env },
+      ),
+    );
+    if (Number.isInteger(count) && count > 0) {
+      checksReported = true;
+      break;
+    }
+    await asyncUtils.sleep(2_000);
+  }
+  if (!checksReported) {
+    throw new Error(`Release pull request reported no checks within ${timeoutMs}ms`);
+  }
   await runTaskCommandAsync(
     root,
     "gh",
@@ -107,56 +138,13 @@ async function waitForPullRequestMerge(
   throw new Error(`Release pull request did not merge within ${timeoutMs}ms`);
 }
 
-/** Find and watch the release workflow for an exact merged commit. */
-async function waitForReleaseWorkflow(
-  root: string,
-  baseBranch: string,
-  mergeSha: string,
-  env: NodeJS.ProcessEnv,
-  timeoutMs: number,
-): Promise<void> {
-  const deadline = Date.now() + timeoutMs;
-  let runId = "";
-  while (Date.now() < deadline) {
-    runId = captureTaskCommand(
-      root,
-      "gh",
-      [
-        "run",
-        "list",
-        "--workflow",
-        "release.yml",
-        "--branch",
-        baseBranch,
-        "--event",
-        "push",
-        "--commit",
-        mergeSha,
-        "--limit",
-        "1",
-        "--json",
-        "databaseId",
-        "--jq",
-        ".[0].databaseId // empty",
-      ],
-      { env },
-    );
-    if (runId) break;
-    await asyncUtils.sleep(5_000);
-  }
-  if (!runId) throw new Error(`Release workflow did not start within ${timeoutMs}ms`);
-  await runTaskCommandAsync(root, "gh", ["run", "watch", runId, "--exit-status"], {
-    env,
-    signal: AbortSignal.timeout(timeoutMs),
-  });
-}
-
 function githubAccount(root: string): {
   hostname: string;
   owner: string;
   repository: string;
   login: string;
   token: string;
+  canManage: boolean;
 } {
   const repository = projectUtils.repositoryUrl(root);
   if (!repository) throw new Error("Release preparation requires a GitHub repository");
@@ -199,21 +187,20 @@ function githubAccount(root: string): {
     });
     const repositoryData =
       repositoryResult.exitCode === 0 ? json.parseRecord(repositoryResult.stdout ?? "") : undefined;
-    const permissions = object.isRecord(repositoryData?.permissions)
-      ? repositoryData.permissions
-      : undefined;
-    if (
-      permissions?.push !== true &&
-      permissions?.maintain !== true &&
-      permissions?.admin !== true
-    ) {
+    const permissions = githubRepositoryPermissions(repositoryData);
+    if (!permissions.push && !permissions.maintain && !permissions.admin) {
       continue;
     }
     logger.info("selected GitHub CLI account", {
       login: account.login,
       repository: `${identity.owner}/${identity.repository}`,
     });
-    return { ...identity, login: account.login, token };
+    return {
+      ...identity,
+      login: account.login,
+      token,
+      canManage: githubRepositoryCanManage(permissions),
+    };
   }
   const detected =
     accounts
@@ -275,7 +262,7 @@ program
   .option("--no-wait", "return after enabling automatic merge without watching publication")
   .option(
     "--wait-timeout-minutes <minutes>",
-    "maximum time for pull request checks, merge, and publication",
+    "maximum time for pull request checks and merge",
     "120",
   )
   .action(
@@ -313,9 +300,21 @@ program
           throw new Error("--wait-timeout-minutes must be a positive integer");
         }
         const waitTimeoutMs = waitTimeoutMinutes * 60_000;
+        if (opts.approve && !opts.wait) {
+          throw new Error("automatic merge requires waiting so the draft candidate can be built");
+        }
         const currentBranch = git(root, ["branch", "--show-current"], { capture: true });
         if (!currentBranch) throw new Error("Release preparation requires a local branch");
         const account = githubAccount(root);
+        if (!account.canManage) {
+          throw new Error("Release preparation requires maintain or admin permission");
+        }
+        if (hasLocalReleaseTargets(root)) {
+          const localTools = missingLocalReleaseTools(root);
+          if (localTools.length > 0) {
+            throw new Error(`Local release candidate build requires: ${localTools.join(", ")}`);
+          }
+        }
         git(root, ["fetch", "--tags", "origin", opts.base]);
         const comparisonBase = resolveBaseVersion(root, [opts.prefix], {
           fetch: false,
@@ -470,7 +469,7 @@ program
           "",
           `Source commit: ${git(releaseRoot, ["rev-parse", `${releaseBranch}^`], { capture: true })}`,
           "",
-          "Merging this PR updates VERSION on main and starts the public release workflow.",
+          "Merging this PR updates VERSION on main and prepares a draft GitHub Release.",
           ...(releaseSummary ? ["", releaseSummary] : []),
         ].join("\n");
         const githubEnvironment = {
@@ -511,8 +510,6 @@ program
             env: githubEnvironment,
           });
         }
-        git(root, ["worktree", "remove", "--force", releaseRoot]);
-        git(root, ["branch", "--delete", "--force", releaseBranch]);
         if (opts.approve && opts.wait) {
           const mergeSha = await waitForPullRequestMerge(
             root,
@@ -521,10 +518,39 @@ program
             waitTimeoutMs,
           );
           logger.info("release pull request merged", { releaseBranch, mergeSha });
-          await waitForReleaseWorkflow(root, opts.base, mergeSha, githubEnvironment, waitTimeoutMs);
-          logger.success(`published ${releaseTag} from ${mergeSha}`);
+          git(root, ["fetch", "origin", opts.base]);
+          git(releaseRoot, ["switch", "--detach", mergeSha]);
+          runTaskCommand(releaseRoot, process.execPath, ["install"]);
+          const releaseCandidateScript = join(
+            releaseRoot,
+            "node_modules/@dbx-tools/projen/tasks/release-candidate.ts",
+          );
+          runTaskCommand(
+            releaseRoot,
+            process.execPath,
+            [
+              releaseCandidateScript,
+              "--root",
+              releaseRoot,
+              "--version",
+              next.version,
+              "--tag",
+              releaseTag,
+              "--sha",
+              mergeSha,
+              "--notes-file",
+              `docs/releases/v${next.version}.md`,
+              "--upload",
+            ],
+            { env: githubEnvironment },
+          );
+          git(root, ["worktree", "remove", "--force", releaseRoot]);
+          git(root, ["branch", "--delete", "--force", releaseBranch]);
+          logger.success(`prepared draft ${releaseTag} from ${mergeSha}`);
           return;
         }
+        git(root, ["worktree", "remove", "--force", releaseRoot]);
+        git(root, ["branch", "--delete", "--force", releaseBranch]);
         logger.success(
           `${
             opts.approve ? "enabled automatic merge for" : "opened"
@@ -534,4 +560,4 @@ program
     },
   );
 
-await program.parseAsync();
+if (import.meta.main) await program.parseAsync();

package/tasks/uniffi-python.js

@@ -5,6 +5,7 @@ import {
   mkdirSync,
   mkdtempSync,
   readFileSync,
+  readdirSync,
   rmSync,
   writeFileSync,
 } from "node:fs";
@@ -130,6 +131,7 @@ export const installPythonBindings = ({
   module,
   packageRoot,
   platform,
+  generatedSource,
   readonly = false,
   run,
   targetDirectory,
@@ -137,20 +139,25 @@ export const installPythonBindings = ({
   const packageName = module.split(".").at(-1);
   if (!packageName) throw new Error(`Invalid Python module ${module}`);
   const packageDirectory = resolve(packageRoot, "src", ...module.split("."));
-  const generatedDirectory = mkdtempSync(join(tmpdir(), `${packageName}-python-`));
+  const generatedDirectory = generatedSource
+    ? undefined
+    : mkdtempSync(join(tmpdir(), `${packageName}-python-`));
   const generator = resolve(targetDirectory, pythonBindingGeneratorName(crate, platform));
-  if (!existsSync(generator)) throw new Error(`Missing UniFFI generator ${generator}`);
 
   try {
-    run(
-      generator,
-      pythonBindingGeneratorArgs({
-        crate,
-        library,
-        output: generatedDirectory,
-      }),
-    );
-    const generated = join(generatedDirectory, `${crate.replaceAll("-", "_")}.py`);
+    if (!generatedSource) {
+      if (!existsSync(generator)) throw new Error(`Missing UniFFI generator ${generator}`);
+      run(
+        generator,
+        pythonBindingGeneratorArgs({
+          crate,
+          library,
+          output: generatedDirectory,
+        }),
+      );
+    }
+    const generated =
+      generatedSource ?? join(generatedDirectory, `${crate.replaceAll("-", "_")}.py`);
     if (!existsSync(generated)) throw new Error(`Missing generated binding ${generated}`);
     mkdirSync(packageDirectory, { recursive: true });
 
@@ -162,6 +169,11 @@ export const installPythonBindings = ({
     setWritable(init);
     writeFileSync(init, `${generatedHeader(crate)}from .bindings import *\n`);
 
+    for (const candidate of readdirSync(packageDirectory)) {
+      if (/\.(?:dll|dylib|so)$/.test(candidate)) {
+        rmSync(join(packageDirectory, candidate), { force: true });
+      }
+    }
     const nativeLibrary = join(packageDirectory, basename(library));
     setWritable(nativeLibrary);
     cpSync(library, nativeLibrary);
@@ -174,6 +186,6 @@ export const installPythonBindings = ({
     rmSync(join(packageDirectory, "_generated"), { recursive: true, force: true });
     return { bindings, init, library: nativeLibrary };
   } finally {
-    rmSync(generatedDirectory, { recursive: true, force: true });
+    if (generatedDirectory) rmSync(generatedDirectory, { recursive: true, force: true });
   }
 };

package/tasks/uniffi-release.mjs

@@ -17,7 +17,12 @@ import { fileURLToPath } from "node:url";
 import { createRequire } from "node:module";
 import { parseArgs } from "node:util";
 import { spawnSync } from "node:child_process";
-import { installPythonBindings, stampPythonProject } from "./uniffi-python.js";
+import {
+  installPythonBindings,
+  pythonBindingGeneratorArgs,
+  pythonBindingGeneratorName,
+  stampPythonProject,
+} from "./uniffi-python.js";
 
 const require = createRequire(import.meta.url);
 const bundledToml = fileURLToPath(new URL("./smol-toml.cjs", import.meta.url));
@@ -34,7 +39,9 @@ const parsed = parseArgs({
     "native-package": { type: "string" },
     "python-package": { type: "string" },
     "python-module": { type: "string" },
+    "python-bindings": { type: "string" },
     "cargo-target": { type: "string" },
+    "generator-target": { type: "string" },
     "node-triple": { type: "string" },
     "python-tag": { type: "string" },
     os: { type: "string" },
@@ -414,8 +421,10 @@ const packagePython = ({
   pythonTag,
   version,
   cargoTarget,
+  generatorTarget,
   os,
   pythonModule,
+  pythonBindings,
 }) => {
   const pythonRoot = resolve(output, "python-root");
   cpSync(resolve(root, pythonDirectory), pythonRoot, { recursive: true });
@@ -442,8 +451,9 @@ const packagePython = ({
     module: pythonModule,
     packageRoot: pythonRoot,
     platform: os,
+    generatedSource: pythonBindings,
     run,
-    targetDirectory: resolve(cargoTargetRoot, cargoTarget, "release"),
+    targetDirectory: resolve(cargoTargetRoot, generatorTarget ?? cargoTarget, "release"),
   });
 
   const wheelDirectory = resolve(output, "python");
@@ -463,6 +473,25 @@ const packagePython = ({
   ]);
 };
 
+const generatePython = () => {
+  const crate = required("crate");
+  const cargoTarget = required("cargo-target");
+  const os = required("os");
+  const output = resolve(root, required("output"));
+  const generator = resolve(
+    cargoTargetRoot,
+    cargoTarget,
+    "release",
+    pythonBindingGeneratorName(crate, os),
+  );
+  const library = libraryPath(crate, cargoTarget, os);
+  if (!existsSync(generator)) throw new Error(`Missing UniFFI generator ${generator}`);
+  if (!existsSync(library)) throw new Error(`Missing native library ${library}`);
+  rmSync(output, { recursive: true, force: true });
+  mkdirSync(output, { recursive: true });
+  run(generator, pythonBindingGeneratorArgs({ crate, library, output }));
+};
+
 const build = () => {
   const crate = required("crate");
   const cargoTarget = required("cargo-target");
@@ -517,14 +546,18 @@ const build = () => {
       pythonTag,
       version,
       cargoTarget,
+      generatorTarget: parsed.values["generator-target"],
       os,
       pythonModule: required("python-module"),
+      pythonBindings: parsed.values["python-bindings"],
     });
   }
 };
 
 if (parsed.positionals[0] === "build") {
   build();
+} else if (parsed.positionals[0] === "generate-python") {
+  generatePython();
 } else if (parsed.positionals[0] === "facade") {
   packageNodeFacade({
     output: resolve(root, required("output")),