minitest-cli 0.8.2__tar.gz → 0.9.0__tar.gz

{minitest_cli-0.8.2 → minitest_cli-0.9.0}/AGENTS.md

@@ -49,7 +49,7 @@ uv add <package>                                   # Add new dependency (always
 ### Output Convention
 - `--json` flag: JSON to stdout, diagnostics to stderr
 - Without `--json`: human-friendly rich tables to stdout, diagnostics to stderr
-- Exit codes: 0=Success, 1=General error, 2=Auth error, 3=Network/API error, 4=Not found
+- Exit codes: 0=Success, 1=General error, 2=Auth error, 3=Network/API error, 4=Not found, 5=Build invalid
 
 ### No Interactive Prompts
 - All input via flags, env vars, or stdin

{minitest_cli-0.8.2 → minitest_cli-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: minitest-cli
-Version: 0.8.2
+Version: 0.9.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

{minitest_cli-0.8.2 → minitest_cli-0.9.0}/pyproject.toml

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

{minitest_cli-0.8.2 → minitest_cli-0.9.0}/src/minitest_cli/commands/build.py

@@ -14,6 +14,7 @@ from minitest_cli.commands.build_helpers import (
     format_build_row,
     format_pagination_info,
     handle_response_error,
+    print_validation_warnings,
     resolve_app,
     run_api_call,
     upload_status_message,
@@ -79,6 +80,7 @@ def upload(
     if json_mode:
         output(result_dict, json_mode=True)
     else:
+        print_validation_warnings(result.validation_warnings)
         print_success(f"Build uploaded: {file.name} ({resolved_platform})")
         output(result_dict, json_mode=False)
 

{minitest_cli-0.8.2 → minitest_cli-0.9.0}/src/minitest_cli/commands/build_helpers.py

@@ -12,10 +12,13 @@ import typer
 from minitest_cli.core.app_context import resolve_app_id
 from minitest_cli.core.config import Settings
 from minitest_cli.models import BuildListResponse, BuildResponse
-from minitest_cli.utils.output import print_error
+from minitest_cli.utils.output import err_console, print_error
 
 EXIT_NETWORK_ERROR = 3
 EXIT_NOT_FOUND = 4
+EXIT_BUILD_INVALID = 5
+
+BUILD_INVALID_ERROR_CODE = "build_invalid"
 
 # ---------------------------------------------------------------------------
 # Context accessors
@@ -93,11 +96,44 @@ def handle_response_error(resp: httpx.Response, *, resource: str = "Build") -> N
     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_build_invalid(resp):
+        raise typer.Exit(code=EXIT_BUILD_INVALID)
     if resp.status_code >= 400:
         print_error(f"API error ({resp.status_code}): {extract_detail(resp)}")
         raise typer.Exit(code=EXIT_NETWORK_ERROR)
 
 
+def _try_handle_build_invalid(resp: httpx.Response) -> bool:
+    """If response is a build-invalid error, render issues and return True."""
+    try:
+        body = resp.json()
+    except Exception:  # noqa: BLE001
+        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.")
+    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}")
+    return True
+
+
+def print_validation_warnings(warnings: list[dict] | None) -> None:
+    """Print non-fatal validation warnings to stderr."""
+    if not warnings:
+        return
+    for warning in warnings:
+        if not isinstance(warning, dict):
+            continue
+        code = warning.get("code", "unknown")
+        message = warning.get("message", "")
+        err_console.print(f"  [yellow]⚠[/yellow] {code}: {message}")
+
+
 def run_api_call[T](coro: Coroutine[object, object, T]) -> T:
     """Run an async API coroutine, catching network errors → exit 3."""
     try:

{minitest_cli-0.8.2 → minitest_cli-0.9.0}/src/minitest_cli/commands/skill.py

@@ -1,5 +1,4 @@
-"""Skill command – fetch the latest CLI skill instructions from GitHub."""
-
+import os
 import sys
 
 import httpx
@@ -9,9 +8,10 @@ from minitest_cli.utils.output import err_console, print_error
 
 app = typer.Typer(name="skill", help="Retrieve the minitest CLI skill for AI agents.")
 
-SKILL_URL = (
+_DEFAULT_SKILL_URL = (
     "https://raw.githubusercontent.com/minitap-ai/agent-skills/main/skills/minitest-cli/SKILL.md"
 )
+SKILL_URL = os.environ.get("MINITEST_SKILL_URL", _DEFAULT_SKILL_URL)
 
 EXIT_NETWORK_ERROR = 3
 

minitest_cli-0.9.0/src/minitest_cli/commands/test_file.py

@@ -0,0 +1,163 @@
+import mimetypes
+from pathlib import Path
+from typing import Annotated, Any
+
+import typer
+
+from minitest_cli.api.client import ApiClient
+from minitest_cli.commands import test_file_list
+from minitest_cli.commands.test_file_helpers import (
+    MAX_UPLOAD_BYTES,
+    base_path,
+    get_app_flag,
+    get_settings,
+    handle_file_response,
+    is_json_mode,
+    run_api_call,
+)
+from minitest_cli.core.app_context import resolve_app_id
+from minitest_cli.core.auth import require_auth
+from minitest_cli.utils.output import output, print_error, print_success
+
+app = typer.Typer(name="test-file", help="Test-file operations (app-scoped).")
+test_file_list.register(app)
+
+
+@app.command(name="upload")
+def upload_file(
+    path: Annotated[
+        Path,
+        typer.Argument(
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+            readable=True,
+            resolve_path=True,
+            help="Path to the local file to upload.",
+        ),
+    ],
+    name: Annotated[
+        str | None, typer.Option("--name", help="Display name (defaults to the file basename).")
+    ] = None,
+    note: Annotated[
+        str | None, typer.Option("--note", help="Optional 'what this file is for' note.")
+    ] = None,
+) -> None:
+    settings = get_settings()
+    json_mode = is_json_mode()
+    require_auth(settings)
+    app_id = resolve_app_id(settings, get_app_flag())
+
+    size = path.stat().st_size
+    if size > MAX_UPLOAD_BYTES:
+        print_error(f"File too large: {size} bytes (max {MAX_UPLOAD_BYTES} bytes / 25 MB).")
+        raise typer.Exit(code=1)
+
+    mime, _ = mimetypes.guess_type(path.name)
+    mime = mime or "application/octet-stream"
+
+    async def _run() -> dict[str, Any]:
+        async with ApiClient(settings) as client:
+            with path.open("rb") as fh:
+                data = {}
+                if name is not None:
+                    data["name"] = name
+                if note is not None:
+                    data["note"] = note
+                resp = await client.upload_file(
+                    base_path(app_id),
+                    files={"file": (path.name, fh, mime)},
+                    data=data,
+                )
+            handle_file_response(resp)
+            return resp.json()
+
+    data = run_api_call(_run())
+    if not json_mode:
+        print_success(f"Test file uploaded: {data.get('id', '')}")
+    output(data, json_mode=json_mode)
+
+
+@app.command(name="get")
+def get_file(
+    file_id: Annotated[str, typer.Argument(help="Test file ID.")],
+) -> None:
+    settings = get_settings()
+    json_mode = is_json_mode()
+    require_auth(settings)
+    app_id = resolve_app_id(settings, get_app_flag())
+
+    async def _run() -> dict[str, Any]:
+        async with ApiClient(settings) as client:
+            resp = await client.get(f"{base_path(app_id)}/{file_id}")
+            handle_file_response(resp)
+            return resp.json()
+
+    output(run_api_call(_run()), json_mode=json_mode)
+
+
+@app.command(name="update")
+def update_file(
+    file_id: Annotated[str, typer.Argument(help="Test file ID.")],
+    name: Annotated[str | None, typer.Option("--name", help="New display name.")] = None,
+    note: Annotated[str | None, typer.Option("--note", help="New note.")] = None,
+    clear_note: Annotated[
+        bool, typer.Option("--clear-note", help="Remove the existing note.")
+    ] = False,
+) -> None:
+    settings = get_settings()
+    json_mode = is_json_mode()
+    require_auth(settings)
+    app_id = resolve_app_id(settings, get_app_flag())
+
+    if note is not None and clear_note:
+        print_error("Use either --note or --clear-note, not both.")
+        raise typer.Exit(code=1)
+
+    body: dict[str, Any] = {}
+    if name is not None:
+        body["name"] = name
+    if note is not None:
+        body["note"] = note
+    if clear_note:
+        body["clearNote"] = True
+
+    if not body:
+        print_error("Provide at least one field to update.")
+        raise typer.Exit(code=1)
+
+    async def _run() -> dict[str, Any]:
+        async with ApiClient(settings) as client:
+            resp = await client.patch(f"{base_path(app_id)}/{file_id}", json=body)
+            handle_file_response(resp)
+            return resp.json()
+
+    data = run_api_call(_run())
+    if not json_mode:
+        print_success(f"Test file updated: {file_id}")
+    output(data, json_mode=json_mode)
+
+
+@app.command(name="delete")
+def delete_file(
+    file_id: Annotated[str, typer.Argument(help="Test file ID.")],
+    force: Annotated[bool, typer.Option("--force", help="Skip confirmation.")] = False,
+) -> None:
+    settings = get_settings()
+    json_mode = is_json_mode()
+    require_auth(settings)
+    if not force:
+        print_error("Delete requires --force flag.")
+        raise typer.Exit(code=1)
+    app_id = resolve_app_id(settings, get_app_flag())
+
+    async def _run() -> None:
+        async with ApiClient(settings) as client:
+            resp = await client.delete(f"{base_path(app_id)}/{file_id}")
+            handle_file_response(resp)
+
+    run_api_call(_run())
+    if json_mode:
+        output({"deleted": True, "id": file_id}, json_mode=True)
+    else:
+        print_success(f"Test file deleted: {file_id}")

minitest_cli-0.9.0/src/minitest_cli/commands/test_file_helpers.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+import typer
+
+from minitest_cli.commands.user_story_helpers import (
+    extract_detail,
+    get_app_flag,
+    get_settings,
+    is_json_mode,
+    run_api_call,
+)
+from minitest_cli.utils.output import print_error
+
+EXIT_GENERAL_ERROR = 1
+EXIT_NETWORK_ERROR = 3
+EXIT_NOT_FOUND = 4
+
+MAX_UPLOAD_BYTES = 25 * 1024 * 1024  # mirrors the testing-service multipart cap
+
+FILE_TABLE_HEADERS = ["ID", "Name", "Original Filename", "Kind", "MIME", "Size", "Updated At"]
+
+
+def base_path(app_id: str) -> str:
+    return f"/api/v1/apps/{app_id}/test-files"
+
+
+def handle_file_response(resp: httpx.Response, *, resource: str = "Test file") -> None:
+    if resp.status_code == 404:
+        detail = extract_detail(resp)
+        print_error(detail or f"{resource} not found.")
+        raise typer.Exit(code=EXIT_NOT_FOUND)
+    if resp.status_code >= 400:
+        detail = extract_detail(resp)
+        print_error(detail or f"API error: {resp.status_code}")
+        raise typer.Exit(code=EXIT_NETWORK_ERROR)
+
+
+def format_file_row(entry: dict[str, Any]) -> list[str]:
+    size = entry.get("sizeBytes") or entry.get("size_bytes") or 0
+    return [
+        str(entry.get("id", "")),
+        entry.get("name", ""),
+        entry.get("originalFilename") or entry.get("original_filename") or "",
+        entry.get("kind", "") or "",
+        entry.get("mimeType") or entry.get("mime_type") or "",
+        str(size),
+        entry.get("updatedAt") or entry.get("updated_at") or "",
+    ]
+
+
+__all__ = [
+    "EXIT_GENERAL_ERROR",
+    "EXIT_NETWORK_ERROR",
+    "EXIT_NOT_FOUND",
+    "FILE_TABLE_HEADERS",
+    "MAX_UPLOAD_BYTES",
+    "base_path",
+    "extract_detail",
+    "format_file_row",
+    "get_app_flag",
+    "get_settings",
+    "handle_file_response",
+    "is_json_mode",
+    "run_api_call",
+]

minitest_cli-0.9.0/src/minitest_cli/commands/test_file_list.py

@@ -0,0 +1,58 @@
+from typing import Annotated, Any
+
+import typer
+
+from minitest_cli.api.client import ApiClient
+from minitest_cli.commands.test_file_helpers import (
+    FILE_TABLE_HEADERS,
+    base_path,
+    format_file_row,
+    get_app_flag,
+    get_settings,
+    handle_file_response,
+    is_json_mode,
+    run_api_call,
+)
+from minitest_cli.core.app_context import resolve_app_id
+from minitest_cli.core.auth import require_auth
+from minitest_cli.utils.output import output, print_info, print_table
+
+
+def register(app: typer.Typer) -> None:
+
+    @app.command(name="list")
+    def list_files(
+        kind: Annotated[
+            str | None,
+            typer.Option("--kind", help="Filter by kind (image|document|video|audio|other)."),
+        ] = None,
+        page: Annotated[int, typer.Option("--page", min=1, help="Page number.")] = 1,
+        page_size: Annotated[
+            int, typer.Option("--page-size", min=1, max=100, help="Items per page.")
+        ] = 20,
+    ) -> None:
+        settings = get_settings()
+        json_mode = is_json_mode()
+        require_auth(settings)
+        app_id = resolve_app_id(settings, get_app_flag())
+
+        params: dict[str, Any] = {"page": page, "page_size": page_size}
+        if kind is not None:
+            params["kind"] = kind
+
+        async def _run() -> Any:
+            async with ApiClient(settings) as client:
+                resp = await client.get(base_path(app_id), params=params)
+                handle_file_response(resp)
+                return resp.json()
+
+        data = run_api_call(_run())
+        items = data["items"] if isinstance(data, dict) and "items" in data else data
+        if json_mode:
+            output(items, json_mode=True)
+            return
+        if not items:
+            print_info("No test files found.")
+            return
+        rows = [format_file_row(f) for f in items]
+        print_table(FILE_TABLE_HEADERS, rows, title=f"Test files ({len(items)})")

minitest_cli-0.9.0/src/minitest_cli/commands/test_profile.py

@@ -0,0 +1,172 @@
+import sys
+from typing import Annotated, Any
+
+import typer
+
+from minitest_cli.api.client import ApiClient
+from minitest_cli.commands import test_profile_list
+from minitest_cli.commands.test_profile_helpers import (
+    app_base_path,
+    get_app_flag,
+    get_settings,
+    handle_profile_response,
+    is_json_mode,
+    run_api_call,
+)
+from minitest_cli.core.app_context import resolve_app_id
+from minitest_cli.core.auth import require_auth
+from minitest_cli.utils.output import output, print_error, print_success
+
+app = typer.Typer(name="test-profile", help="Test-profile operations (app-scoped).")
+test_profile_list.register(app)
+
+
+def _read_password(password: str | None, password_stdin: bool) -> str | None:
+    if password_stdin:
+        if password is not None:
+            print_error("Use either --password or --password-stdin, not both.")
+            raise typer.Exit(code=1)
+        return sys.stdin.read().rstrip("\r\n")
+    return password
+
+
+@app.command(name="create")
+def create_profile(
+    name: Annotated[str, typer.Option("--name", help="Profile name.")],
+    username: Annotated[str | None, typer.Option("--username", help="Account username.")] = None,
+    password: Annotated[
+        str | None, typer.Option("--password", help="Account password (use stdin for security).")
+    ] = None,
+    password_stdin: Annotated[
+        bool,
+        typer.Option("--password-stdin", help="Read the password from stdin (no echo)."),
+    ] = False,
+    about: Annotated[
+        str | None, typer.Option("--about", help="Free-text notes about the account.")
+    ] = None,
+) -> None:
+    settings = get_settings()
+    json_mode = is_json_mode()
+    require_auth(settings)
+    app_id = resolve_app_id(settings, get_app_flag())
+    pwd = _read_password(password, password_stdin)
+
+    body: dict[str, Any] = {"name": name}
+    if username is not None:
+        body["username"] = username
+    if pwd is not None:
+        body["password"] = pwd
+    if about is not None:
+        body["about"] = about
+
+    async def _run() -> dict[str, Any]:
+        async with ApiClient(settings) as client:
+            resp = await client.post(app_base_path(app_id), json=body)
+            handle_profile_response(resp)
+            return resp.json()
+
+    data = run_api_call(_run())
+    if not json_mode:
+        print_success(f"Test profile created: {data.get('id', '')}")
+    output(data, json_mode=json_mode)
+
+
+@app.command(name="get")
+def get_profile(
+    profile_id: Annotated[str, typer.Argument(help="Test profile ID.")],
+) -> None:
+    settings = get_settings()
+    json_mode = is_json_mode()
+    require_auth(settings)
+    app_id = resolve_app_id(settings, get_app_flag())
+
+    async def _run() -> dict[str, Any]:
+        async with ApiClient(settings) as client:
+            resp = await client.get(f"{app_base_path(app_id)}/{profile_id}")
+            handle_profile_response(resp)
+            return resp.json()
+
+    output(run_api_call(_run()), json_mode=json_mode)
+
+
+@app.command(name="update")
+def update_profile(
+    profile_id: Annotated[str, typer.Argument(help="Test profile ID.")],
+    name: Annotated[str | None, typer.Option("--name", help="New profile name.")] = None,
+    username: Annotated[str | None, typer.Option("--username", help="New username.")] = None,
+    password: Annotated[
+        str | None, typer.Option("--password", help="New password (overrides existing).")
+    ] = None,
+    password_stdin: Annotated[
+        bool,
+        typer.Option("--password-stdin", help="Read the new password from stdin."),
+    ] = False,
+    clear_password: Annotated[
+        bool,
+        typer.Option("--clear-password", help="Remove the stored password."),
+    ] = False,
+    about: Annotated[
+        str | None, typer.Option("--about", help="New about text (pass '' to clear).")
+    ] = None,
+) -> None:
+    settings = get_settings()
+    json_mode = is_json_mode()
+    require_auth(settings)
+    app_id = resolve_app_id(settings, get_app_flag())
+
+    pwd = _read_password(password, password_stdin)
+    if pwd is not None and clear_password:
+        print_error("Use either --password/--password-stdin or --clear-password, not both.")
+        raise typer.Exit(code=1)
+
+    body: dict[str, Any] = {}
+    if name is not None:
+        body["name"] = name
+    if username is not None:
+        body["username"] = username
+    if pwd is not None:
+        body["password"] = pwd
+    elif clear_password:
+        body["password"] = None
+    if about is not None:
+        body["about"] = about
+
+    if not body:
+        print_error("Provide at least one field to update.")
+        raise typer.Exit(code=1)
+
+    async def _run() -> dict[str, Any]:
+        async with ApiClient(settings) as client:
+            resp = await client.patch(f"{app_base_path(app_id)}/{profile_id}", json=body)
+            handle_profile_response(resp)
+            return resp.json()
+
+    data = run_api_call(_run())
+    if not json_mode:
+        print_success(f"Test profile updated: {profile_id}")
+    output(data, json_mode=json_mode)
+
+
+@app.command(name="delete")
+def delete_profile(
+    profile_id: Annotated[str, typer.Argument(help="Test profile ID.")],
+    force: Annotated[bool, typer.Option("--force", help="Skip confirmation.")] = False,
+) -> None:
+    settings = get_settings()
+    json_mode = is_json_mode()
+    require_auth(settings)
+    if not force:
+        print_error("Delete requires --force flag.")
+        raise typer.Exit(code=1)
+    app_id = resolve_app_id(settings, get_app_flag())
+
+    async def _run() -> None:
+        async with ApiClient(settings) as client:
+            resp = await client.delete(f"{app_base_path(app_id)}/{profile_id}")
+            handle_profile_response(resp)
+
+    run_api_call(_run())
+    if json_mode:
+        output({"deleted": True, "id": profile_id}, json_mode=True)
+    else:
+        print_success(f"Test profile deleted: {profile_id}")

minitest_cli-0.9.0/src/minitest_cli/commands/test_profile_helpers.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+import typer
+
+from minitest_cli.commands.user_story_helpers import (
+    extract_detail,
+    get_app_flag,
+    get_settings,
+    is_json_mode,
+    run_api_call,
+)
+from minitest_cli.utils.output import print_error
+
+EXIT_NETWORK_ERROR = 3
+EXIT_NOT_FOUND = 4
+
+PROFILE_TABLE_HEADERS = ["ID", "Name", "Username", "Scope", "Updated At"]
+
+
+def app_base_path(app_id: str) -> str:
+    return f"/api/v1/apps/{app_id}/test-profiles"
+
+
+SHARED_PATH = "/api/v1/test-profiles/shared"
+
+
+def handle_profile_response(resp: httpx.Response, *, resource: str = "Test profile") -> None:
+    if resp.status_code == 404:
+        detail = extract_detail(resp)
+        print_error(detail or f"{resource} not found.")
+        raise typer.Exit(code=EXIT_NOT_FOUND)
+    if resp.status_code >= 400:
+        detail = extract_detail(resp)
+        print_error(detail or f"API error: {resp.status_code}")
+        raise typer.Exit(code=EXIT_NETWORK_ERROR)
+
+
+def profile_scope(profile: dict[str, Any]) -> str:
+    if profile.get("isShared") or profile.get("is_shared"):
+        return "shared"
+    return "app"
+
+
+def format_profile_row(profile: dict[str, Any]) -> list[str]:
+    return [
+        str(profile.get("id", "")),
+        profile.get("name", ""),
+        profile.get("username") or "",
+        profile_scope(profile),
+        profile.get("updatedAt") or profile.get("updated_at") or "",
+    ]
+
+
+__all__ = [
+    "EXIT_NETWORK_ERROR",
+    "EXIT_NOT_FOUND",
+    "PROFILE_TABLE_HEADERS",
+    "SHARED_PATH",
+    "app_base_path",
+    "extract_detail",
+    "format_profile_row",
+    "get_app_flag",
+    "get_settings",
+    "handle_profile_response",
+    "is_json_mode",
+    "run_api_call",
+]