minitest-cli 0.4.4__tar.gz → 0.5.0__tar.gz

{minitest_cli-0.4.4 → minitest_cli-0.5.0}/.github/workflows/ci.yml

@@ -63,3 +63,36 @@ jobs:
 
       - name: Run tests
         run: uv run pytest
+
+  install-script:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Clone the repository
+        uses: actions/checkout@v5
+
+      - name: Run install.sh
+        run: |
+          bash install.sh
+          echo "$HOME/.local/bin" >> "$GITHUB_PATH"
+
+      - name: Verify minitest is usable
+        run: minitest --help
+
+  install-script-windows:
+    runs-on: windows-latest
+    steps:
+      - name: Clone the repository
+        uses: actions/checkout@v5
+
+      - name: Run install.ps1
+        shell: pwsh
+        run: |
+          .\install.ps1
+          "$env:USERPROFILE\.local\bin" | Out-File -Append -FilePath $env:GITHUB_PATH -Encoding utf8
+
+      - name: Verify minitest is usable
+        shell: pwsh
+        run: minitest --help

{minitest_cli-0.4.4 → minitest_cli-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: minitest-cli
-Version: 0.4.4
+Version: 0.5.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
@@ -37,27 +37,43 @@ Command-line interface for the Minitest testing platform.
 
 ## Installation
 
-### pip (recommended)
+### One-liner (recommended)
+
+**macOS / Linux:**
 
 ```bash
-pip install minitest-cli
+curl -fsSL https://raw.githubusercontent.com/minitap-ai/minitest-cli/main/install.sh | bash
+```
+
+**Windows (PowerShell):**
+
+```powershell
+powershell -ExecutionPolicy ByPass -c "irm https://raw.githubusercontent.com/minitap-ai/minitest-cli/main/install.ps1 | iex"
 ```
 
-### uvx (zero-install)
+Both scripts use `uv` if available, or install it automatically.
+
+### Other methods
 
-Run without installing:
+**uv** (all platforms):
 
 ```bash
-uvx --from minitest-cli minitest --help
+uv tool install minitest-cli
 ```
 
-### Homebrew
+**Homebrew** (macOS):
 
 ```bash
 brew install minitap-ai/tap/minitest-cli
 ```
 
-### From source
+**uvx** (zero-install, all platforms):
+
+```bash
+uvx --from minitest-cli minitest --help
+```
+
+**From source:**
 
 ```bash
 git clone https://github.com/minitap-ai/minitest-cli.git
@@ -81,40 +97,40 @@ minitest run --app <app-id>
 
 ## Configuration
 
-| Environment Variable | Description | Required |
-|---------------------|-------------|----------|
-| `MINITEST_TOKEN` | API authentication token | Yes (or use `minitest auth login`) |
-| `MINITEST_APP_ID` | Default app ID | No (can use `--app` flag) |
-| `MINITEST_API_URL` | API base URL | No (defaults to production) |
+| Environment Variable | Description              | Required                           |
+| -------------------- | ------------------------ | ---------------------------------- |
+| `MINITEST_TOKEN`     | API authentication token | Yes (or use `minitest auth login`) |
+| `MINITEST_APP_ID`    | Default app ID           | No (can use `--app` flag)          |
+| `MINITEST_API_URL`   | API base URL             | No (defaults to production)        |
 
 ## Global Flags
 
-| Flag | Description |
-|------|-------------|
-| `--json` | Output JSON to stdout (diagnostics go to stderr) |
-| `--app <id-or-name>` | Target app for commands that require one |
-| `--version` | Show CLI version |
-| `--help` | Show help |
+| Flag                 | Description                                      |
+| -------------------- | ------------------------------------------------ |
+| `--json`             | Output JSON to stdout (diagnostics go to stderr) |
+| `--app <id-or-name>` | Target app for commands that require one         |
+| `--version`          | Show CLI version                                 |
+| `--help`             | Show help                                        |
 
 ## Commands
 
-| Command | Description |
-|---------|-------------|
-| `minitest auth` | Authentication management |
-| `minitest apps` | App management |
-| `minitest flow` | Testing flow operations |
-| `minitest build` | Build management |
-| `minitest run` | Test execution |
+| Command          | Description               |
+| ---------------- | ------------------------- |
+| `minitest auth`  | Authentication management |
+| `minitest apps`  | App management            |
+| `minitest flow`  | Testing flow operations   |
+| `minitest build` | Build management          |
+| `minitest run`   | Test execution            |
 
 ## Exit Codes
 
-| Code | Meaning |
-|------|---------|
-| 0 | Success |
-| 1 | General error |
-| 2 | Authentication error |
-| 3 | Network / API error |
-| 4 | Resource not found |
+| Code | Meaning              |
+| ---- | -------------------- |
+| 0    | Success              |
+| 1    | General error        |
+| 2    | Authentication error |
+| 3    | Network / API error  |
+| 4    | Resource not found   |
 
 ## Using the Dev Environment
 

minitest_cli-0.5.0/README.md

@@ -0,0 +1,141 @@
+# minitest-cli
+
+Command-line interface for the Minitest testing platform.
+
+## Installation
+
+### One-liner (recommended)
+
+**macOS / Linux:**
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/minitap-ai/minitest-cli/main/install.sh | bash
+```
+
+**Windows (PowerShell):**
+
+```powershell
+powershell -ExecutionPolicy ByPass -c "irm https://raw.githubusercontent.com/minitap-ai/minitest-cli/main/install.ps1 | iex"
+```
+
+Both scripts use `uv` if available, or install it automatically.
+
+### Other methods
+
+**uv** (all platforms):
+
+```bash
+uv tool install minitest-cli
+```
+
+**Homebrew** (macOS):
+
+```bash
+brew install minitap-ai/tap/minitest-cli
+```
+
+**uvx** (zero-install, all platforms):
+
+```bash
+uvx --from minitest-cli minitest --help
+```
+
+**From source:**
+
+```bash
+git clone https://github.com/minitap-ai/minitest-cli.git
+cd minitest-cli
+uv sync
+uv run minitest --help
+```
+
+## Quick Start
+
+```bash
+# Authenticate
+minitest auth login
+
+# List your apps
+minitest apps list
+
+# Run tests
+minitest run --app <app-id>
+```
+
+## Configuration
+
+| Environment Variable | Description              | Required                           |
+| -------------------- | ------------------------ | ---------------------------------- |
+| `MINITEST_TOKEN`     | API authentication token | Yes (or use `minitest auth login`) |
+| `MINITEST_APP_ID`    | Default app ID           | No (can use `--app` flag)          |
+| `MINITEST_API_URL`   | API base URL             | No (defaults to production)        |
+
+## Global Flags
+
+| Flag                 | Description                                      |
+| -------------------- | ------------------------------------------------ |
+| `--json`             | Output JSON to stdout (diagnostics go to stderr) |
+| `--app <id-or-name>` | Target app for commands that require one         |
+| `--version`          | Show CLI version                                 |
+| `--help`             | Show help                                        |
+
+## Commands
+
+| Command          | Description               |
+| ---------------- | ------------------------- |
+| `minitest auth`  | Authentication management |
+| `minitest apps`  | App management            |
+| `minitest flow`  | Testing flow operations   |
+| `minitest build` | Build management          |
+| `minitest run`   | Test execution            |
+
+## Exit Codes
+
+| Code | Meaning              |
+| ---- | -------------------- |
+| 0    | Success              |
+| 1    | General error        |
+| 2    | Authentication error |
+| 3    | Network / API error  |
+| 4    | Resource not found   |
+
+## Using the Dev Environment
+
+To point the CLI at the **dev** environment instead of production, set these environment variables when running `minitest`:
+
+```bash
+MINITEST_SUPABASE_URL=https://qrezuucghnmfvaxghqsv.supabase.co \
+MINITEST_SUPABASE_PUBLISHABLE_KEY=sb_publishable_4JRhoCm8pa5PbII0dhS09A_jhpkQhmy \
+MINITEST_API_URL=https://testing-service.dev.minitap.ai \
+minitest auth login
+```
+
+This authenticates against the dev environment and stores a dev-specific auth token. After logging in, keep the same variables set for all subsequent commands:
+
+```bash
+MINITEST_SUPABASE_URL=https://qrezuucghnmfvaxghqsv.supabase.co \
+MINITEST_SUPABASE_PUBLISHABLE_KEY=sb_publishable_4JRhoCm8pa5PbII0dhS09A_jhpkQhmy \
+MINITEST_API_URL=https://testing-service.dev.minitap.ai \
+minitest apps list
+```
+
+> **Tip:** You can `export` these variables in your shell session (or add them to a `.envrc` / `.env` file) to avoid repeating them on every invocation.
+
+## Development
+
+```bash
+# Install dependencies
+uv sync --dev
+
+# Run linter
+uv run ruff check .
+
+# Run formatter
+uv run ruff format .
+
+# Run type checker
+uv run pyright
+
+# Run tests
+uv run pytest
+```

minitest_cli-0.5.0/install.ps1

@@ -0,0 +1,116 @@
+# install.ps1 - Install minitest-cli via uv (installs uv if not installed)
+#
+# Usage:
+#   powershell -ExecutionPolicy ByPass -c "irm https://raw.githubusercontent.com/minitap-ai/minitest-cli/main/install.ps1 | iex"
+#
+
+$ErrorActionPreference = "Stop"
+$Package = "minitest-cli"
+$InstalledVia = ""
+
+function Write-Info  { param([string]$Message) Write-Host "==> $Message" -ForegroundColor Blue }
+function Write-Ok    { param([string]$Message) Write-Host "==> $Message" -ForegroundColor Green }
+function Write-Warn  { param([string]$Message) Write-Host "Warning: $Message" -ForegroundColor Yellow }
+function Write-Err   { param([string]$Message) Write-Host "Error: $Message" -ForegroundColor Red }
+
+function Get-UvToolBinDir {
+    $dir = & uv tool dir --bin 2>$null
+    if ($dir) { return $dir }
+    return "$env:USERPROFILE\.local\bin"
+}
+
+function Add-PathEntryIfMissing {
+    param([string]$Entry)
+    $normalizedEntry = $Entry.TrimEnd('\')
+    $pathEntries = ($env:PATH -split ';' | Where-Object { $_ }) | ForEach-Object { $_.TrimEnd('\') }
+    if (-not ($pathEntries | Where-Object { $_ -ieq $normalizedEntry })) {
+        $env:PATH = "$Entry;$env:PATH"
+    }
+}
+
+function Install-WithUv {
+    Write-Info "Installing $Package with uv..."
+    try {
+        & uv tool install $Package --force 2>&1 | Write-Host
+        if ($LASTEXITCODE -eq 0) {
+            $script:InstalledVia = "uv"
+            return $true
+        }
+        Write-Warn "uv tool install failed with exit code $LASTEXITCODE."
+        return $false
+    } catch {
+        Write-Warn "uv tool install failed."
+        return $false
+    }
+}
+
+function Install-Uv {
+    Write-Info "Installing uv package manager..."
+    try {
+        & ([scriptblock]::Create((Invoke-RestMethod "https://astral.sh/uv/install.ps1")))
+        # Refresh PATH so uv is available in this session
+        $uvPath = "$env:USERPROFILE\.local\bin"
+        Add-PathEntryIfMissing -Entry $uvPath
+        # Also check cargo bin (uv may install there on some setups)
+        $cargoPath = "$env:USERPROFILE\.cargo\bin"
+        Add-PathEntryIfMissing -Entry $cargoPath
+        return $true
+    } catch {
+        Write-Warn "Failed to install uv."
+        return $false
+    }
+}
+
+# -------------------------------------------------------------------
+# Main: use uv if available, otherwise bootstrap it
+# -------------------------------------------------------------------
+
+# 1. uv already installed? Use it
+if (Get-Command uv -ErrorAction SilentlyContinue) {
+    Install-WithUv | Out-Null
+}
+
+# 2. No uv - bootstrap it
+if (-not $InstalledVia) {
+    if (Install-Uv) {
+        Install-WithUv | Out-Null
+    }
+}
+
+if (-not $InstalledVia) {
+    Write-Err "Installation failed."
+    Write-Err "Please install manually:"
+    Write-Err "  powershell -ExecutionPolicy ByPass -c `"irm https://astral.sh/uv/install.ps1 | iex`""
+    Write-Err "  uv tool install $Package"
+    exit 1
+}
+
+# -------------------------------------------------------------------
+# Verify installation
+# -------------------------------------------------------------------
+if (Get-Command minitest -ErrorAction SilentlyContinue) {
+    Write-Ok "minitest-cli installed successfully!"
+    minitest --version
+    Write-Host ""
+    Write-Info "Next steps:"
+    Write-Host "  minitest auth login       # authenticate"
+    Write-Host "  minitest apps list        # list your apps"
+    Write-Host "  minitest --help           # see all commands"
+} else {
+    # Check uv tool bin directory
+    $toolBinDir = Get-UvToolBinDir
+    $uvBin = Join-Path $toolBinDir "minitest.exe"
+    if (Test-Path $uvBin) {
+        Write-Ok "minitest-cli installed successfully!"
+        & $uvBin --version
+        Write-Host ""
+        Write-Warn "minitest is not on your PATH in this session."
+        Write-Warn "Close and reopen your terminal, then run:"
+        Write-Host "  minitest --help"
+    } else {
+        Write-Err "Installation reported success, but 'minitest' binary was not found."
+        Write-Err "Please try reinstalling:"
+        Write-Err "  uv tool install $Package"
+        exit 1
+    }
+}

minitest_cli-0.5.0/install.sh

@@ -0,0 +1,144 @@
+#!/usr/bin/env bash
+# install.sh — Install minitest-cli via uv (installs uv if not installed)
+#
+# Usage:
+#   curl -fsSL https://raw.githubusercontent.com/minitap-ai/minitest-cli/main/install.sh | bash
+#
+set -euo pipefail
+
+PACKAGE="minitest-cli"
+INSTALLED_VIA=""
+
+info()  { printf '\033[1;34m==>\033[0m %s\n' "$*"; }
+ok()    { printf '\033[1;32m==>\033[0m %s\n' "$*"; }
+warn()  { printf '\033[1;33mWarning:\033[0m %s\n' "$*"; }
+error() { printf '\033[1;31mError:\033[0m %s\n' "$*" >&2; }
+
+# Resolve the directory where uv installs tool executables.
+# Respects UV_TOOL_BIN_DIR / XDG_BIN_HOME; falls back to ~/.local/bin.
+get_uv_bin_dir() {
+  uv tool dir --bin 2>/dev/null || printf '%s\n' "${UV_TOOL_BIN_DIR:-${XDG_BIN_HOME:-${HOME}/.local/bin}}"
+}
+
+# Resolve the target shell rc file based on $SHELL.
+get_shell_rc() {
+  case "${SHELL:-}" in
+    */zsh)  printf '%s\n' "${HOME}/.zshrc" ;;
+    */bash) printf '%s\n' "${HOME}/.bashrc" ;;
+    *)      printf '%s\n' "${HOME}/.profile" ;;
+  esac
+}
+
+# -------------------------------------------------------------------
+# ensure_on_path — make sure a directory is on PATH now + in shell rc
+# -------------------------------------------------------------------
+ensure_on_path() {
+  local dir="$1"
+  case ":${PATH}:" in
+    *":${dir}:"*) return 0 ;;  # already on PATH
+  esac
+  export PATH="${dir}:${PATH}"
+
+  # Patch the user's shell rc file so new terminals pick it up
+  local rc
+  rc="$(get_shell_rc)"
+
+  local line="export PATH=\"${dir}:\$PATH\""
+  local dir_relative="${dir/#${HOME}/\$HOME}"
+  if grep -qF "${dir}" "${rc}" 2>/dev/null \
+     || grep -qF "${dir_relative}" "${rc}" 2>/dev/null \
+     || grep -q "local/bin/env" "${rc}" 2>/dev/null; then
+    :  # already has a PATH entry for this dir
+  else
+    info "Adding ${dir} to PATH in ${rc}"
+    printf '\n# Added by minitest-cli installer\n%s\n' "${line}" >> "${rc}"
+  fi
+}
+
+# -------------------------------------------------------------------
+# install_with_uv — use uv tool install
+# -------------------------------------------------------------------
+install_with_uv() {
+  info "Installing ${PACKAGE} with uv…"
+  if uv tool install "${PACKAGE}" --force 2>&1; then
+    INSTALLED_VIA="uv"
+    local bin_dir
+    bin_dir="$(get_uv_bin_dir)"
+    ensure_on_path "${bin_dir}"
+    return 0
+  fi
+  warn "uv tool install failed."
+  return 1
+}
+
+# -------------------------------------------------------------------
+# bootstrap_uv — install uv itself, then use it to install minitest
+# -------------------------------------------------------------------
+bootstrap_uv() {
+  info "Installing uv package manager…"
+  if curl -LsSf https://astral.sh/uv/install.sh | sh 2>&1; then
+    # uv installer defaults to ~/.local/bin; add it so uv is available
+    ensure_on_path "${HOME}/.local/bin"
+    install_with_uv
+    return $?
+  fi
+  warn "Failed to install uv."
+  return 1
+}
+
+# -------------------------------------------------------------------
+# Main: use uv if available, otherwise bootstrap it
+# -------------------------------------------------------------------
+
+# 1. uv already installed? Use it
+if command -v uv &>/dev/null; then
+  install_with_uv || true
+fi
+
+# 2. No uv — bootstrap it
+if [[ -z "${INSTALLED_VIA}" ]]; then
+  bootstrap_uv || true
+fi
+
+if [[ -z "${INSTALLED_VIA}" ]]; then
+  error "Installation failed."
+  error "Please install manually:"
+  error "  curl -LsSf https://astral.sh/uv/install.sh | sh"
+  error "  uv tool install ${PACKAGE}"
+  exit 1
+fi
+
+# -------------------------------------------------------------------
+# Verify installation
+# -------------------------------------------------------------------
+if command -v minitest &>/dev/null; then
+  ok "minitest-cli installed successfully!"
+  minitest --version
+  echo ""
+  info "Next steps:"
+  echo "  minitest auth login       # authenticate"
+  echo "  minitest apps list        # list your apps"
+  echo "  minitest --help           # see all commands"
+else
+  # minitest binary exists but shell doesn't see it yet (current session)
+  uv_bin_dir="$(get_uv_bin_dir)"
+  if [[ -x "${uv_bin_dir}/minitest" ]]; then
+    ok "minitest-cli installed successfully!"
+    "${uv_bin_dir}/minitest" --version
+    echo ""
+    warn "Run this to use minitest in your current terminal:"
+    echo "  export PATH=\"${uv_bin_dir}:\$PATH\""
+    echo ""
+    info "It will work automatically in new terminals."
+    echo ""
+    info "Next steps:"
+    echo "  minitest auth login       # authenticate"
+    echo "  minitest apps list        # list your apps"
+    echo "  minitest --help           # see all commands"
+  else
+    error "Installation reported success, but 'minitest' binary was not found."
+    error "Please try reinstalling:"
+    error "  uv tool install ${PACKAGE}"
+    exit 1
+  fi
+fi

