@dbx-tools/projen 0.9.146 → 0.9.150

package/README.md

@@ -316,14 +316,14 @@ scripts, and generated files on top.
 Every workspace root exposes a generic development watcher:
 
 ```bash
-bun run dev:watch [--debounce-ms 15000] [--restart-key r] <command> [args...]
+bun run dev:watch <command> [args...]
 ```
 
-It restarts after watched writes have been quiet for 15 seconds. Command paths,
-`--cwd`, and `--filter` identify the owning package. Its transitive workspace
+It restarts after watched writes have been quiet for 15 seconds. Command paths
+and task selectors identify the owning package. Its transitive workspace
 dependencies are watched with the shared generated/dependency/test/temp ignores.
-Press the configured key for an immediate restart. The demo uses this task to
-run its concrete server entrypoint. The `server` tag does not assume one.
+The configured restart key triggers an immediate restart. The demo uses this
+task to run its concrete server entrypoint. The `server` tag does not assume one.
 
 AppKit 0.81's `appkitServerConfig()` is the preferred tsdown preset for a
 consumer app using conventional compiled `server/agents/*/agent.ts` entries. It
@@ -541,10 +541,12 @@ diverged. From `main`, it calls the existing `bump` task, commits the generated
 version changes, pushes `main`, and pushes the matching annotated `vX.Y.Z` tag.
 Pass `--no-bump` only to release an existing synchronized local bump. The tag
 workflow verifies that the tag points at the exact `origin/main` commit. The
-local task waits for this workflow by default, displays live job and step
-progress, then prints its logs. Local-only releases and repositories without a
-resolved authenticated GitHub account skip the watcher. Stopping the local
-watcher does not cancel the remote run.
+local task completes local publication and demo deployment first, then waits for
+this workflow by default. It prints the initial job and step state, then only
+append-only status changes, without annotations. Successful runs omit full logs;
+unsuccessful runs print failed-step logs only. Local-only releases and
+repositories without a resolved authenticated GitHub account skip the watcher.
+Stopping the local watcher does not cancel the remote run.
 
 One `build-release` job installs workspace dependencies, runs validation, packs
 the npm archives, builds all Python distributions, and builds the documentation
@@ -556,7 +558,9 @@ workspace. Each Python package retains its own publishing environment and waits
 for its package dependencies to publish. The npm job uses the bundled archive
 publisher without a checkout or workspace install. Pages deploys the already
 built site after registry publication succeeds. Local npm and Python registry publication remains available
-through the direct local publication tooling.
+through the direct local publication tooling. Those local publishers run
+concurrently; a failure or release termination stops every live publisher before
+the command returns.
 
 The default release publishes npm, Python, and docs, then publishes to
 configured local registries. Use `bun run release --help` or the generated
@@ -658,8 +662,8 @@ release [options]
 | `--no-docs`                            | Disable build and deploy documentation                                                                                                                            |
 | `--validation`                         | Run optional release validation tasks before publishing (default: true, env: PROJEN_RELEASE_VALIDATION)                                                           |
 | `--no-validation`                      | Disable run optional release validation tasks before publishing                                                                                                   |
-| `-w, --watch-github-actions`           | Wait for and stream the tag-triggered GitHub Actions release (default: true, env: PROJEN_RELEASE_WATCH_GITHUB_ACTIONS)                                            |
-| `--no-watch-github-actions`            | Disable wait for and stream the tag-triggered github actions release                                                                                              |
+| `-w, --watch-github-actions`           | Wait for and log the tag-triggered GitHub Actions release (default: true, env: PROJEN_RELEASE_WATCH_GITHUB_ACTIONS)                                               |
+| `--no-watch-github-actions`            | Disable wait for and log the tag-triggered github actions release                                                                                                 |
 | `--release-notes`                      | Generate and commit release notes for a new version bump (default: true, env: PROJEN_RELEASE_RELEASE_NOTES)                                                       |
 | `--no-release-notes`                   | Disable generate and commit release notes for a new version bump                                                                                                  |
 | `--release-notes-text <value>`         | Write supplied release-note Markdown without invoking Genie (env: PROJEN_RELEASE_RELEASE_NOTES_TEXT)                                                              |

