minitest-cli 0.31.0__tar.gz → 0.32.0__tar.gz

{minitest_cli-0.31.0 → minitest_cli-0.32.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: minitest-cli
-Version: 0.31.0
+Version: 0.32.0
 Summary: Minitest CLI – command-line interface for the Minitest testing platform
 Project-URL: Homepage, https://minitap.ai/
 Project-URL: Source, https://github.com/minitap-ai/minitest-cli
@@ -111,6 +111,32 @@ minitest --app <app-id> run all --web
 minitest --app <app-id> run all --ios-build <ios-build-id> --android-build <android-build-id>
 ```
 
+## Native cloud tablets
+
+Native lanes default to phones. Use `--ios-device-type phone|tablet` or
+`--android-device-type phone|tablet` on `run start` (including `--tag`), `run all`,
+or `run from-commit` to configure an already selected native cloud lane:
+
+```bash
+minitest --app <app-id> run all --ios-build <ios-build-id> --ios-device-type tablet
+minitest --app <app-id> run start --tag smoke --android-build <android-build-id> --android-device-type tablet
+minitest --app <app-id> run from-commit <full-sha> --platform ios --ios-device-type tablet
+```
+
+The device-type options do not select an OS: `start`/`all` still need the
+corresponding build flag; `from-commit` uses `--platform` (or its existing iOS +
+Android default). An explicit device type, even `phone`, errors when that OS is
+not selected. These options do not apply to physical devices, web/mobile-web
+targets, or Edge. V1 supports one form factor per OS per run; run phone and
+tablet suites separately. Tablet results are labelled `iOS · Tablet` or
+`Android · Tablet`; phone labels stay unchanged.
+
+An iPhone-only build may run on iPad in compatibility mode; the server warns
+that the run does not establish native tablet-layout coverage. Unknown
+device-family metadata produces a different warning with the same coverage
+limitation. Neither warning blocks launch. These per-run options do not change
+app defaults.
+
 ## Configuration
 
 | Environment Variable          | Description                                                | Required                           |

{minitest_cli-0.31.0 → minitest_cli-0.32.0}/README.md

@@ -78,6 +78,32 @@ minitest --app <app-id> run all --web
 minitest --app <app-id> run all --ios-build <ios-build-id> --android-build <android-build-id>
 ```
 
+## Native cloud tablets
+
+Native lanes default to phones. Use `--ios-device-type phone|tablet` or
+`--android-device-type phone|tablet` on `run start` (including `--tag`), `run all`,
+or `run from-commit` to configure an already selected native cloud lane:
+
+```bash
+minitest --app <app-id> run all --ios-build <ios-build-id> --ios-device-type tablet
+minitest --app <app-id> run start --tag smoke --android-build <android-build-id> --android-device-type tablet
+minitest --app <app-id> run from-commit <full-sha> --platform ios --ios-device-type tablet
+```
+
+The device-type options do not select an OS: `start`/`all` still need the
+corresponding build flag; `from-commit` uses `--platform` (or its existing iOS +
+Android default). An explicit device type, even `phone`, errors when that OS is
+not selected. These options do not apply to physical devices, web/mobile-web
+targets, or Edge. V1 supports one form factor per OS per run; run phone and
+tablet suites separately. Tablet results are labelled `iOS · Tablet` or
+`Android · Tablet`; phone labels stay unchanged.
+
+An iPhone-only build may run on iPad in compatibility mode; the server warns
+that the run does not establish native tablet-layout coverage. Unknown
+device-family metadata produces a different warning with the same coverage
+limitation. Neither warning blocks launch. These per-run options do not change
+app defaults.
+
 ## Configuration
 
 | Environment Variable          | Description                                                | Required                           |

{minitest_cli-0.31.0 → minitest_cli-0.32.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "minitest-cli"
-version = "0.31.0"
+version = "0.32.0"
 description = "Minitest CLI – command-line interface for the Minitest testing platform"
 readme = "README.md"
 license = "MIT"

{minitest_cli-0.31.0 → minitest_cli-0.32.0}/src/minitest_cli/commands/batch_helpers.py

@@ -5,6 +5,7 @@ from typing import Any
 from minitest_cli.api.client import BATCH_CREATE_TIMEOUT, ApiClient
 from minitest_cli.commands.run_display import _derive_run_status
 from minitest_cli.commands.run_helpers import handle_response_error
+from minitest_cli.commands.batch_warnings import print_compatibility_warnings
 from minitest_cli.models.batch import BatchResponse, CreateBatchRequest
 
 
@@ -21,7 +22,9 @@ async def post_batch(client: ApiClient, app_id: str, body: CreateBatchRequest) -
         timeout=BATCH_CREATE_TIMEOUT,
     )
     handle_response_error(resp, resource="Batch")
-    return BatchResponse.model_validate(resp.json())
+    batch = BatchResponse.model_validate(resp.json())
+    print_compatibility_warnings(batch)
+    return batch
 
 
 def batch_summary_payload(batch: BatchResponse) -> dict[str, Any]:

minitest_cli-0.32.0/src/minitest_cli/commands/batch_warnings.py

@@ -0,0 +1,12 @@
+from minitest_cli.models.batch import BatchResponse
+from minitest_cli.utils.output import print_warning
+
+
+def print_compatibility_warnings(batch: BatchResponse, seen: set[str] | None = None) -> set[str]:
+    reported = seen if seen is not None else set()
+    for target in batch.targets:
+        for warning in target.compatibility_warnings:
+            if warning not in reported:
+                print_warning(warning)
+                reported.add(warning)
+    return reported

{minitest_cli-0.31.0 → minitest_cli-0.32.0}/src/minitest_cli/commands/flow_types.py

@@ -26,14 +26,17 @@ from minitest_cli.commands.flow_types_helpers import (
 )
 from minitest_cli.core.auth import require_auth
 from minitest_cli.models.flow_type import FlowTypeListItem
-from minitest_cli.utils.output import print_error, print_json
+from minitest_cli.utils.output import print_error, print_json, print_warning
 
-app = typer.Typer(name="flow-types", help="List, create and update flow (user-story) types.")
+app = typer.Typer(
+    name="flow-types", help="Deprecated: use `minitest tags`. Manage legacy flow types."
+)
 
 
 @app.callback()
 def _callback() -> None:
-    """Flow types operations."""
+    """Deprecated: use `minitest tags`."""
+    print_warning("`minitest flow-types` is deprecated; use `minitest tags` instead.")
 
 
 @app.command(name="list")

{minitest_cli-0.31.0 → minitest_cli-0.32.0}/src/minitest_cli/commands/flow_types_helpers.py

@@ -1,7 +1,5 @@
 """Shared helpers for flow (user-story) types: API paths, fetching, name resolution."""
 
-import asyncio
-from typing import NamedTuple
 from uuid import UUID
 
 import httpx
@@ -18,7 +16,6 @@ EXIT_NOT_FOUND = 4
 
 APPS_PATH = "/api/v1/apps"
 BUILTIN_TYPES_PATH = "/api/v1/user-story-types"
-CUSTOM_TYPE_VALUE = "custom"
 
 
 def custom_types_path(app_id: str, custom_type_id: str | None = None) -> str:
@@ -50,23 +47,6 @@ def handle_response_error(resp: httpx.Response) -> None:
     raise typer.Exit(code=EXIT_NETWORK_ERROR)
 
 
-def fetch_builtin_flow_types(settings: Settings) -> list[str]:
-    """Fetch the built-in flow type values from the API."""
-    try:
-        resp = httpx.get(f"{settings.api_url}{BUILTIN_TYPES_PATH}", timeout=10)
-    except httpx.HTTPError as exc:
-        print_error(f"Failed to fetch flow types: {exc}")
-        raise typer.Exit(code=EXIT_NETWORK_ERROR) from exc
-    if resp.status_code != 200:
-        print_error(f"Failed to fetch flow types: HTTP {resp.status_code}")
-        raise typer.Exit(code=EXIT_NETWORK_ERROR)
-    data = resp.json()
-    if not isinstance(data, list) or not data:
-        print_error("Invalid response from the flow types endpoint.")
-        raise typer.Exit(code=EXIT_NETWORK_ERROR)
-    return data
-
-
 def get_settings() -> Settings:
     return typer.Context.settings  # type: ignore[attr-defined]
 
@@ -135,44 +115,3 @@ async def resolve_custom_flow_type_id(client: ApiClient, app_id: str, selector:
     known = ", ".join(t.name for t in custom_types) or "none"
     print_error(f"No custom flow type named '{selector}'. Existing custom types: {known}")
     raise typer.Exit(code=EXIT_NOT_FOUND)
-
-
-def fetch_custom_flow_types(settings: Settings, app_id: str) -> list[CustomFlowType]:
-    """Fetch the tenant's custom flow types from a synchronous command body."""
-
-    async def _run() -> list[CustomFlowType]:
-        async with ApiClient(settings) as client:
-            return await get_custom_flow_types(client, app_id)
-
-    try:
-        return asyncio.run(_run())
-    except httpx.HTTPError as exc:
-        print_error(f"Failed to fetch custom flow types: {exc}")
-        raise typer.Exit(code=EXIT_NETWORK_ERROR) from exc
-
-
-class ResolvedFlowType(NamedTuple):
-    """A ``--type`` value resolved into the fields the user-story API expects."""
-
-    value: str
-    custom_type_id: str | None
-
-
-def resolve_flow_type(value: str, settings: Settings, app_id: str) -> ResolvedFlowType:
-    """Resolve a ``--type`` value against built-in types, then the tenant's custom ones.
-
-    Custom types resolve to the ``custom`` API type plus the matching type id, which
-    is what testing-service expects — the custom name itself is not a valid API value.
-    """
-    builtin_types = fetch_builtin_flow_types(settings)
-    if value in builtin_types:
-        return ResolvedFlowType(value, None)
-
-    custom_types = fetch_custom_flow_types(settings, app_id)
-    for custom_type in custom_types:
-        if custom_type.name.lower() == value.lower():
-            return ResolvedFlowType(CUSTOM_TYPE_VALUE, custom_type.id)
-
-    valid = [*builtin_types, *(t.name for t in custom_types)]
-    print_error(f"Invalid flow type '{value}'. Valid types: {', '.join(valid)}")
-    raise typer.Exit(code=1)

{minitest_cli-0.31.0 → minitest_cli-0.32.0}/src/minitest_cli/commands/run.py

@@ -5,7 +5,7 @@ from typing import Annotated
 import typer
 
 from minitest_cli.api.client import ApiClient
-from minitest_cli.commands.batch_helpers import batch_summary_payload, post_batch
+from minitest_cli.commands.batch_helpers import post_batch
 from minitest_cli.commands.run_display import _derive_run_status
 from minitest_cli.commands.run_helpers import (
     base_path,
@@ -22,15 +22,19 @@ from minitest_cli.commands.run_helpers import (
     RUN_TABLE_HEADERS,
     TERMINAL_STATUSES,
 )
+from minitest_cli.commands.run_cancel import cancel
 from minitest_cli.commands.run_commit import from_commit
 from minitest_cli.commands.run_targets import (
     AndroidBuildOpt,
+    AndroidDeviceTypeOpt,
     build_targets,
     IosBuildOpt,
+    IosDeviceTypeOpt,
     WebOpt,
 )
 from minitest_cli.commands.run_feedback import feedback
 from minitest_cli.commands.run_recording import register_recording_commands
+from minitest_cli.commands.run_tagged import print_batch_started, start_tagged
 from minitest_cli.commands.verdicts import verdicts
 from minitest_cli.models.batch import BatchResponse, CreateBatchRequest
 from minitest_cli.models.story_run import (
@@ -51,21 +55,36 @@ app = typer.Typer(name="run", help="Test execution.")
 
 @app.command()
 def start(
-    user_story: Annotated[str, typer.Argument(help="User-story name or UUID to run.")],
+    user_story: Annotated[
+        str | None, typer.Argument(help="User-story name or UUID to run. Excludes --tag.")
+    ] = None,
+    tag: Annotated[
+        list[str] | None,
+        typer.Option("--tag", help="Run every scenario carrying any of these tags (repeatable)."),
+    ] = None,
     ios_build: IosBuildOpt = None,
     android_build: AndroidBuildOpt = None,
     web: WebOpt = False,
+    ios_device_type: IosDeviceTypeOpt = None,
+    android_device_type: AndroidDeviceTypeOpt = None,
     watch: Annotated[
         bool, typer.Option("--watch/--no-watch", help="Poll for results (default: watch).")
     ] = True,
 ) -> None:
-    """Start a new test run for a user story (via the batches endpoint)."""
+    """Start a run for one user story, or one batch over every story with --tag."""
+    if (user_story is None) == (not tag):
+        print_error("Pass either a user story or --tag, not both or neither.")
+        raise typer.Exit(code=1)
     settings, app_id, json_mode = resolve_app()
-    targets = build_targets(ios_build, android_build, web)
+    targets = build_targets(ios_build, android_build, web, ios_device_type, android_device_type)
+    if tag:
+        print_batch_started(start_tagged(settings, app_id, tag, targets), json_mode)
+        return
+    story_ref = user_story or ""
 
     async def _start() -> StoryRunResponse:
         async with ApiClient(settings) as client:
-            user_story_id = await resolve_user_story_id(client, app_id, user_story)
+            user_story_id = await resolve_user_story_id(client, app_id, story_ref)
             body = CreateBatchRequest(user_story_ids=[user_story_id], targets=targets)
             batch = await post_batch(client, app_id, body)
             if not batch.story_runs:
@@ -148,52 +167,27 @@ def list_runs(
         print_info(tip)
 
 
-@app.command()
-def cancel(run_id: Annotated[str, typer.Argument(help="Run ID to cancel.")]) -> None:
-    """Cancel a pending or running story run."""
-    settings, app_id, json_mode = resolve_app()
-    ensure_uuid(run_id, kind="run id")
-
-    async def _cancel() -> StoryRunResponse:
-        async with ApiClient(settings) as client:
-            resp = await client.post(f"{base_path(app_id)}/{run_id}/cancel")
-            handle_response_error(resp, resource="Run")
-            return StoryRunResponse.model_validate(resp.json())
-
-    run = run_api_call(_cancel())
-    if json_mode:
-        output(run.model_dump(mode="json", by_alias=True), json_mode=True)
-    else:
-        print_success(f"Run cancelled: {run.id} (status: {_derive_run_status(run)})")
-
-
 @app.command(name="all")
 def run_all(
     ios_build: IosBuildOpt = None,
     android_build: AndroidBuildOpt = None,
     web: WebOpt = False,
+    ios_device_type: IosDeviceTypeOpt = None,
+    android_device_type: AndroidDeviceTypeOpt = None,
 ) -> None:
     """Start a batch covering every user story for the app."""
     settings, app_id, json_mode = resolve_app()
-    targets = build_targets(ios_build, android_build, web)
+    targets = build_targets(ios_build, android_build, web, ios_device_type, android_device_type)
 
     async def _run_all() -> BatchResponse:
         async with ApiClient(settings) as client:
             body = CreateBatchRequest(targets=targets)
             return await post_batch(client, app_id, body)
 
-    batch = run_api_call(_run_all())
-    if json_mode:
-        print_json(batch_summary_payload(batch))
-        return
-    rows = [format_run_row(r) for r in batch.story_runs]
-    print_table(RUN_TABLE_HEADERS, rows, title=f"Batch {batch.id} — {batch.status.value}")
-    print_info(
-        f"Started {len(batch.story_runs)} runs. "
-        f"Use `minitest batch get {batch.id}` or `minitest run status <id>` to follow up."
-    )
+    print_batch_started(run_api_call(_run_all()), json_mode)
 
 
+app.command(name="cancel")(cancel)
 app.command(name="from-commit")(from_commit)
 app.command(name="verdicts")(verdicts)
 app.command(name="feedback")(feedback)

minitest_cli-0.32.0/src/minitest_cli/commands/run_cancel.py

@@ -0,0 +1,123 @@
+"""The `minitest run cancel` command: cancel the in-flight platforms of a story run.
+
+testing-service only cancels per story-run platform (SRP), so the command reads
+the run, then cancels each selected platform that has not finished yet.
+"""
+
+from enum import StrEnum
+from typing import Annotated
+
+import typer
+
+from minitest_cli.api.client import ApiClient
+from minitest_cli.commands.run_display import _derive_run_status
+from minitest_cli.commands.run_helpers import (
+    base_path,
+    ensure_uuid,
+    EXIT_NOT_FOUND,
+    handle_response_error,
+    resolve_app,
+    run_api_call,
+)
+from minitest_cli.models.story_run import PlatformRun, StoryRunResponse
+from minitest_cli.utils.output import output, print_error, print_success
+
+# Mirrors testing-service EXECUTION_FINISHED_STATES: the SRP cancel route answers 409 for these.
+FINISHED_EXECUTION_STATES = {"evaluating", "completed", "failed", "skipped", "escalated"}
+
+
+class RunPlatform(StrEnum):
+    ios = "ios"
+    android = "android"
+    web = "web"
+
+
+def _srp_cancel_path(app_id: str, srp_id: str | None) -> str:
+    return f"/api/v1/apps/{app_id}/story-run-platforms/{srp_id}/cancel"
+
+
+def _label(platform: PlatformRun) -> str:
+    return platform.label or platform.platform
+
+
+def _is_cancellable(platform: PlatformRun) -> bool:
+    return (
+        platform.srp_id is not None
+        and platform.cancellation_requested_at is None
+        and platform.execution_state not in FINISHED_EXECUTION_STATES
+    )
+
+
+def _select(
+    run: StoryRunResponse, platform: RunPlatform | None, srp_id: str | None
+) -> list[PlatformRun]:
+    selected = [
+        p
+        for p in run.platforms
+        if (platform is None or p.platform == platform.value)
+        and (srp_id is None or p.srp_id == srp_id.lower())
+    ]
+    if not selected:
+        wanted = [
+            f"{platform.value} platform" if platform else "",
+            f"SRP {srp_id}" if srp_id else "",
+        ]
+        print_error(f"Run {run.id} has no {' / '.join(w for w in wanted if w) or 'platforms'}.")
+        raise typer.Exit(code=EXIT_NOT_FOUND)
+    return selected
+
+
+async def _cancel_platforms(
+    client: ApiClient, app_id: str, targets: list[PlatformRun]
+) -> tuple[StoryRunResponse | None, list[PlatformRun]]:
+    latest: StoryRunResponse | None = None
+    cancelled: list[PlatformRun] = []
+    for target in targets:
+        resp = await client.post(_srp_cancel_path(app_id, target.srp_id))
+        if resp.status_code == 409:
+            continue
+        handle_response_error(resp, resource="Run platform")
+        latest = StoryRunResponse.model_validate(resp.json())
+        cancelled.append(target)
+    return latest, cancelled
+
+
+def cancel(
+    run_id: Annotated[str, typer.Argument(help="Run ID to cancel.")],
+    platform: Annotated[
+        RunPlatform | None,
+        typer.Option("--platform", help="Only cancel this platform (ios, android or web)."),
+    ] = None,
+    srp_id: Annotated[
+        str | None,
+        typer.Option("--srp", help="Only cancel this story-run platform ID."),
+    ] = None,
+) -> None:
+    """Cancel every pending or running platform of a story run."""
+    settings, app_id, json_mode = resolve_app()
+    ensure_uuid(run_id, kind="run id")
+    if srp_id is not None:
+        ensure_uuid(srp_id, kind="SRP id")
+
+    async def _cancel() -> tuple[StoryRunResponse, list[PlatformRun]]:
+        async with ApiClient(settings) as client:
+            resp = await client.get(f"{base_path(app_id)}/{run_id}")
+            handle_response_error(resp, resource="Run")
+            run = StoryRunResponse.model_validate(resp.json())
+            targets = [p for p in _select(run, platform, srp_id) if _is_cancellable(p)]
+            latest, cancelled = await _cancel_platforms(client, app_id, targets)
+            return latest or run, cancelled
+
+    run, cancelled = run_api_call(_cancel())
+    if not cancelled:
+        states = ", ".join(f"{_label(p)}: {p.execution_state}" for p in run.platforms)
+        print_error(
+            f"Nothing to cancel on run {run.id}: the selected platforms already finished "
+            f"or are being cancelled ({states})."
+        )
+        raise typer.Exit(code=1)
+    if json_mode:
+        output(run.model_dump(mode="json", by_alias=True), json_mode=True)
+        return
+    labels = ", ".join(_label(p) for p in cancelled)
+    print_success(f"Run cancelled: {run.id} ({labels}; status: {_derive_run_status(run)})")

{minitest_cli-0.31.0 → minitest_cli-0.32.0}/src/minitest_cli/commands/run_commit.py

@@ -23,6 +23,11 @@ from minitest_cli.commands.run_helpers import (
     run_api_call,
 )
 from minitest_cli.models import BatchResponse, BatchStatus, CreateBatchRequest
+from minitest_cli.commands.run_targets import (
+    AndroidDeviceTypeOpt,
+    IosDeviceTypeOpt,
+    build_commit_targets,
+)
 from minitest_cli.utils.output import output, print_info, print_success, print_warning
 
 CommitShaArg = Annotated[
@@ -49,6 +54,8 @@ TimeoutOpt = Annotated[int, typer.Option("--timeout", help="Seconds to poll befo
 def from_commit(
     commit_sha: CommitShaArg,
     platform: PlatformOpt = None,
+    ios_device_type: IosDeviceTypeOpt = None,
+    android_device_type: AndroidDeviceTypeOpt = None,
     user_story: UserStoryOpt = None,
     watch: WatchOpt = True,
     timeout: TimeoutOpt = DEFAULT_TIMEOUT_SECONDS,
@@ -57,6 +64,7 @@ def from_commit(
     settings, app_id, json_mode = resolve_app()
     sha = validate_commit_sha(commit_sha)
     platforms = validate_platforms(platform)
+    targets = build_commit_targets(platforms, ios_device_type, android_device_type)
 
     async def _run() -> BatchResponse:
         async with ApiClient(settings) as client:
@@ -65,11 +73,19 @@ def from_commit(
                 story_ids = [
                     await resolve_user_story_id(client, app_id, name) for name in user_story
                 ]
-            body = CreateBatchRequest(user_story_ids=story_ids, commit_sha=sha, platforms=platforms)
+            body = CreateBatchRequest(
+                user_story_ids=story_ids,
+                commit_sha=sha,
+                platforms=platforms if targets is None else None,
+                targets=targets,
+            )
             batch = await post_batch(client, app_id, body)
             if not watch:
                 return batch
-            return await poll_batch(client, app_id, batch.id, timeout)
+            seen_warnings = {
+                warning for target in batch.targets for warning in target.compatibility_warnings
+            }
+            return await poll_batch(client, app_id, batch.id, timeout, seen_warnings)
 
     batch = run_api_call(_run())
     payload = batch_commit_payload(batch)

{minitest_cli-0.31.0 → minitest_cli-0.32.0}/src/minitest_cli/commands/run_commit_helpers.py

@@ -6,6 +6,7 @@ from typing import Any
 
 from minitest_cli.api.client import ApiClient
 from minitest_cli.commands.batch_helpers import batches_base_path
+from minitest_cli.commands.batch_warnings import print_compatibility_warnings
 from minitest_cli.commands.run_display import _derive_run_status
 from minitest_cli.commands.run_helpers import handle_response_error
 from minitest_cli.models import BatchResponse, BatchStatus
@@ -28,6 +29,11 @@ def batch_commit_payload(batch: BatchResponse) -> dict[str, Any]:
         "targets": [
             {
                 "platform": target.platform,
+                **(
+                    {"deviceType": target.device_type, "label": target.label}
+                    if target.device_type is not None
+                    else {}
+                ),
                 "buildId": target.build_id,
                 "status": target.counters.status,
                 "passed": target.counters.passed,
@@ -48,16 +54,22 @@ def batch_commit_payload(batch: BatchResponse) -> dict[str, Any]:
 
 
 async def poll_batch(
-    client: ApiClient, app_id: str, batch_id: str, timeout_seconds: int
+    client: ApiClient,
+    app_id: str,
+    batch_id: str,
+    timeout_seconds: int,
+    seen_warnings: set[str] | None = None,
 ) -> BatchResponse:
     path = f"{batches_base_path(app_id)}/{batch_id}"
     deadline = time.monotonic() + timeout_seconds
+    reported_warnings = seen_warnings if seen_warnings is not None else set()
 
     with err_console.status("[bold blue]Waiting for the build and the run...") as spinner:
         while True:
             resp = await client.get(path)
             handle_response_error(resp, resource="Batch")
             batch = BatchResponse.model_validate(resp.json())
+            print_compatibility_warnings(batch, reported_warnings)
             spinner.update(f"[bold blue]Batch {batch.status.value} ({len(batch.story_runs)} runs)")
             if batch.status in TERMINAL_BATCH_STATUSES:
                 return batch

{minitest_cli-0.31.0 → minitest_cli-0.32.0}/src/minitest_cli/commands/run_display.py

@@ -60,7 +60,7 @@ def format_run_row(run: StoryRunResponse) -> list[str]:
 
 
 def _platform_label(p: PlatformRun) -> str:
-    return p.label or target_label(p.platform, p.browser, p.viewport)
+    return p.label or target_label(p.platform, p.browser, p.viewport, p.device_type)
 
 
 def _platform_status_line(p: PlatformRun) -> tuple[str, str | None]:
@@ -100,7 +100,16 @@ def display_run_result(run: StoryRunResponse, json_mode: bool) -> None:
     rows: list[list[str]] = []
     for cr in run.results:
         result_str = "[green]✓ pass[/green]" if cr.success else "[red]✗ fail[/red]"
-        platform_label = target_label(cr.platform, None, None)
+        matching_platforms = [
+            p
+            for p in run.platforms
+            if (p.srp_id == cr.srp_id if cr.srp_id else p.platform == cr.platform)
+        ]
+        platform_label = (
+            _platform_label(matching_platforms[0])
+            if len(matching_platforms) == 1
+            else target_label(cr.platform, None, None)
+        )
         if cr.is_platform_override:
             platform_label += " *"
         rows.append([cr.criterion_version_id, platform_label, result_str, cr.fail_reason or ""])

minitest_cli-0.32.0/src/minitest_cli/commands/run_tagged.py

@@ -0,0 +1,44 @@
+"""Batch launch over every scenario carrying a tag, and the shared batch summary output."""
+
+import typer
+
+from minitest_cli.api.client import ApiClient
+from minitest_cli.commands.batch_helpers import batch_summary_payload, post_batch
+from minitest_cli.commands.run_helpers import RUN_TABLE_HEADERS, format_run_row, run_api_call
+from minitest_cli.commands.tags_helpers import resolve_tag_ids
+from minitest_cli.commands.user_story_helpers import EXIT_NOT_FOUND, fetch_all_user_stories
+from minitest_cli.core.config import Settings
+from minitest_cli.models.batch import BatchResponse, CreateBatchRequest
+from minitest_cli.models.targets import BatchTarget
+from minitest_cli.utils.output import print_error, print_info, print_json, print_table
+
+
+def print_batch_started(batch: BatchResponse, json_mode: bool) -> None:
+    if json_mode:
+        print_json(batch_summary_payload(batch))
+        return
+    rows = [format_run_row(r) for r in batch.story_runs]
+    print_table(RUN_TABLE_HEADERS, rows, title=f"Batch {batch.id} — {batch.status.value}")
+    print_info(
+        f"Started {len(batch.story_runs)} runs. "
+        f"Use `minitest batch get {batch.id}` or `minitest run status <id>` to follow up."
+    )
+
+
+def start_tagged(
+    settings: Settings, app_id: str, tags: list[str], targets: list[BatchTarget]
+) -> BatchResponse:
+    async def _start() -> BatchResponse:
+        async with ApiClient(settings) as client:
+            tag_ids = await resolve_tag_ids(client, app_id, tags)
+            stories = await fetch_all_user_stories(client, app_id, {"tagId": tag_ids})
+            # An empty id list would make the backend run every scenario of the app.
+            if not stories:
+                print_error(f"No scenario carries any of these tags: {', '.join(tags)}.")
+                raise typer.Exit(code=EXIT_NOT_FOUND)
+            body = CreateBatchRequest(
+                user_story_ids=[str(s["id"]) for s in stories], targets=targets
+            )
+            return await post_batch(client, app_id, body)
+
+    return run_api_call(_start())