@leejungkiin/awkit 1.7.0 → 1.7.4

package/skills/ios-simulator-skill/scripts/sim_list.py

@@ -0,0 +1,299 @@
+#!/usr/bin/env python3
+"""
+iOS Simulator Listing with Progressive Disclosure
+
+Lists available simulators with token-efficient summaries.
+Full details available on demand via cache IDs.
+
+Achieves 96% token reduction (57k→2k tokens) for common queries.
+
+Usage Examples:
+    # Concise summary (default)
+    python scripts/sim_list.py
+
+    # Get full details for cached list
+    python scripts/sim_list.py --get-details <cache-id>
+
+    # Get recommendations
+    python scripts/sim_list.py --suggest
+
+    # Filter by device type
+    python scripts/sim_list.py --device-type iPhone
+
+Output (default):
+    Simulator Summary [cache-sim-20251028-143052]
+    ├─ Total: 47 devices
+    ├─ Available: 31
+    └─ Booted: 1
+
+    ✓ iPhone 16 Pro (iOS 18.1) [ABC-123...]
+
+    Use --get-details cache-sim-20251028-143052 for full list
+
+Technical Details:
+- Uses xcrun simctl list devices
+- Caches results with 1-hour TTL
+- Reduces output by 96% by default
+- Token efficiency: summary = ~30 tokens, full list = ~1500 tokens
+"""
+
+import argparse
+import json
+import subprocess
+import sys
+from typing import Any
+
+from common import get_cache
+
+
+class SimulatorLister:
+    """Lists iOS simulators with progressive disclosure."""
+
+    def __init__(self):
+        """Initialize lister with cache."""
+        self.cache = get_cache()
+
+    def list_simulators(self) -> dict:
+        """
+        Get list of all simulators.
+
+        Returns:
+            Dict with structure:
+            {
+                "devices": [...],
+                "runtimes": [...],
+                "total_devices": int,
+                "available_devices": int,
+                "booted_devices": [...]
+            }
+        """
+        try:
+            result = subprocess.run(
+                ["xcrun", "simctl", "list", "devices", "--json"],
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+
+            return json.loads(result.stdout)
+        except (subprocess.CalledProcessError, json.JSONDecodeError):
+            return {"devices": {}, "runtimes": []}
+
+    def parse_devices(self, sim_data: dict) -> list[dict]:
+        """
+        Parse simulator data into flat list.
+
+        Returns:
+            List of device dicts with runtime info
+        """
+        devices = []
+
+        devices_by_runtime = sim_data.get("devices", {})
+
+        for runtime_str, device_list in devices_by_runtime.items():
+            # Extract iOS version from runtime string
+            # Format: "iOS 18.1", "tvOS 18", etc.
+            runtime_name = runtime_str.replace(" Simulator", "").strip()
+
+            for device in device_list:
+                devices.append(
+                    {
+                        "name": device.get("name"),
+                        "udid": device.get("udid"),
+                        "state": device.get("state"),
+                        "runtime": runtime_name,
+                        "is_available": device.get("isAvailable", False),
+                    }
+                )
+
+        return devices
+
+    def get_concise_summary(self, devices: list[dict]) -> dict:
+        """
+        Generate concise summary with cache ID.
+
+        Returns 96% fewer tokens than full list.
+        """
+        booted = [d for d in devices if d["state"] == "Booted"]
+        available = [d for d in devices if d["is_available"]]
+        iphone = [d for d in available if "iPhone" in d["name"]]
+
+        # Cache full list for later retrieval
+        cache_id = self.cache.save(
+            {
+                "devices": devices,
+                "timestamp": __import__("datetime").datetime.now().isoformat(),
+            },
+            "simulator-list",
+        )
+
+        return {
+            "cache_id": cache_id,
+            "summary": {
+                "total_devices": len(devices),
+                "available_devices": len(available),
+                "booted_devices": len(booted),
+            },
+            "quick_access": {
+                "booted": booted[:3] if booted else [],
+                "recommended_iphone": iphone[:3] if iphone else [],
+            },
+        }
+
+    def get_full_list(
+        self,
+        cache_id: str,
+        device_type: str | None = None,
+        runtime: str | None = None,
+    ) -> list[dict] | None:
+        """
+        Retrieve full simulator list from cache.
+
+        Args:
+            cache_id: Cache ID from concise summary
+            device_type: Filter by type (iPhone, iPad, etc.)
+            runtime: Filter by iOS version
+
+        Returns:
+            List of devices matching filters
+        """
+        data = self.cache.get(cache_id)
+        if not data:
+            return None
+
+        devices = data.get("devices", [])
+
+        # Apply filters
+        if device_type:
+            devices = [d for d in devices if device_type in d["name"]]
+        if runtime:
+            devices = [d for d in devices if runtime.lower() in d["runtime"].lower()]
+
+        return devices
+
+    def suggest_simulators(self, limit: int = 4) -> list[dict]:
+        """
+        Get simulator recommendations.
+
+        Returns:
+            List of recommended simulators (best candidates for building)
+        """
+        all_sims = self.list_simulators()
+        devices = self.parse_devices(all_sims)
+
+        # Score devices for recommendations
+        scored = []
+        for device in devices:
+            score = 0
+
+            # Prefer booted
+            if device["state"] == "Booted":
+                score += 10
+            # Prefer available
+            if device["is_available"]:
+                score += 5
+            # Prefer recent iOS versions
+            ios_version = device["runtime"]
+            if "18" in ios_version:
+                score += 3
+            elif "17" in ios_version:
+                score += 2
+            # Prefer iPhones over other types
+            if "iPhone" in device["name"]:
+                score += 1
+
+            scored.append({"device": device, "score": score})
+
+        # Sort by score and return top N
+        scored.sort(key=lambda x: x["score"], reverse=True)
+        return [s["device"] for s in scored[:limit]]
+
+
+def format_device(device: dict) -> str:
+    """Format device for display."""
+    state_icon = "✓" if device["state"] == "Booted" else " "
+    avail_icon = "●" if device["is_available"] else "○"
+    name = device["name"]
+    runtime = device["runtime"]
+    udid_short = device["udid"][:8] + "..."
+    return f"{state_icon} {avail_icon} {name} ({runtime}) [{udid_short}]"
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(description="List iOS simulators with progressive disclosure")
+    parser.add_argument(
+        "--get-details",
+        metavar="CACHE_ID",
+        help="Get full details for cached simulator list",
+    )
+    parser.add_argument("--suggest", action="store_true", help="Get simulator recommendations")
+    parser.add_argument(
+        "--device-type",
+        help="Filter by device type (iPhone, iPad, Apple Watch, etc.)",
+    )
+    parser.add_argument("--runtime", help="Filter by iOS version (e.g., iOS-18, iOS-17)")
+    parser.add_argument("--json", action="store_true", help="Output as JSON")
+
+    args = parser.parse_args()
+
+    lister = SimulatorLister()
+
+    # Get full list with details
+    if args.get_details:
+        devices = lister.get_full_list(
+            args.get_details, device_type=args.device_type, runtime=args.runtime
+        )
+
+        if devices is None:
+            print(f"Error: Cache ID not found or expired: {args.get_details}")
+            sys.exit(1)
+
+        if args.json:
+            print(json.dumps(devices, indent=2))
+        else:
+            print(f"Simulators ({len(devices)}):\n")
+            for device in devices:
+                print(f"  {format_device(device)}")
+
+    # Get recommendations
+    elif args.suggest:
+        suggestions = lister.suggest_simulators()
+
+        if args.json:
+            print(json.dumps(suggestions, indent=2))
+        else:
+            print("Recommended Simulators:\n")
+            for i, device in enumerate(suggestions, 1):
+                print(f"{i}. {format_device(device)}")
+
+    # Default: concise summary
+    else:
+        all_sims = lister.list_simulators()
+        devices = lister.parse_devices(all_sims)
+        summary = lister.get_concise_summary(devices)
+
+        if args.json:
+            print(json.dumps(summary, indent=2))
+        else:
+            # Human-readable concise output
+            cache_id = summary["cache_id"]
+            s = summary["summary"]
+            q = summary["quick_access"]
+
+            print(f"Simulator Summary [{cache_id}]")
+            print(f"├─ Total: {s['total_devices']} devices")
+            print(f"├─ Available: {s['available_devices']}")
+            print(f"└─ Booted: {s['booted_devices']}")
+
+            if q["booted"]:
+                print()
+                for device in q["booted"]:
+                    print(f"  {format_device(device)}")
+
+            print()
+            print(f"Use --get-details {cache_id} for full list")
+
+
+if __name__ == "__main__":
+    main()

package/skills/ios-simulator-skill/scripts/simctl_boot.py

@@ -0,0 +1,312 @@
+#!/usr/bin/env python3
+"""
+Boot iOS simulators and wait for readiness.
+
+This script boots one or more simulators and optionally waits for them to reach
+a ready state. It measures boot time and provides progress feedback.
+
+Key features:
+- Boot by UDID or device name
+- Wait for device readiness with configurable timeout
+- Measure boot performance
+- Batch boot operations (boot all, boot by type)
+- Progress reporting for CI/CD pipelines
+"""
+
+import argparse
+import subprocess
+import sys
+import time
+
+from common.device_utils import (
+    get_booted_device_udid,
+    list_simulators,
+    resolve_device_identifier,
+)
+from common.env_config import env_float, env_int
+
+DEFAULT_BOOT_TIMEOUT = env_int("IOS_SIM_BOOT_TIMEOUT", 300)
+BOOT_SUBPROCESS_TIMEOUT = env_int("IOS_SIM_BOOT_SUBPROCESS_TIMEOUT", 60)
+POLL_INTERVAL_SECONDS = env_float("IOS_SIM_POLL_INTERVAL", 0.5, min_value=0.05)
+
+
+class SimulatorBooter:
+    """Boot iOS simulators with optional readiness waiting."""
+
+    def __init__(self, udid: str | None = None):
+        """Initialize booter with optional device UDID."""
+        self.udid = udid
+
+    def boot(
+        self, wait_ready: bool = False, timeout_seconds: int = DEFAULT_BOOT_TIMEOUT
+    ) -> tuple[bool, str]:
+        """
+        Boot simulator and optionally wait for readiness.
+
+        Args:
+            wait_ready: Wait for device to be ready before returning
+            timeout_seconds: Maximum seconds to wait for readiness
+
+        Returns:
+            (success, message) tuple
+        """
+        if not self.udid:
+            return False, "Error: Device UDID not specified"
+
+        start_time = time.time()
+
+        # Check if already booted
+        try:
+            booted = get_booted_device_udid()
+            if booted == self.udid:
+                elapsed = time.time() - start_time
+                return True, (f"Device already booted: {self.udid} " f"[checked in {elapsed:.1f}s]")
+        except RuntimeError:
+            pass  # No booted device, proceed with boot
+
+        # Execute boot command
+        try:
+            cmd = ["xcrun", "simctl", "boot", self.udid]
+            result = subprocess.run(
+                cmd,
+                check=False,
+                capture_output=True,
+                text=True,
+                timeout=BOOT_SUBPROCESS_TIMEOUT,
+            )
+
+            if result.returncode != 0:
+                error = result.stderr.strip()
+                return False, f"Boot failed: {error}"
+        except subprocess.TimeoutExpired:
+            return False, "Boot command timed out"
+        except Exception as e:
+            return False, f"Boot error: {e}"
+
+        # Optionally wait for readiness
+        if wait_ready:
+            ready, wait_message = self._wait_for_ready(timeout_seconds)
+            elapsed = time.time() - start_time
+            if ready:
+                return True, (f"Device booted and ready: {self.udid} " f"[{elapsed:.1f}s total]")
+            return False, wait_message
+
+        elapsed = time.time() - start_time
+        return True, (
+            f"Device booted: {self.udid} [boot in {elapsed:.1f}s] "
+            "(use --wait-ready to wait for availability)"
+        )
+
+    def _wait_for_ready(self, timeout_seconds: int = DEFAULT_BOOT_TIMEOUT) -> tuple[bool, str]:
+        """
+        Wait for device to reach ready state.
+
+        Args:
+            timeout_seconds: Maximum seconds to wait
+
+        Returns:
+            (success, message) tuple
+        """
+        start_time = time.time()
+        poll_interval = POLL_INTERVAL_SECONDS
+        checks = 0
+
+        while time.time() - start_time < timeout_seconds:
+            try:
+                checks += 1
+                # Check if device responds to simctl commands
+                result = subprocess.run(
+                    ["xcrun", "simctl", "spawn", self.udid, "launchctl", "list"],
+                    check=False,
+                    capture_output=True,
+                    text=True,
+                    timeout=5,
+                )
+
+                if result.returncode == 0:
+                    elapsed = time.time() - start_time
+                    return True, (
+                        f"Device ready: {self.udid} " f"[{elapsed:.1f}s, {checks} checks]"
+                    )
+            except (subprocess.TimeoutExpired, RuntimeError):
+                pass  # Not ready yet
+
+            time.sleep(poll_interval)
+
+        elapsed = time.time() - start_time
+        return False, (
+            f"Boot timeout: Device did not reach ready state "
+            f"within {elapsed:.1f}s ({checks} checks)"
+        )
+
+    @staticmethod
+    def boot_all() -> tuple[int, int]:
+        """
+        Boot all available simulators.
+
+        Returns:
+            (succeeded, failed) tuple with counts
+        """
+        simulators = list_simulators(state="available")
+        succeeded = 0
+        failed = 0
+
+        for sim in simulators:
+            booter = SimulatorBooter(udid=sim["udid"])
+            success, _message = booter.boot(wait_ready=False)
+            if success:
+                succeeded += 1
+            else:
+                failed += 1
+
+        return succeeded, failed
+
+    @staticmethod
+    def boot_by_type(device_type: str) -> tuple[int, int]:
+        """
+        Boot all simulators of a specific type.
+
+        Args:
+            device_type: Device type filter (e.g., "iPhone", "iPad")
+
+        Returns:
+            (succeeded, failed) tuple with counts
+        """
+        simulators = list_simulators(state="available")
+        succeeded = 0
+        failed = 0
+
+        for sim in simulators:
+            if device_type.lower() in sim["name"].lower():
+                booter = SimulatorBooter(udid=sim["udid"])
+                success, _message = booter.boot(wait_ready=False)
+                if success:
+                    succeeded += 1
+                else:
+                    failed += 1
+
+        return succeeded, failed
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(description="Boot iOS simulators and wait for readiness")
+    parser.add_argument(
+        "--udid",
+        help="Device UDID or name (required unless using --all or --type)",
+    )
+    parser.add_argument(
+        "--name",
+        help="Device name (alternative to --udid)",
+    )
+    parser.add_argument(
+        "--wait-ready",
+        action="store_true",
+        help="Wait for device to reach ready state",
+    )
+    parser.add_argument(
+        "--timeout",
+        type=int,
+        default=DEFAULT_BOOT_TIMEOUT,
+        help=(
+            f"Timeout for --wait-ready in seconds "
+            f"(default: {DEFAULT_BOOT_TIMEOUT}, override via IOS_SIM_BOOT_TIMEOUT)"
+        ),
+    )
+    parser.add_argument(
+        "--all",
+        action="store_true",
+        help="Boot all available simulators",
+    )
+    parser.add_argument(
+        "--type",
+        help="Boot all simulators of a specific type (e.g., iPhone, iPad)",
+    )
+    parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Output as JSON",
+    )
+
+    args = parser.parse_args()
+
+    # Handle batch operations
+    if args.all:
+        succeeded, failed = SimulatorBooter.boot_all()
+        if args.json:
+            import json
+
+            print(
+                json.dumps(
+                    {
+                        "action": "boot_all",
+                        "succeeded": succeeded,
+                        "failed": failed,
+                        "total": succeeded + failed,
+                    }
+                )
+            )
+        else:
+            total = succeeded + failed
+            print(f"Boot summary: {succeeded}/{total} succeeded, " f"{failed} failed")
+        sys.exit(0 if failed == 0 else 1)
+
+    if args.type:
+        succeeded, failed = SimulatorBooter.boot_by_type(args.type)
+        if args.json:
+            import json
+
+            print(
+                json.dumps(
+                    {
+                        "action": "boot_by_type",
+                        "type": args.type,
+                        "succeeded": succeeded,
+                        "failed": failed,
+                        "total": succeeded + failed,
+                    }
+                )
+            )
+        else:
+            total = succeeded + failed
+            print(f"Boot {args.type} summary: {succeeded}/{total} succeeded, " f"{failed} failed")
+        sys.exit(0 if failed == 0 else 1)
+
+    # Resolve device identifier
+    device_id = args.udid or args.name
+    if not device_id:
+        print("Error: Specify --udid, --name, --all, or --type", file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        udid = resolve_device_identifier(device_id)
+    except RuntimeError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    # Boot device
+    booter = SimulatorBooter(udid=udid)
+    success, message = booter.boot(wait_ready=args.wait_ready, timeout_seconds=args.timeout)
+
+    if args.json:
+        import json
+
+        print(
+            json.dumps(
+                {
+                    "action": "boot",
+                    "device_id": device_id,
+                    "udid": udid,
+                    "success": success,
+                    "message": message,
+                }
+            )
+        )
+    else:
+        print(message)
+
+    sys.exit(0 if success else 1)
+
+
+if __name__ == "__main__":
+    main()