{minitest_cli-0.4.4 → minitest_cli-0.5.0}/pyproject.toml

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

{minitest_cli-0.4.4 → minitest_cli-0.5.0}/src/minitest_cli/commands/auth.py

@@ -1,5 +1,7 @@
 """Authentication commands: login, logout, status."""
 
+import json
+import subprocess
 from datetime import UTC, datetime
 
 import typer
@@ -13,10 +15,37 @@ from minitest_cli.core.auth import (
     oauth_pkce_login,
 )
 from minitest_cli.core.config import Settings
-from minitest_cli.utils.output import output, print_error, print_success
+from minitest_cli.utils.output import output, print_error, print_info, print_success
 
 app = typer.Typer(name="auth", help="Authentication management.")
 
+SKILL_NAME = "minitest-cli"
+SKILL_INSTALL_CMD = "npx skills add minitap-ai/agent-skills --skill minitest-cli"
+
+
+def _is_skill_installed() -> bool:
+    """Check if the minitest-cli skill is installed via ``npx skills ls``.
+
+    Queries both project-level and global scopes so the detection stays in
+    sync with whatever directories the ``skills`` CLI manages.
+    """
+    for flags in (["--json"], ["--json", "-g"]):
+        try:
+            result = subprocess.run(
+                ["npx", "skills", "ls", *flags],
+                capture_output=True,
+                text=True,
+                timeout=30,
+            )
+            if result.returncode == 0:
+                skills = json.loads(result.stdout)
+                if any(s.get("name") == SKILL_NAME for s in skills):
+                    return True
+        except (subprocess.TimeoutExpired, json.JSONDecodeError, FileNotFoundError, OSError):
+            # npx not available or unexpected output – fall through
+            pass
+    return False
+
 
 def _get_settings() -> Settings:
     """Retrieve settings stored by the main callback."""