package/index.ts

@@ -3,7 +3,7 @@
 // Hand edits are overwritten on the next watch; this file is read-only.
 
 export const PACKAGE_IDENTIFIER = "@dbx-tools/projen";
-export const PACKAGE_VERSION = "0.9.146";
+export const PACKAGE_VERSION = "0.9.150";
 export * as barrels from "./src/barrels.ts";
 export * as bunApp from "./src/bun-app.ts";
 export * as bunWorkflow from "./src/bun-workflow.ts";

package/package.json

@@ -30,10 +30,10 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.7.0",
-    "@dbx-tools/cli-args": "^0.9.146",
-    "@dbx-tools/core": "^0.9.146",
-    "@dbx-tools/path": "^0.9.146",
-    "@dbx-tools/shared-core": "^0.9.146",
+    "@dbx-tools/cli-args": "^0.9.150",
+    "@dbx-tools/core": "^0.9.150",
+    "@dbx-tools/path": "^0.9.150",
+    "@dbx-tools/shared-core": "^0.9.150",
     "commander": "^15.0.0",
     "concurrently": "^10.0.3",
     "constructs": "^10.6.0",
@@ -55,7 +55,7 @@
   },
   "main": "index.ts",
   "license": "Apache-2.0",
-  "version": "0.9.146",
+  "version": "0.9.150",
   "types": "index.ts",
   "type": "module",
   "exports": {

package/src/_task-command.ts

@@ -40,7 +40,17 @@ export async function runTaskCommandAsync(
   args: readonly string[],
   options: TaskCommandOptions & { readonly signal?: AbortSignal } = {},
 ): Promise<void> {
-  await exec.spawn(executable(command), [...args], {
+  await spawnTaskCommand(cwd, command, args, options);
+}
+
+/** Start one supervised task command and return its live process handle. */
+export function spawnTaskCommand(
+  cwd: string,
+  command: string,
+  args: readonly string[],
+  options: TaskCommandOptions & { readonly signal?: AbortSignal } = {},
+): exec.ChildProcessResult {
+  return exec.spawn(executable(command), [...args], {
     cwd,
     env: options.env,
     stdout: "inherit",

package/tasks/local-publish.ts

@@ -1,10 +1,11 @@
 /** Build and publish the current workspace to configured loopback registries. */
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import type { ChildProcessResult } from "@dbx-tools/core/exec";
 import * as projectUtils from "@dbx-tools/core/project-utils";
 import { log, net } from "@dbx-tools/shared-core";
 import { activePythonIndexes, resolveLocalPypi } from "./python-registry.ts";
-import { runTaskCommandAsync } from "../src/_task-command.ts";
+import { spawnTaskCommand } from "../src/_task-command.ts";
 
 const logger = log.logger("projen:local-publish");
 
@@ -38,6 +39,24 @@ export function localPublishTaskPath(task: "publish.ts" | "publish-python.ts"):
   return fileURLToPath(new URL(task, import.meta.url));
 }
 
+/** Await concurrent publishers and terminate every live sibling after one fails. */
+export async function awaitLocalPublishers(
+  publishes: readonly ChildProcessResult[],
+): Promise<void> {
+  try {
+    await Promise.all(publishes);
+  } catch (error) {
+    await Promise.all(
+      publishes.map((publish) =>
+        publish.exitCode === null && publish.signalCode === null
+          ? publish.shutdown()
+          : Promise.resolve(),
+      ),
+    );
+    throw error;
+  }
+}
+
 /** Build and publish the current workspace directly to local registries. */
 export async function publishLocalRelease(
   options: LocalPublishOptions,
@@ -46,7 +65,7 @@ export async function publishLocalRelease(
   const localRegistry = resolveLocalRegistry(options.localRegistry);
   const activeIndexes = activePythonIndexes();
   const localPypi = resolveLocalPypi(options.localPypi, activeIndexes);
-  const publishes: Promise<unknown>[] = [];
+  const publishes: ChildProcessResult[] = [];
 
   if (
     options.localPypi.toLowerCase() === "auto" &&
@@ -62,7 +81,7 @@ export async function publishLocalRelease(
     const publishNpmScript = localPublishTaskPath("publish.ts");
     logger.info(`building and publishing npm workspace to ${localRegistry}`);
     publishes.push(
-      runTaskCommandAsync(root, process.execPath, [
+      spawnTaskCommand(root, process.execPath, [
         publishNpmScript,
         options.version,
         "--registry",
@@ -75,7 +94,7 @@ export async function publishLocalRelease(
     const publishPythonScript = localPublishTaskPath("publish-python.ts");
     logger.info(`building and publishing Python workspace to ${localPypi.publishUrl}`);
     publishes.push(
-      runTaskCommandAsync(root, process.execPath, [
+      spawnTaskCommand(root, process.execPath, [
         publishPythonScript,
         options.version,
         "--root",
@@ -93,7 +112,7 @@ export async function publishLocalRelease(
     return { npm: false, python: false };
   }
 
-  await Promise.all(publishes);
+  await awaitLocalPublishers(publishes);
   logger.success(`published local workspace ${options.version}`);
   return { npm: Boolean(localRegistry), python: Boolean(localPypi) };
 }

package/tasks/release.ts

@@ -38,6 +38,33 @@ const GithubReleaseRunSchema = z
   })
   .passthrough();
 
+const GithubReleaseStepSchema = z
+  .object({
+    name: z.string(),
+    number: z.number().int(),
+    status: z.string(),
+    conclusion: z.string().nullable().optional(),
+  })
+  .passthrough();
+
+const GithubReleaseJobSchema = z
+  .object({
+    databaseId: z.number().int().positive(),
+    name: z.string(),
+    status: z.string(),
+    conclusion: z.string().nullable().optional(),
+    steps: z.array(GithubReleaseStepSchema),
+  })
+  .passthrough();
+
+const GithubReleaseRunViewSchema = z
+  .object({
+    status: z.string(),
+    conclusion: z.string().nullable().optional(),
+    jobs: z.array(GithubReleaseJobSchema),
+  })
+  .passthrough();
+
 /** Inputs required to locate and watch one tag-triggered release workflow. */
 export interface WatchReleaseGithubActionsOptions {
   readonly account: projectUtils.ProjectGhAccount;
@@ -63,6 +90,61 @@ function delay(milliseconds: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
 
+interface GithubProgressEntry {
+  readonly conclusion?: string | null;
+  readonly key: string;
+  readonly label: string;
+  readonly status: string;
+}
+
+function githubProgressEntries(
+  run: z.infer<typeof GithubReleaseRunViewSchema>,
+): GithubProgressEntry[] {
+  return [
+    {
+      key: "run",
+      label: "release",
+      status: run.status,
+      conclusion: run.conclusion,
+    },
+    ...run.jobs.flatMap((job) => [
+      {
+        key: `job:${job.databaseId}`,
+        label: job.name,
+        status: job.status,
+        conclusion: job.conclusion,
+      },
+      ...job.steps.map((step) => ({
+        key: `job:${job.databaseId}:step:${step.number}`,
+        label: `${job.name} / ${step.name}`,
+        status: step.status,
+        conclusion: step.conclusion,
+      })),
+    ]),
+  ];
+}
+
+function githubProgressMarker(entry: GithubProgressEntry): string {
+  if (entry.status === "completed") {
+    if (entry.conclusion === "success") return "[done]";
+    if (entry.conclusion === "skipped") return "[skip]";
+    return "[fail]";
+  }
+  return entry.status === "in_progress" ? "[run]" : "[wait]";
+}
+
+function reportGithubProgress(
+  run: z.infer<typeof GithubReleaseRunViewSchema>,
+  previous: Map<string, string>,
+): void {
+  for (const entry of githubProgressEntries(run)) {
+    const state = `${entry.status}:${entry.conclusion ?? ""}`;
+    if (previous.get(entry.key) === state) continue;
+    previous.set(entry.key, state);
+    logger.info(`${githubProgressMarker(entry)} ${entry.label}`);
+  }
+}
+
 /** Whether this release selection has remote work worth watching. */
 export function shouldWatchReleaseGithubActions(
   options: Pick<ReleaseSelectionOptions, "publish"> & { readonly watchGithubActions?: boolean },
@@ -134,18 +216,39 @@ export async function watchReleaseGithubActions(
     url: run.url,
   });
   try {
-    runTaskCommand(
-      root,
-      "gh",
-      ["run", "watch", String(run.databaseId), "--repo", repository, "--interval", "3"],
-      { env: account.env },
-    );
-    runTaskCommand(
-      root,
-      "gh",
-      ["run", "view", String(run.databaseId), "--repo", repository, "--log"],
-      { env: account.env },
-    );
+    const progress = new Map<string, string>();
+    let completed = false;
+    let conclusion: string | null | undefined;
+    while (!completed) {
+      const output = captureTaskCommand(
+        root,
+        "gh",
+        [
+          "run",
+          "view",
+          String(run.databaseId),
+          "--repo",
+          repository,
+          "--json",
+          "status,conclusion,jobs",
+        ],
+        { check: true, env: account.env, stderr: "inherit" },
+      );
+      const parsed = GithubReleaseRunViewSchema.safeParse(json.parse(output));
+      if (!parsed.success) throw new Error("GitHub returned invalid release progress metadata");
+      reportGithubProgress(parsed.data, progress);
+      completed = parsed.data.status === "completed";
+      conclusion = parsed.data.conclusion;
+      if (!completed) await delay(pollIntervalMs);
+    }
+    if (conclusion !== "success" && conclusion !== "skipped") {
+      runTaskCommand(
+        root,
+        "gh",
+        ["run", "view", String(run.databaseId), "--repo", repository, "--log-failed"],
+        { env: account.env },
+      );
+    }
   } catch (error) {
     logger.warn("GitHub Actions release watch stopped; the remote run was not cancelled", {
       error: errorUtils.toError(error),
@@ -374,9 +477,10 @@ export async function runRelease(
     /** Path to complete release notes supplied instead of invoking Genie. */
     readonly releaseNotesFile?: string;
     readonly writeReleaseNotes?: typeof writeReleaseNotes;
-    /** Wait for and stream a matching tag-triggered GitHub Actions run. */
+    /** After local release actions, wait for and stream the matching GitHub Actions run. */
     readonly watchGithubActions?: boolean;
     readonly githubActionsWatcher?: ReleaseGithubActionsWatcher;
+    readonly resolveGithubAccount?: typeof projectUtils.resolveProjectGhAccount;
   },
 ): Promise<string> {
   const { branch, prefix, remote, root } = options;
@@ -480,23 +584,6 @@ export async function runRelease(
   }
   logger.success(`released ${tag}`, { sha: head });
 
-  if (shouldWatchReleaseGithubActions(options, selection)) {
-    const account = projectUtils.resolveProjectGhAccount(root, { remote });
-    if (account) {
-      await (options.githubActionsWatcher ?? watchReleaseGithubActions)({
-        account,
-        head,
-        root,
-        tag,
-      });
-    } else {
-      logger.info("skipping GitHub Actions release watch: no authenticated account", {
-        remote,
-        tag,
-      });
-    }
-  }
-
   // Restore local deploys: when a non-standard (loopback) npm or uv registry is
   // configured, publish the freshly tagged version to it directly. Detection and
   // publishing are owned by local-publish.ts; this no-ops on standard registries.
@@ -518,6 +605,25 @@ export async function runRelease(
     ]);
   }
 
+  if (shouldWatchReleaseGithubActions(options, selection)) {
+    const account = (options.resolveGithubAccount ?? projectUtils.resolveProjectGhAccount)(root, {
+      remote,
+    });
+    if (account) {
+      await (options.githubActionsWatcher ?? watchReleaseGithubActions)({
+        account,
+        head,
+        root,
+        tag,
+      });
+    } else {
+      logger.info("skipping GitHub Actions release watch: no authenticated account", {
+        remote,
+        tag,
+      });
+    }
+  }
+
   return tag;
 }
 
@@ -552,7 +658,7 @@ export const ReleaseOptionsSchema = z.object({
   watchGithubActions: z
     .boolean()
     .default(true)
-    .describe("Wait for and stream the tag-triggered GitHub Actions release"),
+    .describe("Wait for and log the tag-triggered GitHub Actions release"),
   releaseNotes: z
     .boolean()
     .default(true)