wafer-cli 0.2.7__py3-none-any.whl → 0.2.9__py3-none-any.whl

wafer/targets.py

@@ -257,6 +257,220 @@ def get_default_target() -> str | None:
     return data.get("default_target")
 
 
+# ── Pool Management ─────────────────────────────────────────────────────────
+
+
+def get_pool(name: str) -> list[str]:
+    """Get list of targets in a named pool.
+
+    Pools are defined in ~/.wafer/config.toml:
+        [pools.my-pool]
+        targets = ["target-1", "target-2", "target-3"]
+
+    Args:
+        name: Pool name
+
+    Returns:
+        List of target names in the pool
+
+    Raises:
+        FileNotFoundError: If pool doesn't exist
+    """
+    if not CONFIG_FILE.exists():
+        raise FileNotFoundError(f"Pool not found: {name} (no config file)")
+
+    with open(CONFIG_FILE, "rb") as f:
+        data = tomllib.load(f)
+
+    pools = data.get("pools", {})
+    if name not in pools:
+        raise FileNotFoundError(
+            f"Pool not found: {name}\n"
+            f"  Define pools in ~/.wafer/config.toml:\n"
+            f"  [pools.{name}]\n"
+            f'  targets = ["target-1", "target-2"]'
+        )
+
+    pool_config = pools[name]
+    targets = pool_config.get("targets", [])
+
+    if not targets:
+        raise ValueError(f"Pool '{name}' has no targets defined")
+
+    return targets
+
+
+def get_target_type(name: str) -> str | None:
+    """Get the type of a target without fully loading it.
+
+    Args:
+        name: Target name
+
+    Returns:
+        Target type string (runpod, digitalocean, baremetal, etc.) or None if not found
+    """
+    path = _target_path(name)
+    if not path.exists():
+        return None
+
+    with open(path, "rb") as f:
+        data = tomllib.load(f)
+
+    return data.get("type")
+
+
+def filter_pool_by_auth(target_names: list[str]) -> tuple[list[str], list[str]]:
+    """Filter pool targets to only those with valid authentication.
+
+    Args:
+        target_names: List of target names to filter
+
+    Returns:
+        Tuple of (usable_targets, skipped_targets)
+    """
+    from wafer_core.auth import get_api_key
+
+    usable = []
+    skipped = []
+
+    for name in target_names:
+        target_type = get_target_type(name)
+        if target_type is None:
+            # Target doesn't exist, skip it
+            skipped.append(name)
+            continue
+
+        # Check auth requirements by target type
+        if target_type == "runpod":
+            if not get_api_key("runpod"):
+                skipped.append(name)
+                continue
+        elif target_type == "digitalocean":
+            if not get_api_key("digitalocean"):
+                skipped.append(name)
+                continue
+        # Other types (baremetal, vm, workspace, modal) don't need runtime API keys
+
+        usable.append(name)
+
+    return usable, skipped
+
+
+def list_pools() -> list[str]:
+    """List all configured pool names.
+
+    Returns:
+        Sorted list of pool names
+    """
+    if not CONFIG_FILE.exists():
+        return []
+
+    with open(CONFIG_FILE, "rb") as f:
+        data = tomllib.load(f)
+
+    return sorted(data.get("pools", {}).keys())
+
+
+def save_pool(name: str, targets: list[str]) -> None:
+    """Save or update a pool configuration.
+
+    Args:
+        name: Pool name
+        targets: List of target names (must all exist)
+
+    Raises:
+        FileNotFoundError: If any target doesn't exist
+    """
+    # Verify all targets exist
+    existing_targets = list_targets()
+    missing = [t for t in targets if t not in existing_targets]
+    if missing:
+        raise FileNotFoundError(f"Targets not found: {', '.join(missing)}")
+
+    _ensure_dirs()
+
+    # Load existing config
+    if CONFIG_FILE.exists():
+        with open(CONFIG_FILE, "rb") as f:
+            data = tomllib.load(f)
+    else:
+        data = {}
+
+    # Update pools section
+    if "pools" not in data:
+        data["pools"] = {}
+
+    data["pools"][name] = {"targets": targets}
+
+    # Write back - need custom handling for nested structure
+    _write_config_with_pools(data)
+
+
+def _write_config_with_pools(data: dict) -> None:
+    """Write config file with pools support.
+
+    Handles the nested [pools.name] TOML structure and preserves
+    existing nested sections like [default], [api], [environments.*].
+    """
+    lines = []
+
+    # Collect nested sections to write after top-level keys
+    nested_sections: dict[str, dict] = {}
+
+    # Write top-level keys first (except pools and nested dicts)
+    for key, value in data.items():
+        if key == "pools":
+            continue
+        if value is None:
+            continue
+        if isinstance(value, dict):
+            # Save nested sections for later
+            nested_sections[key] = value
+        elif isinstance(value, str):
+            lines.append(f'{key} = "{value}"')
+        elif isinstance(value, bool):
+            lines.append(f"{key} = {str(value).lower()}")
+        elif isinstance(value, int | float):
+            lines.append(f"{key} = {value}")
+        elif isinstance(value, list):
+            if all(isinstance(v, int) for v in value):
+                lines.append(f"{key} = {value}")
+            else:
+                formatted = ", ".join(f'"{v}"' if isinstance(v, str) else str(v) for v in value)
+                lines.append(f"{key} = [{formatted}]")
+
+    # Write nested sections (e.g., [default], [api], [environments.foo])
+    for section_name, section_data in nested_sections.items():
+        lines.append("")
+        lines.append(f"[{section_name}]")
+        for key, value in section_data.items():
+            if value is None:
+                continue
+            if isinstance(value, str):
+                lines.append(f'{key} = "{value}"')
+            elif isinstance(value, bool):
+                lines.append(f"{key} = {str(value).lower()}")
+            elif isinstance(value, int | float):
+                lines.append(f"{key} = {value}")
+            elif isinstance(value, list):
+                if all(isinstance(v, int) for v in value):
+                    lines.append(f"{key} = {value}")
+                else:
+                    formatted = ", ".join(f'"{v}"' if isinstance(v, str) else str(v) for v in value)
+                    lines.append(f"{key} = [{formatted}]")
+
+    # Write pools
+    pools = data.get("pools", {})
+    for pool_name, pool_config in pools.items():
+        lines.append("")
+        lines.append(f"[pools.{pool_name}]")
+        targets = pool_config.get("targets", [])
+        formatted = ", ".join(f'"{t}"' for t in targets)
+        lines.append(f"targets = [{formatted}]")
+
+    CONFIG_FILE.write_text("\n".join(lines) + "\n")
+
+
 def set_default_target(name: str) -> None:
     """Set default target.
 
@@ -350,3 +564,279 @@ def get_target_info(target: TargetConfig) -> dict[str, str]:
     info["Compute"] = target.compute_capability
 
     return info
+
+
+# Probe script to run on target - checks available backends
+_PROBE_SCRIPT = """
+import json
+import shutil
+import sys
+
+def probe():
+    result = {
+        "python_version": sys.version.split()[0],
+        "backends": {},
+        "packages": {},
+    }
+
+    # Check Triton
+    try:
+        import triton
+        result["backends"]["triton"] = triton.__version__
+    except ImportError:
+        result["backends"]["triton"] = None
+
+    # Check torch
+    try:
+        import torch
+        result["packages"]["torch"] = torch.__version__
+        result["backends"]["torch"] = torch.__version__
+        result["cuda_available"] = torch.cuda.is_available()
+        if torch.cuda.is_available():
+            result["gpu_name"] = torch.cuda.get_device_name(0)
+            props = torch.cuda.get_device_properties(0)
+            result["compute_capability"] = f"{props.major}.{props.minor}"
+    except ImportError:
+        result["packages"]["torch"] = None
+
+    # Check hipcc (AMD)
+    hipcc = shutil.which("hipcc")
+    result["backends"]["hipcc"] = hipcc
+
+    # Check nvcc (NVIDIA)
+    nvcc = shutil.which("nvcc")
+    result["backends"]["nvcc"] = nvcc
+
+    # Check ROCm version
+    try:
+        with open("/opt/rocm/.info/version", "r") as f:
+            result["rocm_version"] = f.read().strip()
+    except Exception:
+        result["rocm_version"] = None
+
+    # Check CUDA version from nvcc
+    if nvcc:
+        import subprocess
+        try:
+            out = subprocess.check_output([nvcc, "--version"], text=True)
+            for line in out.split("\\n"):
+                if "release" in line.lower():
+                    # Parse "Cuda compilation tools, release 12.1, V12.1.105"
+                    parts = line.split("release")
+                    if len(parts) > 1:
+                        result["cuda_version"] = parts[1].split(",")[0].strip()
+                    break
+        except Exception:
+            pass
+
+    print(json.dumps(result))
+
+if __name__ == "__main__":
+    probe()
+"""
+
+
+class ProbeError(Exception):
+    """Error during target probing with actionable context."""
+
+    pass
+
+
+async def probe_target_capabilities(target: TargetConfig) -> dict[str, Any]:
+    """Probe a target to discover available compilation backends.
+
+    Connects to the target and runs a probe script to check:
+    - Triton availability
+    - torch availability
+    - HIP/CUDA compiler
+    - ROCm/CUDA version
+    - GPU info
+
+    Args:
+        target: Target config
+
+    Returns:
+        Dict with capabilities info
+
+    Raises:
+        ProbeError: With actionable error message on failure
+    """
+    import json
+    import subprocess
+
+    if isinstance(target, RunPodTarget):
+        import trio_asyncio
+        from wafer_core.targets.runpod import RunPodError, get_pod_state, runpod_ssh_context
+
+        # Check if pod exists before trying to connect
+        pod_state = get_pod_state(target.name)
+
+        try:
+            # Need trio_asyncio.open_loop() for asyncssh bridge used by runpod_ssh_context
+            async with trio_asyncio.open_loop():
+                async with runpod_ssh_context(target) as ssh_info:
+                    ssh_target = f"{ssh_info.user}@{ssh_info.host}"
+                    port = ssh_info.port
+                    key_path = target.ssh_key
+
+                    # Find Python and run probe using subprocess (simpler than async ssh)
+                    def run_ssh_cmd(cmd: str) -> tuple[int, str, str]:
+                        try:
+                            result = subprocess.run(
+                                [
+                                    "ssh",
+                                    "-o",
+                                    "StrictHostKeyChecking=no",
+                                    "-o",
+                                    "UserKnownHostsFile=/dev/null",
+                                    "-o",
+                                    "ConnectTimeout=30",
+                                    "-i",
+                                    str(key_path),
+                                    "-p",
+                                    str(port),
+                                    ssh_target,
+                                    cmd,
+                                ],
+                                capture_output=True,
+                                text=True,
+                                timeout=60,
+                            )
+                            return result.returncode, result.stdout, result.stderr
+                        except subprocess.TimeoutExpired:
+                            raise ProbeError(
+                                f"SSH connection timed out\n"
+                                f"  Host: {ssh_target}:{port}\n"
+                                f"  Hint: The pod may be starting up. Try again in 30 seconds."
+                            ) from None
+
+                    # Find Python
+                    python_exe = "python3"
+                    for candidate in [
+                        "/opt/conda/envs/py_3.10/bin/python3",
+                        "/opt/conda/bin/python3",
+                    ]:
+                        code, out, _ = run_ssh_cmd(f"{candidate} --version 2>/dev/null && echo OK")
+                        if code == 0 and "OK" in out:
+                            python_exe = candidate
+                            break
+
+                    # Run probe script
+                    escaped_script = _PROBE_SCRIPT.replace("'", "'\"'\"'")
+                    code, out, err = run_ssh_cmd(f"{python_exe} -c '{escaped_script}'")
+                    if code != 0:
+                        raise ProbeError(
+                            f"Probe script failed on target\n"
+                            f"  Exit code: {code}\n"
+                            f"  Error: {err.strip() if err else 'unknown'}"
+                        )
+
+                    try:
+                        return json.loads(out)
+                    except json.JSONDecodeError as e:
+                        raise ProbeError(
+                            f"Failed to parse probe output\n  Error: {e}\n  Output: {out[:200]}..."
+                        ) from None
+
+        except RunPodError as e:
+            # RunPod API errors (provisioning, pod not found, etc.)
+            raise ProbeError(f"RunPod error for target '{target.name}'\n  {e}") from None
+        except OSError as e:
+            # SSH connection errors
+            if pod_state:
+                raise ProbeError(
+                    f"SSH connection failed to target '{target.name}'\n"
+                    f"  Host: {pod_state.ssh_username}@{pod_state.public_ip}:{pod_state.ssh_port}\n"
+                    f"  Error: {e}\n"
+                    f"  Hint: Check if the pod is still running with 'wafer config targets pods'"
+                ) from None
+            raise ProbeError(
+                f"SSH connection failed to target '{target.name}'\n"
+                f"  Error: {e}\n"
+                f"  Hint: No pod found. One will be provisioned on next probe attempt."
+            ) from None
+
+    elif isinstance(target, (BaremetalTarget, VMTarget)):
+        import subprocess
+
+        # Parse ssh_target (user@host:port or user@host)
+        ssh_target = target.ssh_target
+        if ":" in ssh_target.split("@")[-1]:
+            host_port = ssh_target.split("@")[-1]
+            host = host_port.rsplit(":", 1)[0]
+            port = host_port.rsplit(":", 1)[1]
+            user = ssh_target.split("@")[0]
+            ssh_target = f"{user}@{host}"
+        else:
+            host = ssh_target.split("@")[-1]
+            port = "22"
+            user = ssh_target.split("@")[0]
+
+        key_path = target.ssh_key
+
+        def run_ssh_cmd(cmd: str) -> tuple[int, str, str]:
+            try:
+                result = subprocess.run(
+                    [
+                        "ssh",
+                        "-o",
+                        "StrictHostKeyChecking=no",
+                        "-o",
+                        "UserKnownHostsFile=/dev/null",
+                        "-o",
+                        "ConnectTimeout=30",
+                        "-i",
+                        str(key_path),
+                        "-p",
+                        port,
+                        ssh_target,
+                        cmd,
+                    ],
+                    capture_output=True,
+                    text=True,
+                    timeout=60,
+                )
+                return result.returncode, result.stdout, result.stderr
+            except subprocess.TimeoutExpired:
+                raise ProbeError(
+                    f"SSH connection timed out\n"
+                    f"  Host: {ssh_target}:{port}\n"
+                    f"  Hint: Check if the host is reachable and SSH is running."
+                ) from None
+
+        # Test SSH connection first
+        code, out, err = run_ssh_cmd("echo OK")
+        if code != 0:
+            raise ProbeError(
+                f"SSH connection failed to target '{target.name}'\n"
+                f"  Host: {user}@{host}:{port}\n"
+                f"  Key: {key_path}\n"
+                f"  Error: {err.strip() if err else 'connection refused or timeout'}\n"
+                f"  Hint: Verify the host is reachable and the SSH key is authorized."
+            )
+
+        # Run probe script
+        escaped_script = _PROBE_SCRIPT.replace("'", "'\"'\"'")
+        code, out, err = run_ssh_cmd(f"python3 -c '{escaped_script}'")
+        if code != 0:
+            raise ProbeError(
+                f"Probe script failed on target '{target.name}'\n"
+                f"  Exit code: {code}\n"
+                f"  Error: {err.strip() if err else 'unknown'}\n"
+                f"  Hint: Ensure python3 is installed on the target."
+            )
+
+        try:
+            return json.loads(out)
+        except json.JSONDecodeError as e:
+            raise ProbeError(
+                f"Failed to parse probe output from '{target.name}'\n"
+                f"  Error: {e}\n"
+                f"  Output: {out[:200]}..."
+            ) from None
+
+    else:
+        raise ProbeError(
+            f"Probing not supported for target type: {type(target).__name__}\n"
+            f"  Supported types: RunPod, Baremetal, VM"
+        )

wafer/wevin_cli.py

@@ -253,6 +253,7 @@ def _build_environment(
 ) -> Environment:
     """Build a CodingEnvironment from template config."""
     from wafer_core.environments.coding import CodingEnvironment
+    from wafer_core.rollouts.templates import DANGEROUS_BASH_COMMANDS
 
     working_dir = Path(corpus_path) if corpus_path else Path.cwd()
     resolved_tools = tools_override or tpl.tools
@@ -260,6 +261,7 @@ def _build_environment(
         working_dir=working_dir,
         enabled_tools=resolved_tools,
         bash_allowlist=tpl.bash_allowlist,
+        bash_denylist=DANGEROUS_BASH_COMMANDS,
     )  # type: ignore[assignment]
     return env
 

wafer/workspaces.py

@@ -396,6 +396,9 @@ Host wafer-{workspace_id}
         "Or add to ~/.ssh/config:",
         config_entry,
         f"Then connect with: ssh wafer-{workspace_id}",
+        "",
+        "To run GPU commands without interactive SSH:",
+        f'  wafer workspaces exec {workspace_id} "<command>"',
     ]
 
     return "\n".join(lines)
@@ -652,6 +655,33 @@ def get_workspace(workspace_id: str, json_output: bool = False) -> str:
     return "\n".join(lines)
 
 
+def _handle_sync_event(sync_type: str) -> None:
+    """Handle sync events and print status to stderr.
+
+    Sync events:
+    - FORWARD:START - Starting workspace → GPU sync
+    - FORWARD:DONE:N - Synced N files to GPU
+    - FORWARD:WARN:msg - Warning during forward sync
+    - REVERSE:START - Starting GPU → workspace sync
+    - REVERSE:DONE:N - Synced N artifacts back
+    """
+    import sys
+
+    if sync_type == "FORWARD:START":
+        print("[sync] Syncing workspace → GPU...", end="", file=sys.stderr, flush=True)
+    elif sync_type.startswith("FORWARD:DONE:"):
+        count = sync_type.split(":")[-1]
+        print(f" done ({count} files)", file=sys.stderr)
+    elif sync_type.startswith("FORWARD:WARN:"):
+        msg = sync_type[13:]  # Remove "FORWARD:WARN:"
+        print(f" warning: {msg}", file=sys.stderr)
+    elif sync_type == "REVERSE:START":
+        print("[sync] Syncing artifacts back...", end="", file=sys.stderr, flush=True)
+    elif sync_type.startswith("REVERSE:DONE:"):
+        count = sync_type.split(":")[-1]
+        print(f" done ({count} files)", file=sys.stderr)
+
+
 @dataclass(frozen=True)
 class SSEEvent:
     """Parsed SSE event result."""
@@ -659,6 +689,7 @@ class SSEEvent:
     output: str | None  # Content to print (None = no output)
     exit_code: int | None  # Exit code if stream should end (None = continue)
     is_error: bool  # Whether output goes to stderr
+    sync_event: str | None = None  # Sync event type (e.g., "FORWARD:START")
 
 
 def _parse_sse_content(content: str) -> SSEEvent:
@@ -680,6 +711,16 @@ def _parse_sse_content(content: str) -> SSEEvent:
     if content.startswith("[ERROR]"):
         return SSEEvent(output=content[8:], exit_code=1, is_error=True)
 
+    # Sync events: [SYNC:FORWARD:START], [SYNC:FORWARD:DONE:5], etc.
+    if content.startswith("[SYNC:"):
+        # Extract sync type (e.g., "FORWARD:START" or "REVERSE:DONE:5")
+        sync_type = content[6:-1]  # Remove [SYNC: and ]
+        return SSEEvent(output=None, exit_code=None, is_error=False, sync_event=sync_type)
+
+    # Status events we can ignore (already handled elsewhere)
+    if content.startswith("[STATUS:") or content.startswith("[CONTEXT:"):
+        return SSEEvent(output=None, exit_code=None, is_error=False)
+
     # Regular output
     return SSEEvent(output=content, exit_code=None, is_error=False)
 
@@ -688,13 +729,15 @@ def exec_command(
     workspace_id: str,
     command: str,
     timeout_seconds: int | None = None,
+    routing: str | None = None,
 ) -> int:
-    """Execute a command in workspace with GPU routing, streaming output.
+    """Execute a command in workspace, streaming output.
 
     Args:
         workspace_id: Workspace ID or name
         command: Command to execute
         timeout_seconds: Execution timeout (default: 300, from config)
+        routing: Routing hint - "auto", "gpu", "cpu", or "baremetal" (default: auto)
 
     Returns:
         Exit code (0 = success, non-zero = failure)
@@ -714,6 +757,10 @@ def exec_command(
     if timeout_seconds:
         request_body["timeout_seconds"] = timeout_seconds
 
+    # Add routing hint if specified
+    if routing:
+        request_body["requirements"] = {"routing": routing}
+
     try:
         # Use streaming request for SSE output
         with httpx.Client(timeout=None, headers=headers) as client:
@@ -736,6 +783,11 @@ def exec_command(
 
                     event = _parse_sse_content(line[6:])
 
+                    # Handle sync events - display status to stderr
+                    if event.sync_event:
+                        _handle_sync_event(event.sync_event)
+                        continue
+
                     if event.output is not None:
                         print(event.output, file=sys.stderr if event.is_error else sys.stdout)
 

{wafer_cli-0.2.7.dist-info → wafer_cli-0.2.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wafer-cli
-Version: 0.2.7
+Version: 0.2.9
 Summary: CLI tool for running commands on remote GPUs and GPU kernel optimization agent
 Requires-Python: >=3.11
 Requires-Dist: typer>=0.12.0

{wafer_cli-0.2.7.dist-info → wafer_cli-0.2.9.dist-info}/RECORD

@@ -2,32 +2,35 @@ wafer/GUIDE.md,sha256=Z_jsSgHAS6bFa83VKhG9jxjUK1XpLjR1fEIKapDa_6g,3195
 wafer/__init__.py,sha256=kBM_ONCpU6UUMBOH8Tmg4A88sNFnbaD59o61cJs-uYM,90
 wafer/analytics.py,sha256=Xxw3bbY3XLgedSJPwzIOBJIjyycIiornWCpjoWbTKYU,8190
 wafer/api_client.py,sha256=cPULiTxqOAYYSfDTNJgd-6Pqrt3IM4Gm9903U7yGIwY,6163
-wafer/auth.py,sha256=ZLsXZ73GDLD8GL7Rij1ELtuLqyJ5EU_uPBUMPVKwExA,10703
+wafer/auth.py,sha256=acBVOz-3la6avztDGjtLRopdjNRIqbrV4tRMM1FAmHI,13682
 wafer/autotuner.py,sha256=6gH0Ho7T58EFerMQcHQxshWe3DF4qU7fb5xthAh5SPM,44364
 wafer/billing.py,sha256=jbLB2lI4_9f2KD8uEFDi_ixLlowe5hasC0TIZJyIXRg,7163
-wafer/cli.py,sha256=QgqaBkCrpnLD6IaY35Eo-JITR5vnMKmHCmnqniW0Yv4,184987
+wafer/cli.py,sha256=To50huPpXV0wv5oH2mx0LJ5vTWt2WRyjYsyrhvf-_2c,220933
 wafer/config.py,sha256=h5Eo9_yfWqWGoPNdVQikI9GoZVUeysunSYiixf1mKcw,3411
 wafer/corpus.py,sha256=yTF3UA5bOa8BII2fmcXf-3WsIsM5DX4etysv0AzVknE,8912
-wafer/evaluate.py,sha256=nIqLQap9-mUtzOWTCJXkZsNydeo36uSTfiD9dGM07aA,130748
+wafer/evaluate.py,sha256=ss4847PC2wrua9wtYECkNzBv5Oww_79o9CIBwvVpI94,169607
 wafer/global_config.py,sha256=fhaR_RU3ufMksDmOohH1OLeQ0JT0SDW1hEip_zaP75k,11345
-wafer/gpu_run.py,sha256=gUbzMsMPsw3UHcn00bI-zTSHrU8c2FEpDvbcsczlDPo,9557
+wafer/gpu_run.py,sha256=TwqXy72T7f2I7e6n5WWod3xgxCPnDhU0BgLsB4CUoQY,9716
 wafer/inference.py,sha256=tZCO5i05FKY27ewis3CSBHFBeFbXY3xwj0DSjdoMY9s,4314
+wafer/kernel_scope.py,sha256=ynfGdIOd2U-jFpyJGPq0pwW7NkGAbz7TWZaLs_TxQy8,16127
 wafer/ncu_analyze.py,sha256=rAWzKQRZEY6E_CL3gAWUaW3uZ4kvQVZskVCPDpsFJuE,24633
 wafer/nsys_analyze.py,sha256=dRsYNYp1IqzGSPrQuEMW5vRbIxr-VrQwQbotLSrPvlY,6795
+wafer/problems.py,sha256=ce2sy10A1nnNUG3VGsseTS8jL7LZsku4dE8zVf9JHQ4,11296
 wafer/rocprof_compute.py,sha256=Tu16Vb05b2grvheFWi1XLGlAr6m48NEDeZoDyw_4Uzw,19885
 wafer/rocprof_sdk.py,sha256=fAYCxpfJa5BZTTkIMBOXg4KsYK4i_wNOKrJJn1ZfypM,10086
 wafer/rocprof_systems.py,sha256=4IWbMcbYk1x_8iS7P3FC_u5sgH6EXADCtR2lV9id80M,18629
-wafer/targets.py,sha256=WE5TJgFPGtEIh7VaTQHZ4wB2t4kW0c5K8-UmQ_39Ock,10254
+wafer/target_lock.py,sha256=SDKhNzv2N7gsphGflcNni9FE5YYuAMuEthngAJEo4Gs,7809
+wafer/targets.py,sha256=9r-iRWoKSH5cQl1LcamaX-T7cNVOg99ngIm_hlRk-qU,26922
 wafer/tracelens.py,sha256=g9ZIeFyNojZn4uTd3skPqIrRiL7aMJOz_-GOd3aiyy4,7998
-wafer/wevin_cli.py,sha256=jvj8H9cNf2EXhVnifQzDrz0aR3mzHgCv68CdIkCx6po,16685
-wafer/workspaces.py,sha256=92LG1mtkzNz-ap3XzcqY6KnQ9SUCFG8VBIOUj1Who64,25757
+wafer/wevin_cli.py,sha256=1_o2P47namZmPkbt47TnyYDmwhEzQYbSg5zjHffu2JQ,16802
+wafer/workspaces.py,sha256=aClxuwi-EgSuXchDR1F2blMiQTb5RV1K2CMpFESE_9Y,28013
 wafer/skills/wafer-guide/SKILL.md,sha256=UfBeIe5GKFzOYcbPmcs8U2nrjbfr-jSMRwg0jQDBfb0,3058
 wafer/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wafer/templates/ask_docs.py,sha256=Lxs-faz9v5m4Qa4NjF2X_lE8KwM9ES9MNJkxo7ep56o,2256
 wafer/templates/optimize_kernel.py,sha256=u6AL7Q3uttqlnBLzcoFdsiPq5lV2TV3bgqwCYYlK9gk,2357
 wafer/templates/trace_analyze.py,sha256=XE1VqzVkIUsZbXF8EzQdDYgg-AZEYAOFpr6B_vnRELc,2880
-wafer_cli-0.2.7.dist-info/METADATA,sha256=hstX06LiFURdAXouzXdm3lFSH31zv-2k47lMWbme_Vs,559
-wafer_cli-0.2.7.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-wafer_cli-0.2.7.dist-info/entry_points.txt,sha256=WqB7hB__WhtPY8y1cO2sZiUz7fCq6Ik-usAigpeFvWE,41
-wafer_cli-0.2.7.dist-info/top_level.txt,sha256=2MK1IVMWfpLL8BZCQ3E9aG6L6L666gSA_teYlwan4fs,6
-wafer_cli-0.2.7.dist-info/RECORD,,
+wafer_cli-0.2.9.dist-info/METADATA,sha256=gMP7nuGTR3QTp9lXATbu-tFbQHA3bg1Q0v57lV2vuKQ,559
+wafer_cli-0.2.9.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+wafer_cli-0.2.9.dist-info/entry_points.txt,sha256=WqB7hB__WhtPY8y1cO2sZiUz7fCq6Ik-usAigpeFvWE,41
+wafer_cli-0.2.9.dist-info/top_level.txt,sha256=2MK1IVMWfpLL8BZCQ3E9aG6L6L666gSA_teYlwan4fs,6
+wafer_cli-0.2.9.dist-info/RECORD,,