@@ -40,6 +69,28 @@ def login() -> None:
     creds = oauth_pkce_login(settings)
     print_success(f"Authenticated as {creds.email}")
 
+    # Check if the minitest-cli agent skill is installed
+    if not _is_skill_installed():
+        print_info("")
+        print_info("💡 The minitest-cli agent skill is not installed in this project.")
+        print_info("   Your AI agent needs it to know how to use minitest.")
+        print_info("")
+        try:
+            answer = input("   Install it now? [Y/n] ").strip().lower()
+        except (EOFError, KeyboardInterrupt):
+            answer = "n"
+            print()  # newline after ^C / ^D
+        if answer in ("", "y", "yes"):
+            print_info("")
+            print_info(f"   Running: {SKILL_INSTALL_CMD}")
+            print_info("")
+            subprocess.run(SKILL_INSTALL_CMD.split(), check=False)
+        else:
+            print_info("")
+            print_info("   You can install it later with:")
+            print_info(f"   {SKILL_INSTALL_CMD}")
+            print_info("")
+
 
 @app.command()
 def logout() -> None:

minitest_cli-0.5.0/src/minitest_cli/commands/maintenance_check.py

@@ -0,0 +1,52 @@
+"""Maintenance check command - acknowledge test freshness for a commit."""
+
+from typing import Annotated
+
+import typer
+
+from minitest_cli.api.client import ApiClient
+from minitest_cli.commands.run_helpers import (
+    handle_response_error,
+    resolve_app,
+    run_api_call,
+)
+from minitest_cli.models.maintenance_check import MaintenanceCheckResponse
+from minitest_cli.utils.output import print_json, print_success
+
+app = typer.Typer(name="maintenance-check", help="Test maintenance acknowledgment.")
+
+
+@app.callback(invoke_without_command=True)
+def maintenance_check(
+    ctx: typer.Context,
+    commit_sha: Annotated[str, typer.Argument(help="Git commit SHA to acknowledge.")],
+) -> None:
+    """Acknowledge that tests have been reviewed for a commit."""
+    if ctx.invoked_subcommand is not None:
+        return
+
+    settings, app_id, json_mode = resolve_app()
+
+    async def _acknowledge() -> MaintenanceCheckResponse:
+        async with ApiClient(settings) as client:
+            body = {"commitSha": commit_sha}
+            resp = await client.post(
+                f"/api/v1/apps/{app_id}/maintenance-check",
+                json=body,
+            )
+            handle_response_error(resp, resource="Maintenance check")
+            return MaintenanceCheckResponse.model_validate(resp.json())
+
+    result = run_api_call(_acknowledge())
+
+    if json_mode:
+        print_json(
+            {
+                "id": result.id,
+                "app_id": result.app_id,
+                "commit_sha": result.commit_sha,
+                "created_at": result.created_at,
+            }
+        )
+    else:
+        print_success(f"Tests acknowledged for commit {commit_sha[:8]}")

