aws-bootstrap-g4dn 0.6.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

aws_bootstrap/ec2.py

@@ -7,6 +7,7 @@ import botocore.exceptions
 import click
 
 from .config import LaunchConfig
+from .output import echo, is_text, secho
 
 
 EBS_DEVICE_NAME = "/dev/sdf"
@@ -81,7 +82,7 @@ def ensure_security_group(ec2_client, name: str, tag_value: str, ssh_port: int =
     if existing["SecurityGroups"]:
         sg_id = existing["SecurityGroups"][0]["GroupId"]
         msg = "  Security group " + click.style(f"'{name}'", fg="bright_white")
-        click.echo(msg + f" already exists ({sg_id}), reusing.")
+        echo(msg + f" already exists ({sg_id}), reusing.")
         return sg_id
 
     # Create new SG
@@ -113,7 +114,7 @@ def ensure_security_group(ec2_client, name: str, tag_value: str, ssh_port: int =
             }
         ],
     )
-    click.secho(f"  Created security group '{name}' ({sg_id}) with SSH ingress.", fg="green")
+    secho(f"  Created security group '{name}' ({sg_id}) with SSH ingress.", fg="green")
     return sg_id
 
 
@@ -163,8 +164,8 @@ def launch_instance(ec2_client, config: LaunchConfig, ami_id: str, sg_id: str) -
         if code in ("MaxSpotInstanceCountExceeded", "VcpuLimitExceeded"):
             _raise_quota_error(code, config)
         elif code in ("InsufficientInstanceCapacity", "SpotMaxPriceTooLow") and config.spot:
-            click.secho(f"\n  Spot request failed: {e.response['Error']['Message']}", fg="yellow")
-            if click.confirm("  Retry as on-demand instance?"):
+            secho(f"\n  Spot request failed: {e.response['Error']['Message']}", fg="yellow")
+            if not is_text() or click.confirm("  Retry as on-demand instance?"):
                 launch_params.pop("InstanceMarketOptions", None)
                 try:
                     response = ec2_client.run_instances(**launch_params)
