ConnectionMaster
diff --git a/‎ddev/changelog.d/23722.added‎
Lines changed: 1 addition & 0 deletions b/‎ddev/changelog.d/23722.added‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎ddev/src/ddev/cli/ci/tests/task_test_runner.py‎
Lines changed: 6 additions & 1 deletion b/‎ddev/src/ddev/cli/ci/tests/task_test_runner.py‎
Lines changed: 6 additions & 1 deletion
diff --git a/‎ddev/src/ddev/cli/release/__init__.py‎
Lines changed: 2 additions & 0 deletions b/‎ddev/src/ddev/cli/release/__init__.py‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎ddev/src/ddev/cli/release/port_commit_workflow.py‎
Lines changed: 8 additions & 15 deletions b/‎ddev/src/ddev/cli/release/port_commit_workflow.py‎
Lines changed: 8 additions & 15 deletions
diff --git a/‎ddev/src/ddev/cli/release/test_agent/__init__.py‎
Lines changed: 170 additions & 0 deletions b/‎ddev/src/ddev/cli/release/test_agent/__init__.py‎
Lines changed: 170 additions & 0 deletions
diff --git a/‎ddev/src/ddev/cli/release/test_agent/dispatch.py‎
Lines changed: 104 additions & 0 deletions b/‎ddev/src/ddev/cli/release/test_agent/dispatch.py‎
Lines changed: 104 additions & 0 deletions
@@ -0,0 +1 @@
+Add `ddev release test-agent` command that dispatches the Linux and Windows Agent test workflows against a release branch or tag.
@@ -63,7 +63,12 @@ async def process_message(self, message: TestBatch) -> None:
         log_extra: dict[str, Any] = {"batch_id": message.id}
 
         dispatch = await self._client.create_workflow_dispatch(
-            self._options.owner, self._options.repo, self._options.workflow_id, ref=self._options.ref, inputs=inputs
+            self._options.owner,
+            self._options.repo,
+            self._options.workflow_id,
+            ref=self._options.ref,
+            inputs=inputs,
+            return_run_details=True,
         )
         run_id = dispatch.data.workflow_run_id
         log_extra["run_id"] = run_id
 
@@ -14,6 +14,7 @@
 from ddev.cli.release.port_commit import port_commit
 from ddev.cli.release.show import show
 from ddev.cli.release.stats import stats
+from ddev.cli.release.test_agent import test_agent
 
 
 @click.group(short_help='Manage the release of integrations')
@@ -33,4 +34,5 @@ def release():
 release.add_command(show)
 release.add_command(stats)
 release.add_command(tag)
+release.add_command(test_agent)
 release.add_command(upload)
@@ -695,7 +695,7 @@ def resolve_port_plan(
         dry_run=dry_run,
     )
 
-    app.output(_format_plan_summary(plan), stderr=True)
+    app.output(_format_plan_summary(app, plan), stderr=True)
 
     if not dry_run and not click.confirm('Continue?'):
         app.abort('Did not get confirmation, aborting.')