{minitest_cli-0.4.4 → minitest_cli-0.5.0}/src/minitest_cli/core/oauth.py

@@ -1,4 +1,4 @@
-"""OAuth PKCE login flow and token refresh."""
+"""OAuth PKCE login flow via Supabase OAuth2 server, and token refresh."""
 
 from __future__ import annotations
 
@@ -20,9 +20,8 @@ from minitest_cli.core.config import Settings
 from minitest_cli.core.credentials import Credentials
 from minitest_cli.core.token_exchange import (
     auth_error,
-    get_apikey_header,
     parse_and_save_token_response,
-    require_supabase_url,
+    register_oauth_client,
 )
 
 _ASSETS = importlib.resources.files("minitest_cli.assets")
@@ -59,31 +58,24 @@ def refresh_token(settings: Settings, creds: Credentials) -> Credentials | None:
 
 
 def oauth_pkce_login(settings: Settings) -> Credentials:
-    """Run the full OAuth PKCE login flow.
+    """Run the full OAuth PKCE login flow via Supabase's OAuth2 server.
 
     Steps:
-      1. Generate code verifier + challenge
-      2. Start local callback server
-      3. Open browser to Supabase authorize endpoint
-      4. Wait for callback with auth code
-      5. Exchange code for tokens
-      6. Save and return credentials
+      1. Start local callback server
+      2. Dynamically register an OAuth2 client with Supabase
+      3. Generate PKCE code verifier + challenge
+      4. Open browser to Supabase authorize endpoint (shows hosted sign-in page)
+      5. Wait for callback with authorization code
+      6. Exchange code + verifier for tokens at Supabase token endpoint
+      7. Save and return credentials
     """
-    supabase_url = require_supabase_url(settings)
+    supabase_url = settings.supabase_url.rstrip("/")
 
     # PKCE challenge: base64url(sha256(verifier)) without padding
     code_verifier = secrets.token_urlsafe(64)
     digest = hashlib.sha256(code_verifier.encode()).digest()
     code_challenge = base64.urlsafe_b64encode(digest).rstrip(b"=").decode()
 
-    # CSRF protection: We do NOT generate our own state parameter.
-    # Supabase internally uses 'state' as a FlowState UUID (database key) to track
-    # the OAuth flow context (redirect_to, PKCE params, etc.). If we override it,
-    # Supabase can't find the FlowState record and falls back to Site URL.
-    # We still have CSRF protection via:
-    #   1. Supabase's FlowState UUID (validated on callback)
-    #   2. PKCE (code_challenge + code_verifier) per OAuth 2.1
-
     # Start callback server
     auth_code_holder: dict[str, str | None] = {"code": None, "error": None}
     ready_event = Event()
@@ -122,17 +114,21 @@ def oauth_pkce_login(settings: Settings) -> Credentials:
     port = server.server_address[1]
     redirect_uri = f"http://127.0.0.1:{port}/callback"
 
-    # Build authorize URL (no custom state - see comment above)
+    # Register OAuth client with Supabase (dynamic client registration)
+    client_id = register_oauth_client(supabase_url, redirect_uri)
+
+    # Build authorize URL — Supabase's OAuth2 server shows its hosted sign-in page
     authorize_params = urllib.parse.urlencode(
         {
-            "provider": "google",
+            "client_id": client_id,
+            "redirect_uri": redirect_uri,
             "response_type": "code",
             "code_challenge": code_challenge,
             "code_challenge_method": "S256",
-            "redirect_to": redirect_uri,
+            "scope": "openid email profile",
         }
     )
-    authorize_url = f"{supabase_url}/auth/v1/authorize?{authorize_params}"
+    authorize_url = f"{supabase_url}/auth/v1/oauth/authorize?{authorize_params}"
 
     print("Opening browser for authentication...", file=sys.stderr)  # noqa: T201
     print(f"If the browser doesn't open, visit:\n{authorize_url}", file=sys.stderr)  # noqa: T201
@@ -156,16 +152,19 @@ def oauth_pkce_login(settings: Settings) -> Credentials:
     if not auth_code:
         auth_error("No authorization code received.")
 
-    # Exchange code for tokens (Supabase uses grant_type=pkce for PKCE flow)
+    # Exchange code for tokens at Supabase's OAuth2 token endpoint
     assert auth_code is not None  # for type narrowing
     try:
         token_response = httpx.post(
-            f"{supabase_url}/auth/v1/token?grant_type=pkce",
-            json={
-                "auth_code": auth_code,
+            f"{supabase_url}/auth/v1/oauth/token",
+            data={
+                "grant_type": "authorization_code",
+                "code": auth_code,
+                "redirect_uri": redirect_uri,
+                "client_id": client_id,
                 "code_verifier": code_verifier,
             },
-            headers={"Content-Type": "application/json", "apikey": get_apikey_header(settings)},
+            headers={"Content-Type": "application/x-www-form-urlencoded"},
             timeout=15.0,
         )
     except httpx.HTTPError as exc:

{minitest_cli-0.4.4 → minitest_cli-0.5.0}/src/minitest_cli/core/token_exchange.py

@@ -6,6 +6,8 @@ import sys
 import time
 from typing import Any, NoReturn
 
+import httpx
+
 from minitest_cli.core.config import Settings
 from minitest_cli.core.credentials import Credentials, save_credentials
 
@@ -51,6 +53,42 @@ def parse_and_save_token_response(settings: Settings, data: dict[str, Any]) -> C
         return None
 
 
+def register_oauth_client(supabase_url: str, redirect_uri: str) -> str:
+    """Dynamically register an OAuth2 client with Supabase and return the client_id."""
+    register_url = f"{supabase_url}/auth/v1/oauth/clients/register"
+    try:
+        resp = httpx.post(
+            register_url,
+            json={
+                "client_name": "minitest-cli",
+                "redirect_uris": [redirect_uri],
+                "grant_types": ["authorization_code", "refresh_token"],
+                "response_types": ["code"],
+                "token_endpoint_auth_method": "none",
+            },
+            headers={"Content-Type": "application/json"},
+            timeout=15.0,
+        )
+    except httpx.HTTPError as exc:
+        auth_error(f"Failed to register OAuth client: {exc}")
+
+    if resp.status_code not in (200, 201):
+        auth_error(f"OAuth client registration failed: {resp.text}")
+
+    try:
+        data = resp.json()
+    except ValueError:
+        auth_error(
+            f"OAuth client registration returned invalid response "
+            f"(HTTP {resp.status_code}): {resp.text}"
+        )
+
+    client_id: str | None = data.get("client_id")
+    if not client_id:
+        auth_error("OAuth client registration returned no client_id.")
+    return client_id  # type: ignore[return-value]
+
+
 def auth_error(message: str) -> NoReturn:
     """Print auth error to stderr and exit with code 2."""
     print(f"Error: {message}", file=sys.stderr)  # noqa: T201

{minitest_cli-0.4.4 → minitest_cli-0.5.0}/src/minitest_cli/main.py

@@ -5,7 +5,7 @@ from typing import Annotated
 import typer
 
 from minitest_cli import __version__
-from minitest_cli.commands import apps, auth, build, flow, run, skill
+from minitest_cli.commands import apps, auth, build, flow, maintenance_check, run, skill
 from minitest_cli.core.config import get_settings
 from minitest_cli.utils.update_check import check_for_updates
 
@@ -21,6 +21,7 @@ app.add_typer(auth.app)
 app.add_typer(apps.app)
 app.add_typer(flow.app)
 app.add_typer(build.app)
+app.add_typer(maintenance_check.app)
 app.add_typer(run.app)
 app.add_typer(skill.app)
 

minitest_cli-0.5.0/src/minitest_cli/models/maintenance_check.py

@@ -0,0 +1,12 @@
+"""Models for maintenance check responses."""
+
+from minitest_cli.models.base import CamelModel
+
+
+class MaintenanceCheckResponse(CamelModel):
+    """Response from creating a maintenance check acknowledgment."""
+
+    id: str
+    app_id: str
+    commit_sha: str
+    created_at: str

{minitest_cli-0.4.4 → minitest_cli-0.5.0}/uv.lock

@@ -141,7 +141,7 @@ wheels = [
 
 [[package]]
 name = "minitest-cli"
-version = "0.4.3"
+version = "0.5.0"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },

minitest_cli-0.4.4/README.md

@@ -1,125 +0,0 @@
-# minitest-cli
-
-Command-line interface for the Minitest testing platform.
-
-## Installation
-
-### pip (recommended)
-
-```bash
-pip install minitest-cli
-```
-
-### uvx (zero-install)
-
-Run without installing:
-
-```bash
-uvx --from minitest-cli minitest --help
-```
-
-### Homebrew
-
-```bash
-brew install minitap-ai/tap/minitest-cli
-```
-
-### From source
-
-```bash
-git clone https://github.com/minitap-ai/minitest-cli.git
-cd minitest-cli
-uv sync
-uv run minitest --help
-```
-
-## Quick Start
-
-```bash
-# Authenticate
-minitest auth login
-
-# List your apps
-minitest apps list
-
-# Run tests
-minitest run --app <app-id>
-```
-
-## Configuration
-
-| Environment Variable | Description | Required |
-|---------------------|-------------|----------|
-| `MINITEST_TOKEN` | API authentication token | Yes (or use `minitest auth login`) |
-| `MINITEST_APP_ID` | Default app ID | No (can use `--app` flag) |
-| `MINITEST_API_URL` | API base URL | No (defaults to production) |
-
-## Global Flags
-
-| Flag | Description |
-|------|-------------|
-| `--json` | Output JSON to stdout (diagnostics go to stderr) |
-| `--app <id-or-name>` | Target app for commands that require one |
-| `--version` | Show CLI version |
-| `--help` | Show help |
-
-## Commands
-
-| Command | Description |
-|---------|-------------|
-| `minitest auth` | Authentication management |
-| `minitest apps` | App management |
-| `minitest flow` | Testing flow operations |
-| `minitest build` | Build management |
-| `minitest run` | Test execution |
-
-## Exit Codes
-
-| Code | Meaning |
-|------|---------|
-| 0 | Success |
-| 1 | General error |
-| 2 | Authentication error |
-| 3 | Network / API error |
-| 4 | Resource not found |
-
-## Using the Dev Environment
-
-To point the CLI at the **dev** environment instead of production, set these environment variables when running `minitest`:
-
-```bash
-MINITEST_SUPABASE_URL=https://qrezuucghnmfvaxghqsv.supabase.co \
-MINITEST_SUPABASE_PUBLISHABLE_KEY=sb_publishable_4JRhoCm8pa5PbII0dhS09A_jhpkQhmy \
-MINITEST_API_URL=https://testing-service.dev.minitap.ai \
-minitest auth login
-```
-
-This authenticates against the dev environment and stores a dev-specific auth token. After logging in, keep the same variables set for all subsequent commands:
-
-```bash
-MINITEST_SUPABASE_URL=https://qrezuucghnmfvaxghqsv.supabase.co \
-MINITEST_SUPABASE_PUBLISHABLE_KEY=sb_publishable_4JRhoCm8pa5PbII0dhS09A_jhpkQhmy \
-MINITEST_API_URL=https://testing-service.dev.minitap.ai \
-minitest apps list
-```
-
-> **Tip:** You can `export` these variables in your shell session (or add them to a `.envrc` / `.env` file) to avoid repeating them on every invocation.
-
-## Development
-
-```bash
-# Install dependencies
-uv sync --dev
-
-# Run linter
-uv run ruff check .
-
-# Run formatter
-uv run ruff format .
-
-# Run type checker
-uv run pyright
-
-# Run tests
-uv run pytest
-```