@@ -329,15 +330,15 @@ def terminate_tagged_instances(ec2_client, instance_ids: list[str]) -> list[dict
 
 def wait_instance_ready(ec2_client, instance_id: str) -> dict:
     """Wait for the instance to be running and pass status checks."""
-    click.echo("  Waiting for instance " + click.style(instance_id, fg="bright_white") + " to enter 'running' state...")
+    echo("  Waiting for instance " + click.style(instance_id, fg="bright_white") + " to enter 'running' state...")
     waiter = ec2_client.get_waiter("instance_running")
     waiter.wait(InstanceIds=[instance_id], WaiterConfig={"Delay": 10, "MaxAttempts": 60})
-    click.secho("  Instance running.", fg="green")
+    secho("  Instance running.", fg="green")
 
-    click.echo("  Waiting for instance status checks to pass...")
+    echo("  Waiting for instance status checks to pass...")
     waiter = ec2_client.get_waiter("instance_status_ok")
     waiter.wait(InstanceIds=[instance_id], WaiterConfig={"Delay": 15, "MaxAttempts": 60})
-    click.secho("  Status checks passed.", fg="green")
+    secho("  Status checks passed.", fg="green")
 
     # Refresh instance info to get public IP
     desc = ec2_client.describe_instances(InstanceIds=[instance_id])

aws_bootstrap/output.py

@@ -0,0 +1,106 @@
+"""Output formatting for structured CLI output (JSON, YAML, table, text)."""
+
+from __future__ import annotations
+import json
+from datetime import datetime
+from enum import StrEnum
+from pathlib import Path
+from typing import Any
+
+import click
+
+
+class OutputFormat(StrEnum):
+    TEXT = "text"
+    JSON = "json"
+    YAML = "yaml"
+    TABLE = "table"
+
+
+def get_format(ctx: click.Context | None = None) -> OutputFormat:
+    """Return the current output format from the click context."""
+    if ctx is None:
+        ctx = click.get_current_context(silent=True)
+    if ctx is None or ctx.obj is None:
+        return OutputFormat.TEXT
+    return ctx.obj.get("output_format", OutputFormat.TEXT)
+
+
+def is_text(ctx: click.Context | None = None) -> bool:
+    """Return True if the current output format is text (default)."""
+    return get_format(ctx) == OutputFormat.TEXT
+
+
+def _default_serializer(obj: Any) -> Any:
+    """JSON serializer for objects not serializable by default."""
+    if isinstance(obj, datetime):
+        return obj.isoformat()
+    if isinstance(obj, Path):
+        return str(obj)
+    raise TypeError(f"Object of type {type(obj).__name__} is not JSON serializable")
+
+
+def emit(data: dict | list, *, headers: dict[str, str] | None = None, ctx: click.Context | None = None) -> None:
+    """Emit structured data in the configured output format.
+
+    For JSON/YAML: serializes the data directly.
+    For TABLE: renders using tabulate. If *data* is a list of dicts, uses
+    *headers* mapping ``{dict_key: column_label}`` for column selection/ordering.
+    If *data* is a single dict, renders as key-value pairs.
+    """
+    fmt = get_format(ctx)
+
+    if fmt == OutputFormat.JSON:
+        click.echo(json.dumps(data, indent=2, default=_default_serializer))
+        return
+
+    if fmt == OutputFormat.YAML:
+        import yaml  # noqa: PLC0415
+
+        # Convert datetime/Path objects before YAML dump
+        prepared = json.loads(json.dumps(data, default=_default_serializer))
+        click.echo(yaml.dump(prepared, default_flow_style=False, sort_keys=False).rstrip())
+        return
+
+    if fmt == OutputFormat.TABLE:
+        from tabulate import tabulate  # noqa: PLC0415
+
+        table_data = data
+        # Unwrap dict-wrapped lists (e.g. {"instances": [...]}) for table rendering
+        if isinstance(data, dict) and headers:
+            for v in data.values():
+                if isinstance(v, list):
+                    table_data = v
+                    break
+
+        if isinstance(table_data, list) and table_data and isinstance(table_data[0], dict):
+            if headers:
+                keys = list(headers.keys())
+                col_labels = list(headers.values())
+                rows = [[row.get(k, "") for k in keys] for row in table_data]
+            else:
+                col_labels = list(table_data[0].keys())
+                keys = col_labels
+                rows = [[row.get(k, "") for k in keys] for row in table_data]
+            click.echo(tabulate(rows, headers=col_labels, tablefmt="simple"))
+        elif isinstance(table_data, dict):
+            rows = [[k, v] for k, v in table_data.items()]
+            click.echo(tabulate(rows, headers=["Key", "Value"], tablefmt="simple"))
+        elif isinstance(table_data, list):
+            # Empty list
+            click.echo("(no data)")
+        return
+
+    # TEXT format: emit() is a no-op in text mode (text output is handled inline)
+
+
+def echo(msg: str = "", **kwargs: Any) -> None:
+    """Wrap ``click.echo``; silent in non-text output modes."""
+    if is_text():
+        click.echo(msg, **kwargs)
+
+
+def secho(msg: str = "", **kwargs: Any) -> None:
+    """Wrap ``click.secho``; silent in non-text output modes."""
+    if is_text():
+        click.secho(msg, **kwargs)

aws_bootstrap/ssh.py

@@ -13,6 +13,7 @@ from pathlib import Path
 import click
 
 from .gpu import _GPU_ARCHITECTURES, GpuInfo
+from .output import echo, secho
 
 
 # ---------------------------------------------------------------------------
@@ -54,7 +55,7 @@ def import_key_pair(ec2_client, key_name: str, key_path: Path) -> str:
     # Check if key pair already exists
     try:
         existing = ec2_client.describe_key_pairs(KeyNames=[key_name])
-        click.echo("  Key pair " + click.style(f"'{key_name}'", fg="bright_white") + " already exists, reusing.")
+        echo("  Key pair " + click.style(f"'{key_name}'", fg="bright_white") + " already exists, reusing.")
         return existing["KeyPairs"][0]["KeyName"]
     except ec2_client.exceptions.ClientError as e:
         if "InvalidKeyPair.NotFound" not in str(e):
@@ -70,7 +71,7 @@ def import_key_pair(ec2_client, key_name: str, key_path: Path) -> str:
             }
         ],
     )