@@ -705,7 +705,6 @@ def resolve_port_plan(
 
 def display_completion_summary(app: Application, plan: PortPlan, *, pr_url: str | None) -> None:
     """Print a panel summarising the port outcome."""
-    text = Text()
     rows: list[tuple[str, str]] = [
         ('Commit', f'{plan.full_sha[:10]} - {plan.clean_subject}'),
         ('Target', plan.target_branch),
@@ -714,17 +713,13 @@ def display_completion_summary(app: Application, plan: PortPlan, *, pr_url: str
     if pr_url is not None:
         rows.append(('Pull request', pr_url))
 
-    label_width = max(len(label) for label, _ in rows)
-    for i, (label, value) in enumerate(rows):
-        if i:
-            text.append('\n')
-        text.append(f'{label}:'.ljust(label_width + 2), style='bold')
-        text.append(value)
-
-    app.output(Panel(text, title='Backport completed', title_align='left', border_style='cyan'), stderr=True)
+    app.output(
+        Panel(app.labeled_lines(rows), title='Backport completed', title_align='left', border_style='cyan'),
+        stderr=True,
+    )
 
 
-def _format_plan_summary(plan: PortPlan) -> Text:
+def _format_plan_summary(app: Application, plan: PortPlan) -> Text:
     text = Text()
     text.append('Configuration:', style='bold')
 
@@ -739,10 +734,8 @@ def _format_plan_summary(plan: PortPlan) -> Text:
         ('Verify commit', str(plan.verify)),
         ('Dry run', str(plan.dry_run)),
     ]
-    for label, value in rows:
-        text.append('\n  ')
-        text.append(f'{label}:', style='bold')
-        text.append(f' {value}')
+    text.append('\n')
+    text.append_text(app.labeled_lines(rows, indent='  ', align=False))
     return text
 
 
 
@@ -0,0 +1,170 @@
+# (C) Datadog, Inc. 2026-present
+# All rights reserved
+# Licensed under a 3-clause BSD style license (see LICENSE)
+"""`ddev release test-agent` — dispatch the Linux + Windows Agent test workflows.
+
+The orchestration body lives here so the file reads top-to-bottom as the command's story.
+Each step delegates to a sibling module (`validation`, `images`, `dispatch`), and every
+helper module is imported lazily inside the function body so `ddev --help` only pays for
+`click` from this package.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import click
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from ddev.cli.application import Application
+    from ddev.cli.release.test_agent.dispatch import DispatchedWorkflow
+
+
+@click.command('test-agent', short_help='Dispatch the Agent test workflows against a branch or tag')
+@click.option('--branch', help='Release branch to test, e.g. `7.80.x`.')
+@click.option('--tag', help='Agent release tag to test, e.g. `7.80.0-rc.1` or `7.80.0`.')
+@click.option('--dry-run', is_flag=True, help='Resolve images and print the plan without dispatching.')
+@click.option('--monitor', is_flag=True, help='Monitor dispatched workflow jobs until both workflows finish.')
+@click.option(
+    '--poll-interval',
+    type=click.FloatRange(min=1.0),
+    default=10.0,
+    show_default=True,
+    help='Seconds between workflow monitor polls.',
+)
+@click.option('--yes', '-y', is_flag=True, help='Skip the interactive confirmation prompt.')
+@click.pass_obj
+def test_agent(
+    app: Application,
+    branch: str | None,
+    tag: str | None,
+    dry_run: bool,
+    monitor: bool,
+    poll_interval: float,
+    yes: bool,
+) -> None:
+    """Trigger `test-agent.yml` and `test-agent-windows.yml` against the resolved Agent image.
+
+    Exactly one of `--branch` or `--tag` must be provided. When `--branch` is given, the latest
+    `MAJ.MIN.PATCH-rc.N` published to `registry.datadoghq.com/agent` is used as the Agent image.
+    When `--tag` is given, that exact tag is used. Linux and Windows (servercore) variants are
+    both validated against the registry before either workflow is dispatched.
+    """
+    import logging
+
+    from ddev.cli.release.test_agent.dispatch import dispatch_both
+    from ddev.cli.release.test_agent.images import build_image_refs, resolve_version, validate_images_exist
+    from ddev.cli.release.test_agent.validation import (
+        Branch,
+        fetch_target,
+        validate_input,
+        verify_workflows_present_on_ref,
+    )
+
+    logging.getLogger('httpx').setLevel(logging.WARNING)
+
+    target = validate_input(app, branch, tag)
+
+    if not app.config.github.token:
+        app.abort('GitHub token required. Set `github.token` via `ddev config set github.token <token>`.')
+
+    fetch_target(app, target)
+    verify_workflows_present_on_ref(app, target)
+    app.display_info('')
+
+    version = resolve_version(app, target)
+    app.display_info('')
+
+    validate_images_exist(app, version)
+    linux_image, windows_image = build_image_refs(version)
+    app.display_info('')
+
+    # GitHub's workflow_dispatch API expects every value in `inputs` to be a string, even for
+    # `type: boolean` workflow inputs — booleans are parsed from the lowercase string form.
+    # `test-py2='false'` is sent to both dispatches by design: this command is forward-looking
+    # and tests Python 3 only, even on Windows (where `test-agent-windows.yml` defaults
+    # `test-py2` to `true` for legacy reasons).
+    inputs: dict[str, str] = {
+        'test-py3': 'true',
+        'test-py2': 'false',
+        'agent-image': linux_image,
+        'agent-image-windows': windows_image,
+    }
+    is_branch = isinstance(target, Branch)
+    _print_plan(app, ref=target.name, version=version, is_branch=is_branch, inputs=inputs)
+    app.display_info('')
+
+    if dry_run:
+        app.display_info('Dry run — no workflows dispatched.')
+        return
+
+    if not yes and not click.confirm('Dispatch both workflows?', default=False):
+        app.abort('Aborted by user.')
+
+    try:
+        workflows = dispatch_both(app.config.github.token, ref=target.name, inputs=inputs)
+    except RuntimeError as e:
+        app.abort(str(e))
+    else:
+        if not monitor:
+            app.display_info('')
+            _print_result(app, workflows=workflows)
+
+    if monitor:
+        from ddev.cli.release.test_agent.monitoring import monitor_dispatched_workflows
+
+        try:
+            monitor_dispatched_workflows(
+                app,
+                app.config.github.token,
+                ref=target.name,
+                workflows=workflows,
+                poll_interval=poll_interval,
+            )
+        except Exception as e:
+            urls = ', '.join(w.html_url for w in workflows)
+            app.abort(f'Failed to monitor workflows: {e}. Runs are still in flight: {urls}')
+
+
+def _print_plan(
+    app: Application,
+    *,
+    ref: str,
+    version: str,
+    is_branch: bool,
+    inputs: dict[str, str],
+) -> None:
+    """Render the resolved dispatch plan via the stderr-bound `display_info` channel.
+
+    All progress lines (`display_waiting`/`display_success`) default to stderr; keeping the
+    plan on the same channel means piping the command into a file leaves stdout clean and
+    keeps the whole pre-dispatch narrative coherent on stderr.
+    """
+    from rich.panel import Panel
+
+    from ddev.cli.release.test_agent.validation import WORKFLOW_LINUX, WORKFLOW_WINDOWS
+
+    rows: list[tuple[str, str]] = [
+        ('Workflows', f'{WORKFLOW_LINUX}, {WORKFLOW_WINDOWS}'),
+        ('Ref', ref),
+    ]
+    if is_branch:
+        rows.append(('Resolved RC', version))
+    rows.extend(inputs.items())
+
+    app.output(
+        Panel(app.labeled_lines(rows), title='Dispatch plan', title_align='left', border_style='cyan'), stderr=True
+    )
+
+
+def _print_result(app: Application, *, workflows: Sequence[DispatchedWorkflow]) -> None:
+    """Render the two run URLs in a rich Panel, matching the look of `ddev release port-commit`."""
+    from rich.panel import Panel
+
+    rows = [(workflow.label, workflow.html_url) for workflow in workflows]
+    app.output(
+        Panel(app.labeled_lines(rows), title='Workflows dispatched', title_align='left', border_style='cyan'),
+        stderr=True,
+    )
@@ -0,0 +1,104 @@
+# (C) Datadog, Inc. 2026-present
+# All rights reserved
+# Licensed under a 3-clause BSD style license (see LICENSE)
+"""Parallel `workflow_dispatch` orchestration for `ddev release test-agent`."""
+
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from ddev.cli.release.test_agent.validation import REPO_NAME, REPO_OWNER, WORKFLOW_LINUX, WORKFLOW_WINDOWS
+
+if TYPE_CHECKING:
+    from ddev.utils.github_async import GitHubResponse
+    from ddev.utils.github_async.models import WorkflowDispatchResult
+
+type DispatchOutcome = GitHubResponse[WorkflowDispatchResult] | BaseException
+
+
+@dataclass(frozen=True)
+class DispatchedWorkflow:
+    """A workflow run created by `ddev release test-agent`."""
+
+    label: str
+    workflow_id: str
+    run_id: int
+    html_url: str
+
+
+def dispatch_both(token: str, *, ref: str, inputs: dict[str, str]) -> tuple[DispatchedWorkflow, DispatchedWorkflow]:
+    """Dispatch both workflows in parallel via the async GitHub client."""
+    from ddev.utils.github_async import async_github_client
+
+    async def run_dispatches() -> tuple[DispatchOutcome, DispatchOutcome]:
+        async with async_github_client(token=token) as client:
+            return await asyncio.gather(
+                client.create_workflow_dispatch(
+                    owner=REPO_OWNER,
+                    repo=REPO_NAME,
+                    workflow_id=WORKFLOW_LINUX,
+                    ref=ref,
+                    inputs=inputs,
+                    return_run_details=True,
+                ),
+                client.create_workflow_dispatch(
+                    owner=REPO_OWNER,
+                    repo=REPO_NAME,
+                    workflow_id=WORKFLOW_WINDOWS,
+                    ref=ref,
+                    inputs=inputs,
+                    return_run_details=True,
+                ),
+                return_exceptions=True,
+            )
+
+    return extract_dispatched_workflows(asyncio.run(run_dispatches()))
+
+
+def extract_dispatched_workflows(
+    results: tuple[DispatchOutcome, DispatchOutcome],
+) -> tuple[DispatchedWorkflow, DispatchedWorkflow]:
+    """Pull workflow runs out of two gather results, raising on any exception with a partial-success hint.
+
+    `asyncio.gather(return_exceptions=True)` captures `CancelledError`/`KeyboardInterrupt`
+    (`BaseException` subclasses, not `Exception`) into its result list. Re-raise those first
+    so flow-control exceptions propagate cleanly instead of being wrapped in `RuntimeError`.
+    """
+    linux_result, windows_result = results
+
+    for result in (linux_result, windows_result):
+        if isinstance(result, BaseException) and not isinstance(result, Exception):
+            raise result
+
+    if isinstance(linux_result, BaseException):
+        if isinstance(windows_result, BaseException):
+            raise RuntimeError(
+                f'Both dispatches failed. Linux: {linux_result!r}. Windows: {windows_result!r}.'
+            ) from linux_result
+        sibling = windows_result.data.html_url
+        raise RuntimeError(
+            f'Linux dispatch failed: {linux_result}. The other workflow was dispatched at {sibling}.'
+        ) from linux_result
+
+    if isinstance(windows_result, BaseException):
+        sibling = linux_result.data.html_url
+        raise RuntimeError(
+            f'Windows dispatch failed: {windows_result}. The other workflow was dispatched at {sibling}.'
+        ) from windows_result
+
+    return (
+        DispatchedWorkflow(
+            label='Linux',
+            workflow_id=WORKFLOW_LINUX,
+            run_id=linux_result.data.workflow_run_id,
+            html_url=linux_result.data.html_url,
+        ),
+        DispatchedWorkflow(
+            label='Windows',
+            workflow_id=WORKFLOW_WINDOWS,
+            run_id=windows_result.data.workflow_run_id,
+            html_url=windows_result.data.html_url,
+        ),
+    )
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	+Add `ddev release test-agent` command that dispatches the Linux and Windows Agent test workflows against a release branch or tag.