@dbx-tools/projen 0.9.149 → 0.9.151

package/README.md

@@ -542,10 +542,11 @@ 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 completes local publication and demo deployment first, then waits for
-this workflow by default. It preserves the live checklist through a scroll-safe
-non-TTY stream and prints the final 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.
+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

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.149";
+export const PACKAGE_VERSION = "0.9.151";
 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.149",
-    "@dbx-tools/core": "^0.9.149",
-    "@dbx-tools/path": "^0.9.149",
-    "@dbx-tools/shared-core": "^0.9.149",
+    "@dbx-tools/cli-args": "^0.9.151",
+    "@dbx-tools/core": "^0.9.151",
+    "@dbx-tools/path": "^0.9.151",
+    "@dbx-tools/shared-core": "^0.9.151",
     "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.149",
+  "version": "0.9.151",
   "types": "index.ts",
   "type": "module",
   "exports": {

package/src/_task-command.ts

@@ -61,31 +61,6 @@ export function spawnTaskCommand(
   });
 }
 
-/**
- * Run a command with piped stdout forwarded line-by-line.
- *
- * The child sees a non-TTY output stream, so interactive redraw commands fall
- * back to append-only output while the parent still receives live progress.
- */
-export async function streamTaskCommand(
-  cwd: string,
-  command: string,
-  args: readonly string[],
-  options: TaskCommandOptions = {},
-): Promise<void> {
-  await exec.spawn(executable(command), [...args], {
-    cwd,
-    env: options.env,
-    stdout: {
-      capture: false,
-      onLine: (line) => console.log(line),
-    },
-    stderr: options.stderr ?? "inherit",
-    stdin: "ignore",
-    check: true,
-  });
-}
-
 /** Capture trimmed stdout, optionally throwing when the command fails. */
 export function captureTaskCommand(
   cwd: string,

package/tasks/release.ts

@@ -11,12 +11,7 @@ import { publishLocalRelease } from "./local-publish.ts";
 import { TaskDirectoriesOptionSchema, TaskRootOptionSchema } from "./options.ts";
 import { writeReleaseNotes } from "./release-notes.ts";
 import { assertReleaseVersion } from "./release-version.ts";
-import {
-  captureTaskCommand,
-  runTaskCommand,
-  streamTaskCommand,
-  taskCommandSucceeds,
-} from "../src/_task-command.ts";
+import { captureTaskCommand, runTaskCommand, taskCommandSucceeds } from "../src/_task-command.ts";
 import { RELEASE_WORKFLOW_FILE } from "../src/release-context.ts";
 import {
   RELEASE_INSTALL_MODES,
@@ -43,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;
@@ -68,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 },
@@ -139,26 +216,39 @@ export async function watchReleaseGithubActions(
     url: run.url,
   });
   try {
-    await streamTaskCommand(
-      root,
-      "gh",
-      [
-        "run",
-        "watch",
-        String(run.databaseId),
-        "--repo",
-        repository,
-        "--interval",
-        String(Math.max(1, Math.round(pollIntervalMs / 1_000))),
-      ],
-      { env: { ...account.env, NO_COLOR: "1" } },
-    );
-    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),