minitest-cli 0.37.0__tar.gz → 0.37.1__tar.gz

{minitest_cli-0.37.0 → minitest_cli-0.37.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: minitest-cli
-Version: 0.37.0
+Version: 0.37.1
 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
@@ -131,6 +131,29 @@ 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.
 
+## Physical devices
+
+By default builds run on virtual devices (iOS Simulator, Android emulator). If
+physical devices are enabled for your workspace, upload a device build with
+`--physical` and select the physical lane when you start the run:
+
+```bash
+# iOS: an Ad Hoc or Development .ipa signed for Minitap's iPhones
+BUILD_ID=$(minitest --json --app <app-id> build upload ./MyApp.ipa --physical | jq -r .id)
+minitest --app <app-id> run all --ios-build "$BUILD_ID" --ios-physical
+
+# Android: the same works with --android-physical
+minitest --app <app-id> run start --tag smoke --android-build <android-build-id> --android-physical
+```
+
+- `build upload --physical` checks the build for physical devices instead of
+  virtual ones. A Simulator build is rejected (`ios.simulator_only_ipa`), and a
+  device build uploaded without `--physical` is rejected with a hint to add it.
+- `--ios-physical` / `--android-physical` need the matching `--ios-build` /
+  `--android-build`, and can't be combined with `--*-device-type`.
+- If physical devices aren't enabled for your workspace, the run is refused
+  with a message saying so.
+
 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

{minitest_cli-0.37.0 → minitest_cli-0.37.1}/README.md

@@ -98,6 +98,29 @@ 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.
 
+## Physical devices
+
+By default builds run on virtual devices (iOS Simulator, Android emulator). If
+physical devices are enabled for your workspace, upload a device build with
+`--physical` and select the physical lane when you start the run:
+
+```bash
+# iOS: an Ad Hoc or Development .ipa signed for Minitap's iPhones
+BUILD_ID=$(minitest --json --app <app-id> build upload ./MyApp.ipa --physical | jq -r .id)
+minitest --app <app-id> run all --ios-build "$BUILD_ID" --ios-physical
+
+# Android: the same works with --android-physical
+minitest --app <app-id> run start --tag smoke --android-build <android-build-id> --android-physical
+```
+
+- `build upload --physical` checks the build for physical devices instead of
+  virtual ones. A Simulator build is rejected (`ios.simulator_only_ipa`), and a
+  device build uploaded without `--physical` is rejected with a hint to add it.
+- `--ios-physical` / `--android-physical` need the matching `--ios-build` /
+  `--android-build`, and can't be combined with `--*-device-type`.
+- If physical devices aren't enabled for your workspace, the run is refused
+  with a message saying so.
+
 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

{minitest_cli-0.37.0 → minitest_cli-0.37.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "minitest-cli"
-version = "0.37.0"
+version = "0.37.1"
 description = "Minitest CLI – command-line interface for the Minitest testing platform"
 readme = "README.md"
 license = "MIT"
@@ -128,6 +128,9 @@ python_functions = [
 python_classes = [
     "Test*"
 ]
+markers = [
+    "real_app_lookup: resolve --app names through the API instead of the test shortcut",
+]
 addopts = [
     "-v",
     "--tb=short",

{minitest_cli-0.37.0 → minitest_cli-0.37.1}/src/minitest_cli/commands/_response_errors.py

@@ -24,6 +24,11 @@ BUILD_INVALID_ERROR_CODE = "build_invalid"
 # rollout: both).
 _SPLIT_APKS_BACKEND_UNSUPPORTED_MARKER = "not yet supported on this execution backend"
 
+# Rejection codes that mean "right build, wrong kind of device": the hint
+# points at the upload flag that matches the build.
+_DEVICE_BUILD_CODES = {"ios.device_only_ipa", "ios.device_only_sdk", "ios.no_simulator_slice"}
+_SIMULATOR_BUILD_CODES = {"ios.simulator_only_ipa"}
+
 # Generic FastAPI ``loc`` prefixes that add noise to a field path (they're
 # implied by "this is a validation error" and repeat across every field).
 _LOC_PREFIXES_TO_DROP = {"body", "query", "path"}
@@ -86,14 +91,16 @@ def extract_detail(resp: httpx.Response) -> str:
         return resp.text
 
 
-def handle_response_error(resp: httpx.Response, *, resource: str = "Build") -> None:
+def handle_response_error(
+    resp: httpx.Response, *, resource: str = "Build", physical: bool = False
+) -> None:
     """Check response status; exit with proper code on errors."""
     if resp.status_code == 404:
         print_error(f"{resource} not found: {extract_detail(resp)}")
         raise typer.Exit(code=EXIT_NOT_FOUND)
     if resp.status_code == 422 and _try_handle_split_apks_backend_unsupported(resp):
         raise typer.Exit(code=EXIT_BUILD_INVALID)
-    if resp.status_code == 422 and _try_handle_build_invalid(resp):
+    if resp.status_code == 422 and _try_handle_build_invalid(resp, physical=physical):
         raise typer.Exit(code=EXIT_BUILD_INVALID)
     if resp.status_code >= 400:
         print_error(f"API error ({resp.status_code}): {extract_detail(resp)}")
@@ -122,7 +129,7 @@ def _try_handle_split_apks_backend_unsupported(resp: httpx.Response) -> bool:
     return True
 
 
-def _try_handle_build_invalid(resp: httpx.Response) -> bool:
+def _try_handle_build_invalid(resp: httpx.Response, *, physical: bool = False) -> bool:
     """If response is a build-invalid error, render issues and return True."""
     try:
         body = resp.json()
@@ -130,17 +137,32 @@ def _try_handle_build_invalid(resp: httpx.Response) -> bool:
         return False
     if not isinstance(body, dict) or body.get("error_code") != BUILD_INVALID_ERROR_CODE:
         return False
-    issues = body.get("issues") or []
-    print_error("Build rejected: failed validation for virtual-device execution.")
+    issues = [issue for issue in body.get("issues") or [] if isinstance(issue, dict)]
+    devices = "physical-device" if physical else "virtual-device"
+    print_error(f"Build rejected: failed validation for {devices} execution.")
     for issue in issues:
-        if not isinstance(issue, dict):
-            continue
         code = issue.get("code", "unknown")
         message = issue.get("message", "")
         err_console.print(f"  [red]✖[/red] {code}: {message}")
+    _print_device_kind_hint({str(issue.get("code")) for issue in issues}, physical=physical)
     return True
 
 
+def _print_device_kind_hint(codes: set[str], *, physical: bool) -> None:
+    if not physical and codes & _DEVICE_BUILD_CODES:
+        err_console.print(
+            "  [yellow]Hint:[/yellow] this is a device build. To run it on physical iPhones,"
+            " upload it with [bold]minitest build upload <file> --physical[/bold];"
+            " for virtual devices, build for the iOS Simulator instead."
+        )
+    elif physical and codes & _SIMULATOR_BUILD_CODES:
+        err_console.print(
+            "  [yellow]Hint:[/yellow] this is a Simulator build. Upload it without"
+            " [bold]--physical[/bold] to run it on virtual devices, or export a device"
+            " build (Ad Hoc or Development) for physical iPhones."
+        )
+
+
 def print_validation_warnings(warnings: list[dict] | None) -> None:
     """Print non-fatal validation warnings to stderr."""
     if not warnings:

{minitest_cli-0.37.0 → minitest_cli-0.37.1}/src/minitest_cli/commands/batch_helpers.py

@@ -2,11 +2,16 @@
 
 from typing import Any
 
+import httpx
+import typer
+
 from minitest_cli.api.client import BATCH_CREATE_TIMEOUT, ApiClient
 from minitest_cli.commands.run_display import _derive_run_status
+from minitest_cli.commands._response_errors import EXIT_NETWORK_ERROR, extract_detail
 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
+from minitest_cli.utils.output import err_console, print_error
 
 
 def batches_base_path(app_id: str) -> str:
@@ -21,12 +26,29 @@ async def post_batch(client: ApiClient, app_id: str, body: CreateBatchRequest) -
         json=body.model_dump(by_alias=True, exclude_none=True),
         timeout=BATCH_CREATE_TIMEOUT,
     )
+    if resp.status_code == 403 and _requests_physical(body):
+        _exit_physical_forbidden(resp)
     handle_response_error(resp, resource="Batch")
     batch = BatchResponse.model_validate(resp.json())
     print_compatibility_warnings(batch)
     return batch
 
 
+def _requests_physical(body: CreateBatchRequest) -> bool:
+    return any(target.backend == "physical" for target in body.targets or [])
+
+
+def _exit_physical_forbidden(resp: httpx.Response) -> None:
+    """A physical lane the workspace is not entitled to: say so, and how to proceed."""
+    print_error(extract_detail(resp))
+    err_console.print(
+        "  [yellow]Fix:[/yellow] ask Minitap to enable physical devices for this workspace,"
+        " or drop [bold]--ios-physical[/bold] / [bold]--android-physical[/bold]"
+        " to run on virtual devices."
+    )
+    raise typer.Exit(code=EXIT_NETWORK_ERROR)
+
+
 def batch_summary_payload(batch: BatchResponse) -> dict[str, Any]:
     """Serialise a batch to a compact JSON payload for --json output (camelCase)."""
     return {

{minitest_cli-0.37.0 → minitest_cli-0.37.1}/src/minitest_cli/commands/build.py

@@ -42,8 +42,8 @@ def upload(
         Path,
         typer.Argument(
             help=(
-                "Path to the build file (.apk, .apks, or .ipa). Must be a Simulator"
-                " build for iOS or an emulator-compatible Android build."
+                "Path to the build file (.apk, .apks, .ipa or .app.zip). A Simulator build"
+                " for iOS or an emulator-compatible Android build, unless --physical."
             ),
             exists=True,
             readable=True,
@@ -53,17 +53,34 @@ def upload(
         Platform | None,
         typer.Option(help="Target platform. Auto-detected from file extension."),
     ] = None,
+    physical: Annotated[
+        bool,
+        typer.Option(
+            "--physical",
+            help=(
+                "Upload a build for physical devices: a signed iOS device .ipa (Ad Hoc or"
+                " Development) or an Android .apk for real phones."
+            ),
+        ),
+    ] = False,
 ) -> None:
-    """Upload a build file (.apk or .apks for Android, .ipa for iOS).
+    """Upload a build file (.apk or .apks for Android, .ipa or .app.zip for iOS).
 
-    Builds must be compatible with virtual devices:
+    By default builds are checked for virtual devices:
 
     \b
-    - iOS: provide a Simulator build (.ipa built for the iOS Simulator, not a physical device).
+    - iOS: provide a Simulator build (.ipa or .app.zip built for the iOS Simulator).
     - Android: provide an emulator-compatible .apk or .apks archive.
+
+    With --physical, builds are checked for physical devices instead: an iOS
+    device .ipa signed for Minitap's iPhones, or an Android .apk. Start runs on
+    them with --ios-physical / --android-physical.
     """
     settings, app_id, json_mode = resolve_app()
     resolved_platform = platform.value if platform else detect_platform(file)
+    form = {"platform": resolved_platform}
+    if physical:
+        form["backend"] = "physical"
 
     async def _run() -> BuildResponse:
         async with ApiClient(settings) as client:
@@ -74,9 +91,9 @@ def upload(
                 resp = await client.upload_file(
                     f"{base_path(app_id)}/build",
                     files={"file": (file.name, f, "application/octet-stream")},
-                    data={"platform": resolved_platform},
+                    data=form,
                 )
-        handle_response_error(resp)
+        handle_response_error(resp, physical=physical)
         return BuildResponse.model_validate(resp.json())
 
     result = run_api_call(_run())
@@ -86,7 +103,8 @@ def upload(
         output(result_dict, json_mode=True)
     else:
         print_validation_warnings(result.validation_warnings)
-        print_success(f"Build uploaded: {file.name} ({resolved_platform})")
+        devices = ", physical devices" if physical else ""
+        print_success(f"Build uploaded: {file.name} ({resolved_platform}{devices})")
         output(result_dict, json_mode=False)
 
 

{minitest_cli-0.37.0 → minitest_cli-0.37.1}/src/minitest_cli/commands/build_helpers.py

@@ -76,6 +76,7 @@ PLATFORM_EXTENSIONS: dict[str, Platform] = {
     ".ipa": Platform.ios,
     ".apk": Platform.android,
     ".apks": Platform.android,
+    ".app.zip": Platform.ios,
 }
 
 
@@ -97,7 +98,8 @@ class BuildKindFilter(StrEnum):
 
 def detect_platform(file_path: Path) -> str:
     """Auto-detect platform from file extension."""
-    suffix = file_path.suffix.lower()
+    name = file_path.name.lower()
+    suffix = ".app.zip" if name.endswith(".app.zip") else file_path.suffix.lower()
     platform = PLATFORM_EXTENSIONS.get(suffix)
     if platform is None:
         print_error(

{minitest_cli-0.37.0 → minitest_cli-0.37.1}/src/minitest_cli/commands/run.py

@@ -11,15 +11,11 @@ from minitest_cli.commands.run_helpers import (
     base_path,
     display_run_result,
     ensure_uuid,
-    fetch_runs,
-    format_run_pagination_info,
-    format_run_row,
     handle_response_error,
     poll_run_status,
     resolve_app,
     resolve_user_story_id,
     run_api_call,
-    RUN_TABLE_HEADERS,
     TERMINAL_STATUSES,
 )
 from minitest_cli.commands.run_cancel import cancel
@@ -27,27 +23,27 @@ from minitest_cli.commands.run_commit import from_commit
 from minitest_cli.commands.run_targets import (
     AndroidBuildOpt,
     AndroidDeviceTypeOpt,
+    AndroidPhysicalOpt,
     build_targets,
     IosBuildOpt,
     IosDeviceTypeOpt,
+    IosPhysicalOpt,
     WebOpt,
 )
 from minitest_cli.commands.run_feedback import feedback
+from minitest_cli.commands.run_list import list_runs
 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 (
-    StoryRunListResponse,
     StoryRunResponse,
 )
 from minitest_cli.utils.output import (
-    output,
     print_error,
     print_info,
     print_json,
     print_success,
-    print_table,
 )
 
 app = typer.Typer(
@@ -69,6 +65,8 @@ def start(
     web: WebOpt = False,
     ios_device_type: IosDeviceTypeOpt = None,
     android_device_type: AndroidDeviceTypeOpt = None,
+    ios_physical: IosPhysicalOpt = False,
+    android_physical: AndroidPhysicalOpt = False,
     watch: Annotated[
         bool, typer.Option("--watch/--no-watch", help="Poll for results (default: watch).")
     ] = True,
@@ -78,7 +76,15 @@ def start(
         print_error("Pass either a scenario 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, ios_device_type, android_device_type)
+    targets = build_targets(
+        ios_build,
+        android_build,
+        web,
+        ios_device_type,
+        android_device_type,
+        ios_physical,
+        android_physical,
+    )
     if tag:
         print_batch_started(start_tagged(settings, app_id, tag, targets), json_mode)
         return
@@ -131,44 +137,6 @@ def status(
     display_run_result(run_api_call(_status()), json_mode)
 
 
-@app.command(name="list")
-def list_runs(
-    user_story: Annotated[str, typer.Argument(help="Scenario name or UUID to list runs for.")],
-    page: Annotated[int, typer.Option(help="Page number.")] = 1,
-    page_size: Annotated[int, typer.Option(help="Items per page.")] = 20,
-    status_filter: Annotated[
-        str | None,
-        typer.Option(
-            "--status",
-            help="Filter by status (pending, running, completed, failed, cancelled).",
-        ),
-    ] = None,
-    all_pages: Annotated[bool, typer.Option("--all", help="Fetch all results.")] = False,
-) -> None:
-    """List the scenario runs of one scenario."""
-    settings, app_id, json_mode = resolve_app()
-    if all_pages:
-        page, page_size = 1, 100
-
-    async def _list() -> StoryRunListResponse:
-        async with ApiClient(settings) as client:
-            user_story_id = await resolve_user_story_id(client, app_id, user_story)
-            return await fetch_runs(client, app_id, user_story_id, page, page_size, status_filter)
-
-    result = run_api_call(_list())
-    if json_mode:
-        output(result.model_dump(mode="json", by_alias=True), json_mode=True)
-        return
-    if not result.items:
-        print_info("No runs found.")
-        return
-    title, tip = format_run_pagination_info(result)
-    rows = [format_run_row(r) for r in result.items]
-    print_table(RUN_TABLE_HEADERS, rows, title=title)
-    if tip:
-        print_info(tip)
-
-
 @app.command(name="all")
 def run_all(
     ios_build: IosBuildOpt = None,
@@ -176,10 +144,20 @@ def run_all(
     web: WebOpt = False,
     ios_device_type: IosDeviceTypeOpt = None,
     android_device_type: AndroidDeviceTypeOpt = None,
+    ios_physical: IosPhysicalOpt = False,
+    android_physical: AndroidPhysicalOpt = False,
 ) -> None:
     """Start a run covering every scenario of the app."""
     settings, app_id, json_mode = resolve_app()
-    targets = build_targets(ios_build, android_build, web, ios_device_type, android_device_type)
+    targets = build_targets(
+        ios_build,
+        android_build,
+        web,
+        ios_device_type,
+        android_device_type,
+        ios_physical,
+        android_physical,
+    )
 
     async def _run_all() -> BatchResponse:
         async with ApiClient(settings) as client:
@@ -189,6 +167,7 @@ def run_all(
     print_batch_started(run_api_call(_run_all()), json_mode)
 
 
+app.command(name="list")(list_runs)
 app.command(name="cancel")(cancel)
 app.command(name="from-commit")(from_commit)
 app.command(name="verdicts")(verdicts)

minitest_cli-0.37.1/src/minitest_cli/commands/run_list.py

@@ -0,0 +1,55 @@
+"""``minitest run list``: the scenario runs of one scenario."""
+
+from typing import Annotated
+
+import typer
+
+from minitest_cli.api.client import ApiClient
+from minitest_cli.commands.run_helpers import (
+    fetch_runs,
+    format_run_pagination_info,
+    format_run_row,
+    resolve_app,
+    resolve_user_story_id,
+    run_api_call,
+    RUN_TABLE_HEADERS,
+)
+from minitest_cli.models.story_run import StoryRunListResponse
+from minitest_cli.utils.output import output, print_info, print_table
+
+
+def list_runs(
+    user_story: Annotated[str, typer.Argument(help="Scenario name or UUID to list runs for.")],
+    page: Annotated[int, typer.Option(help="Page number.")] = 1,
+    page_size: Annotated[int, typer.Option(help="Items per page.")] = 20,
+    status_filter: Annotated[
+        str | None,
+        typer.Option(
+            "--status",
+            help="Filter by status (pending, running, completed, failed, cancelled).",
+        ),
+    ] = None,
+    all_pages: Annotated[bool, typer.Option("--all", help="Fetch all results.")] = False,
+) -> None:
+    """List the scenario runs of one scenario."""
+    settings, app_id, json_mode = resolve_app()
+    if all_pages:
+        page, page_size = 1, 100
+
+    async def _list() -> StoryRunListResponse:
+        async with ApiClient(settings) as client:
+            user_story_id = await resolve_user_story_id(client, app_id, user_story)
+            return await fetch_runs(client, app_id, user_story_id, page, page_size, status_filter)
+
+    result = run_api_call(_list())
+    if json_mode:
+        output(result.model_dump(mode="json", by_alias=True), json_mode=True)
+        return
+    if not result.items:
+        print_info("No runs found.")
+        return
+    title, tip = format_run_pagination_info(result)
+    rows = [format_run_row(r) for r in result.items]
+    print_table(RUN_TABLE_HEADERS, rows, title=title)
+    if tip:
+        print_info(tip)

{minitest_cli-0.37.0 → minitest_cli-0.37.1}/src/minitest_cli/commands/run_targets.py

@@ -1,12 +1,15 @@
 """Lane-selection flags and target assembly for run commands."""
 
-from typing import Annotated
+from collections.abc import Sequence
+from typing import Annotated, Literal
 
 import typer
 
 from minitest_cli.models.targets import BatchTarget, DeviceType
 from minitest_cli.utils.output import print_error
 
+NativePlatform = Literal["ios", "android"]
+
 IosBuildOpt = Annotated[
     str | None, typer.Option("--ios-build", help="iOS build ID (selects the iOS lane).")
 ]
@@ -34,9 +37,49 @@ AndroidDeviceTypeOpt = Annotated[
     ),
 ]
 
+IosPhysicalOpt = Annotated[
+    bool,
+    typer.Option(
+        "--ios-physical",
+        help=(
+            "Run the iOS lane on physical iPhones instead of simulators (needs --ios-build"
+            " with a device build, and physical devices enabled for the workspace)."
+        ),
+    ),
+]
+AndroidPhysicalOpt = Annotated[
+    bool,
+    typer.Option(
+        "--android-physical",
+        help=(
+            "Run the Android lane on physical phones instead of emulators (needs"
+            " --android-build, and physical devices enabled for the workspace)."
+        ),
+    ),
+]
+
+
+def validate_physical(
+    platforms: Sequence[str],
+    physical: dict[str, bool],
+    device_types: dict[str, DeviceType | None],
+) -> None:
+    for platform, enabled in physical.items():
+        if not enabled:
+            continue
+        if platform not in platforms:
+            print_error(f"--{platform}-physical requires --{platform}-build.")
+            raise typer.Exit(code=1)
+        if device_types.get(platform) is not None:
+            print_error(
+                f"--{platform}-physical cannot be combined with --{platform}-device-type:"
+                " device types only apply to virtual devices."
+            )
+            raise typer.Exit(code=1)
+
 
 def validate_device_types(
-    platforms: list[str],
+    platforms: Sequence[str],
     ios_device_type: DeviceType | None,
     android_device_type: DeviceType | None,
 ) -> None:
@@ -52,19 +95,26 @@ def build_targets(
     web: bool,
     ios_device_type: DeviceType | None = None,
     android_device_type: DeviceType | None = None,
+    ios_physical: bool = False,
+    android_physical: bool = False,
 ) -> list[BatchTarget]:
-    targets: list[BatchTarget] = []
-    if ios_build:
-        targets.append(BatchTarget(platform="ios", build_id=ios_build, device_type=ios_device_type))
-    if android_build:
-        targets.append(
-            BatchTarget(platform="android", build_id=android_build, device_type=android_device_type)
+    builds: dict[NativePlatform, str | None] = {"ios": ios_build, "android": android_build}
+    device_types = {"ios": ios_device_type, "android": android_device_type}
+    physical = {"ios": ios_physical, "android": android_physical}
+    native: list[NativePlatform] = [platform for platform, build in builds.items() if build]
+    validate_physical(native, physical, device_types)
+    validate_device_types(native, ios_device_type, android_device_type)
+    targets = [
+        BatchTarget(
+            platform=platform,
+            build_id=builds[platform],
+            device_type=device_types[platform],
+            backend="physical" if physical[platform] else None,
         )
+        for platform in native
+    ]
     if web:
         targets.append(BatchTarget(platform="web"))
-    validate_device_types(
-        [target.platform for target in targets], ios_device_type, android_device_type
-    )
     if not targets:
         print_error(
             "Select at least one lane: --ios-build, --android-build, or --web. "

minitest_cli-0.37.1/src/minitest_cli/core/app_context.py

@@ -0,0 +1,68 @@
+"""App targeting: resolve the active app ID from --app flag or MINITEST_APP_ID.
+
+Both accept an app id or an app name; a name is looked up once in the apps the
+caller can see (the same lookup `draft` and `env` use), an id is used as is.
+"""
+
+import asyncio
+import sys
+import threading
+from uuid import UUID
+
+from minitest_cli.core.config import Settings
+
+EXIT_CODE_GENERAL_ERROR = 1
+
+
+def resolve_app_id(settings: Settings, app_flag: str | None = None) -> str:
+    """Resolve the target app ID.
+
+    Priority:
+      1. --app flag value (passed explicitly)
+      2. MINITEST_APP_ID environment variable (via settings)
+      3. Exit with error if neither is set
+
+    Returns:
+        The resolved app ID string.
+    """
+    target = app_flag or settings.app_id
+    if not target:
+        print(  # noqa: T201
+            "Error: No app specified. Use --app <id-or-name> or set MINITEST_APP_ID.",
+            file=sys.stderr,
+        )
+        raise SystemExit(EXIT_CODE_GENERAL_ERROR)
+    if _is_uuid(target):
+        return target
+    return _app_id_by_name(settings, target)
+
+
+def _is_uuid(value: str) -> bool:
+    try:
+        UUID(value)
+    except ValueError:
+        return False
+    return True
+
+
+def _app_id_by_name(settings: Settings, name: str) -> str:
+    """Look the name up; exits 4 when no app has it, 1 when several do."""
+    from minitest_cli.commands.env_helpers import resolve_app_and_tenant
+
+    result: list[str] = []
+    failure: list[BaseException] = []
+
+    def lookup() -> None:
+        try:
+            app_id, _ = asyncio.run(resolve_app_and_tenant(settings, name))
+            result.append(app_id)
+        except BaseException as exc:  # noqa: BLE001 - re-raised on the caller's thread
+            failure.append(exc)
+
+    # A thread of its own, so this works whether or not the caller runs an event loop.
+    worker = threading.Thread(target=lookup)
+    worker.start()
+    worker.join()
+    if failure:
+        raise failure[0]
+    return result[0]