-    click.secho(f"  Imported key pair '{key_name}' from {key_path}", fg="green")
+    secho(f"  Imported key pair '{key_name}' from {key_path}", fg="green")
     return key_name
 
 
@@ -88,7 +89,7 @@ def wait_for_ssh(host: str, user: str, key_path: Path, retries: int = 30, delay:
             sock = socket.create_connection((host, port), timeout=5)
             sock.close()
         except (TimeoutError, ConnectionRefusedError, OSError):
-            click.echo("  SSH not ready " + click.style(f"(attempt {attempt}/{retries})", dim=True) + ", waiting...")
+            echo("  SSH not ready " + click.style(f"(attempt {attempt}/{retries})", dim=True) + ", waiting...")
             time.sleep(delay)
             continue
 
@@ -106,10 +107,10 @@ def wait_for_ssh(host: str, user: str, key_path: Path, retries: int = 30, delay:
         ]
         result = subprocess.run(cmd, capture_output=True, text=True)
         if result.returncode == 0:
-            click.secho("  SSH connection established.", fg="green")
+            secho("  SSH connection established.", fg="green")
             return True
 
-        click.echo("  SSH not ready " + click.style(f"(attempt {attempt}/{retries})", dim=True) + ", waiting...")
+        echo("  SSH not ready " + click.style(f"(attempt {attempt}/{retries})", dim=True) + ", waiting...")
         time.sleep(delay)
 
     return False
@@ -125,89 +126,89 @@ def run_remote_setup(
     requirements_path = script_path.parent / "requirements.txt"
 
     # SCP the requirements file
-    click.echo("  Uploading requirements.txt...")
+    echo("  Uploading requirements.txt...")
     req_result = subprocess.run(
         ["scp", *ssh_opts, *scp_port_opts, str(requirements_path), f"{user}@{host}:/tmp/requirements.txt"],
         capture_output=True,
         text=True,
     )
     if req_result.returncode != 0:
-        click.secho(f"  SCP failed: {req_result.stderr}", fg="red", err=True)
+        secho(f"  SCP failed: {req_result.stderr}", fg="red", err=True)
         return False
 
     # SCP the GPU benchmark script
     benchmark_path = script_path.parent / "gpu_benchmark.py"
-    click.echo("  Uploading gpu_benchmark.py...")
+    echo("  Uploading gpu_benchmark.py...")
     bench_result = subprocess.run(
         ["scp", *ssh_opts, *scp_port_opts, str(benchmark_path), f"{user}@{host}:/tmp/gpu_benchmark.py"],
         capture_output=True,
         text=True,
     )
     if bench_result.returncode != 0:
-        click.secho(f"  SCP failed: {bench_result.stderr}", fg="red", err=True)
+        secho(f"  SCP failed: {bench_result.stderr}", fg="red", err=True)
         return False
 
     # SCP the GPU smoke test notebook
     notebook_path = script_path.parent / "gpu_smoke_test.ipynb"
-    click.echo("  Uploading gpu_smoke_test.ipynb...")
+    echo("  Uploading gpu_smoke_test.ipynb...")
     nb_result = subprocess.run(
         ["scp", *ssh_opts, *scp_port_opts, str(notebook_path), f"{user}@{host}:/tmp/gpu_smoke_test.ipynb"],
         capture_output=True,
         text=True,
     )
     if nb_result.returncode != 0:
-        click.secho(f"  SCP failed: {nb_result.stderr}", fg="red", err=True)
+        secho(f"  SCP failed: {nb_result.stderr}", fg="red", err=True)
         return False
 
     # SCP the CUDA example source
     saxpy_path = script_path.parent / "saxpy.cu"
-    click.echo("  Uploading saxpy.cu...")
+    echo("  Uploading saxpy.cu...")
     saxpy_result = subprocess.run(
         ["scp", *ssh_opts, *scp_port_opts, str(saxpy_path), f"{user}@{host}:/tmp/saxpy.cu"],
         capture_output=True,
         text=True,
     )
     if saxpy_result.returncode != 0:
-        click.secho(f"  SCP failed: {saxpy_result.stderr}", fg="red", err=True)
+        secho(f"  SCP failed: {saxpy_result.stderr}", fg="red", err=True)
         return False
 
     # SCP the VSCode launch.json
     launch_json_path = script_path.parent / "launch.json"
-    click.echo("  Uploading launch.json...")
+    echo("  Uploading launch.json...")
     launch_result = subprocess.run(
         ["scp", *ssh_opts, *scp_port_opts, str(launch_json_path), f"{user}@{host}:/tmp/launch.json"],
         capture_output=True,
         text=True,
     )
     if launch_result.returncode != 0:
-        click.secho(f"  SCP failed: {launch_result.stderr}", fg="red", err=True)
+        secho(f"  SCP failed: {launch_result.stderr}", fg="red", err=True)
         return False
 
     # SCP the VSCode tasks.json
     tasks_json_path = script_path.parent / "tasks.json"
-    click.echo("  Uploading tasks.json...")
+    echo("  Uploading tasks.json...")
     tasks_result = subprocess.run(
         ["scp", *ssh_opts, *scp_port_opts, str(tasks_json_path), f"{user}@{host}:/tmp/tasks.json"],
         capture_output=True,
         text=True,
     )
     if tasks_result.returncode != 0:
-        click.secho(f"  SCP failed: {tasks_result.stderr}", fg="red", err=True)
+        secho(f"  SCP failed: {tasks_result.stderr}", fg="red", err=True)
         return False
 
     # SCP the script
-    click.echo("  Uploading remote_setup.sh...")
+    echo("  Uploading remote_setup.sh...")
     scp_result = subprocess.run(
         ["scp", *ssh_opts, *scp_port_opts, str(script_path), f"{user}@{host}:/tmp/remote_setup.sh"],
         capture_output=True,
         text=True,
     )
     if scp_result.returncode != 0:
-        click.secho(f"  SCP failed: {scp_result.stderr}", fg="red", err=True)
+        secho(f"  SCP failed: {scp_result.stderr}", fg="red", err=True)
         return False
 
     # Execute the script, passing PYTHON_VERSION as an inline env var if specified
-    click.echo("  Running remote_setup.sh on instance...")
+    echo("  Running remote_setup.sh on instance...")
     remote_cmd = "chmod +x /tmp/remote_setup.sh && "
     if python_version:
         remote_cmd += f"PYTHON_VERSION={python_version} "

aws_bootstrap/tests/test_cli.py

@@ -1,11 +1,13 @@
 """Tests for CLI entry point and help output."""
 
 from __future__ import annotations
+import json
 from datetime import UTC, datetime
 from pathlib import Path
 from unittest.mock import MagicMock, patch
 
 import botocore.exceptions
+import yaml
 from click.testing import CliRunner
 
 from aws_bootstrap.cli import main
@@ -1254,3 +1256,281 @@ def test_cleanup_with_yes(mock_find, mock_session, mock_stale, mock_cleanup):
     assert "Removed aws-gpu1" in result.output
     assert "Cleaned up 1" in result.output
     mock_cleanup.assert_called_once()
+
+
+# ---------------------------------------------------------------------------
+# --output structured format tests
+# ---------------------------------------------------------------------------
+
+
+def test_help_shows_output_option():
+    runner = CliRunner()
+    result = runner.invoke(main, ["--help"])
+    assert result.exit_code == 0
+    assert "--output" in result.output
+    assert "-o" in result.output
+
+
+@patch("aws_bootstrap.cli.find_ebs_volumes_for_instance", return_value=[])
+@patch("aws_bootstrap.cli.get_ssh_host_details", return_value=None)
+@patch("aws_bootstrap.cli.list_ssh_hosts", return_value={})
+@patch("aws_bootstrap.cli.boto3.Session")
+@patch("aws_bootstrap.cli.get_spot_price")
+@patch("aws_bootstrap.cli.find_tagged_instances")
+def test_status_output_json(mock_find, mock_spot_price, mock_session, mock_ssh_hosts, mock_details, mock_ebs):
+    mock_find.return_value = [
+        {
+            "InstanceId": "i-abc123",
+            "Name": "aws-bootstrap-g4dn.xlarge",
+            "State": "running",
+            "InstanceType": "g4dn.xlarge",
+            "PublicIp": "1.2.3.4",
+            "LaunchTime": datetime(2025, 1, 1, tzinfo=UTC),
+            "Lifecycle": "spot",
+            "AvailabilityZone": "us-west-2a",
+        }
+    ]
+    mock_spot_price.return_value = 0.1578
+    runner = CliRunner()
+    result = runner.invoke(main, ["-o", "json", "status"])
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert "instances" in data
+    assert len(data["instances"]) == 1
+    inst = data["instances"][0]
+    assert inst["instance_id"] == "i-abc123"
+    assert inst["state"] == "running"
+    assert inst["instance_type"] == "g4dn.xlarge"
+    assert inst["public_ip"] == "1.2.3.4"
+    assert inst["lifecycle"] == "spot"
+    assert inst["spot_price_per_hour"] == 0.1578
+    assert "uptime_seconds" in inst
+    assert "estimated_cost" in inst
+    # No ANSI or progress text in structured output
+    assert "\x1b[" not in result.output
+    assert "Found" not in result.output
+
+
+@patch("aws_bootstrap.cli.find_ebs_volumes_for_instance", return_value=[])
+@patch("aws_bootstrap.cli.get_ssh_host_details", return_value=None)
+@patch("aws_bootstrap.cli.list_ssh_hosts", return_value={})
+@patch("aws_bootstrap.cli.boto3.Session")
+@patch("aws_bootstrap.cli.get_spot_price")
+@patch("aws_bootstrap.cli.find_tagged_instances")
+def test_status_output_yaml(mock_find, mock_spot_price, mock_session, mock_ssh_hosts, mock_details, mock_ebs):
+    mock_find.return_value = [
+        {
+            "InstanceId": "i-abc123",
+            "Name": "aws-bootstrap-g4dn.xlarge",
+            "State": "running",
+            "InstanceType": "g4dn.xlarge",
+            "PublicIp": "1.2.3.4",
+            "LaunchTime": datetime(2025, 1, 1, tzinfo=UTC),
+            "Lifecycle": "spot",
+            "AvailabilityZone": "us-west-2a",
+        }
+    ]
+    mock_spot_price.return_value = 0.15
+    runner = CliRunner()
+    result = runner.invoke(main, ["-o", "yaml", "status"])
+    assert result.exit_code == 0
+    data = yaml.safe_load(result.output)
+    assert "instances" in data
+    assert data["instances"][0]["instance_id"] == "i-abc123"
+
+
+@patch("aws_bootstrap.cli.find_ebs_volumes_for_instance", return_value=[])
+@patch("aws_bootstrap.cli.get_ssh_host_details", return_value=None)
+@patch("aws_bootstrap.cli.list_ssh_hosts", return_value={})
+@patch("aws_bootstrap.cli.boto3.Session")
+@patch("aws_bootstrap.cli.get_spot_price")
+@patch("aws_bootstrap.cli.find_tagged_instances")
+def test_status_output_table(mock_find, mock_spot_price, mock_session, mock_ssh_hosts, mock_details, mock_ebs):
+    mock_find.return_value = [
+        {
+            "InstanceId": "i-abc123",
+            "Name": "aws-bootstrap-g4dn.xlarge",
+            "State": "running",
+            "InstanceType": "g4dn.xlarge",
+            "PublicIp": "1.2.3.4",
+            "LaunchTime": datetime(2025, 1, 1, tzinfo=UTC),
+            "Lifecycle": "spot",
+            "AvailabilityZone": "us-west-2a",
+        }
+    ]
+    mock_spot_price.return_value = 0.15
+    runner = CliRunner()
+    result = runner.invoke(main, ["-o", "table", "status"])
+    assert result.exit_code == 0
+    assert "Instance ID" in result.output
+    assert "i-abc123" in result.output
+
+
+@patch("aws_bootstrap.cli.boto3.Session")
+@patch("aws_bootstrap.cli.find_tagged_instances")
+def test_status_no_instances_json(mock_find, mock_session):
+    mock_find.return_value = []
+    runner = CliRunner()
+    result = runner.invoke(main, ["-o", "json", "status"])
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert data == {"instances": []}
+
+
+@patch("aws_bootstrap.cli.boto3.Session")
+@patch("aws_bootstrap.cli.get_latest_ami")
+@patch("aws_bootstrap.cli.import_key_pair", return_value="aws-bootstrap-key")
+@patch("aws_bootstrap.cli.ensure_security_group", return_value="sg-123")
+def test_launch_output_json_dry_run(mock_sg, mock_import, mock_ami, mock_session, tmp_path):
+    mock_ami.return_value = {"ImageId": "ami-123", "Name": "TestAMI"}
+
+    key_path = tmp_path / "id_ed25519.pub"
+    key_path.write_text("ssh-ed25519 AAAA test@host")
+
+    runner = CliRunner()
+    result = runner.invoke(main, ["-o", "json", "launch", "--key-path", str(key_path), "--dry-run"])
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert data["dry_run"] is True
+    assert data["instance_type"] == "g4dn.xlarge"
+    assert data["ami_id"] == "ami-123"
+    assert data["pricing"] == "spot"
+    assert data["region"] == "us-west-2"
+
+
+@patch("aws_bootstrap.cli.remove_ssh_host", return_value="aws-gpu1")
+@patch("aws_bootstrap.cli.boto3.Session")
+@patch("aws_bootstrap.cli.find_tagged_instances")
+@patch("aws_bootstrap.cli.terminate_tagged_instances")
+def test_terminate_output_json(mock_terminate, mock_find, mock_session, mock_remove_ssh):
+    mock_find.return_value = [
+        {
+            "InstanceId": "i-abc123",
+            "Name": "test",
+            "State": "running",
+            "InstanceType": "g4dn.xlarge",
+            "PublicIp": "1.2.3.4",
+            "LaunchTime": datetime(2025, 1, 1, tzinfo=UTC),
+        }
+    ]
+    mock_terminate.return_value = [
+        {
+            "InstanceId": "i-abc123",
+            "PreviousState": {"Name": "running"},
+            "CurrentState": {"Name": "shutting-down"},
+        }
+    ]
+    runner = CliRunner()
+    result = runner.invoke(main, ["-o", "json", "terminate", "--yes"])
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert "terminated" in data
+    assert len(data["terminated"]) == 1
+    assert data["terminated"][0]["instance_id"] == "i-abc123"
+    assert data["terminated"][0]["previous_state"] == "running"
+    assert data["terminated"][0]["current_state"] == "shutting-down"
+    assert data["terminated"][0]["ssh_alias_removed"] == "aws-gpu1"
+
+
+@patch("aws_bootstrap.cli.cleanup_stale_ssh_hosts")
+@patch("aws_bootstrap.cli.find_stale_ssh_hosts", return_value=[("i-dead1234", "aws-gpu1")])
+@patch("aws_bootstrap.cli.boto3.Session")
+@patch("aws_bootstrap.cli.find_tagged_instances", return_value=[])
+def test_cleanup_output_json(mock_find, mock_session, mock_stale, mock_cleanup):
+    mock_cleanup.return_value = [CleanupResult(instance_id="i-dead1234", alias="aws-gpu1", removed=True)]
+    runner = CliRunner()
+    result = runner.invoke(main, ["-o", "json", "cleanup", "--yes"])
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert "cleaned" in data
+    assert len(data["cleaned"]) == 1
+    assert data["cleaned"][0]["instance_id"] == "i-dead1234"
+    assert data["cleaned"][0]["alias"] == "aws-gpu1"
+    assert data["cleaned"][0]["removed"] is True
+
+
+@patch("aws_bootstrap.cli.find_stale_ssh_hosts", return_value=[("i-dead1234", "aws-gpu1")])
+@patch("aws_bootstrap.cli.boto3.Session")
+@patch("aws_bootstrap.cli.find_tagged_instances", return_value=[])
+def test_cleanup_dry_run_json(mock_find, mock_session, mock_stale):
+    runner = CliRunner()
+    result = runner.invoke(main, ["-o", "json", "cleanup", "--dry-run"])
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert data["dry_run"] is True
+    assert "stale" in data
+    assert data["stale"][0]["alias"] == "aws-gpu1"
+
+
+@patch("aws_bootstrap.cli.boto3.Session")
+@patch("aws_bootstrap.cli.list_instance_types")
+def test_list_instance_types_json(mock_list, mock_session):
+    mock_list.return_value = [
+        {
+            "InstanceType": "g4dn.xlarge",
+            "VCpuCount": 4,
+            "MemoryMiB": 16384,
+            "GpuSummary": "1x T4 (16384 MiB)",
+        },
+    ]
+    runner = CliRunner()
+    result = runner.invoke(main, ["-o", "json", "list", "instance-types"])
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert isinstance(data, list)
+    assert data[0]["instance_type"] == "g4dn.xlarge"
+    assert data[0]["vcpus"] == 4
+    assert data[0]["memory_mib"] == 16384
+    assert data[0]["gpu"] == "1x T4 (16384 MiB)"
+
+
+@patch("aws_bootstrap.cli.boto3.Session")
+@patch("aws_bootstrap.cli.list_amis")
+def test_list_amis_json(mock_list, mock_session):
+    mock_list.return_value = [
+        {
+            "ImageId": "ami-abc123",
+            "Name": "Deep Learning AMI v42",
+            "CreationDate": "2025-06-01T00:00:00Z",
+            "Architecture": "x86_64",
+        },
+    ]
+    runner = CliRunner()
+    result = runner.invoke(main, ["-o", "json", "list", "amis"])
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert isinstance(data, list)
+    assert data[0]["image_id"] == "ami-abc123"
+    assert data[0]["name"] == "Deep Learning AMI v42"
+    assert data[0]["creation_date"] == "2025-06-01"
+
+
+@patch("aws_bootstrap.cli.boto3.Session")
+@patch("aws_bootstrap.cli.find_tagged_instances")
+def test_terminate_json_requires_yes(mock_find, mock_session):
+    """Structured output without --yes should error."""
+    mock_find.return_value = [
+        {
+            "InstanceId": "i-abc123",
+            "Name": "test",
+            "State": "running",
+            "InstanceType": "g4dn.xlarge",
+            "PublicIp": "1.2.3.4",
+            "LaunchTime": datetime(2025, 1, 1, tzinfo=UTC),
+        }
+    ]
+    runner = CliRunner()
+    result = runner.invoke(main, ["-o", "json", "terminate"])
+    assert result.exit_code != 0
+    assert "--yes is required" in result.output
+
+
+@patch("aws_bootstrap.cli.boto3.Session")
+@patch("aws_bootstrap.cli.find_tagged_instances")
+def test_terminate_no_instances_json(mock_find, mock_session):
+    mock_find.return_value = []
+    runner = CliRunner()
+    result = runner.invoke(main, ["-o", "json", "terminate", "--yes"])
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert data == {"terminated": []}