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

wafer/workspaces.py

@@ -13,15 +13,7 @@ import httpx
 from .api_client import get_api_url
 from .auth import get_auth_headers
 
-
-@dataclass(frozen=True)
-class SSHCredentials:
-    """SSH credentials for workspace access."""
-
-    host: str
-    port: int
-    user: str
-    key_path: Path
+VALID_STATUSES = {"creating", "running"}
 
 
 def _get_client() -> tuple[str, dict[str, str]]:
@@ -72,10 +64,11 @@ def _friendly_error(status_code: int, response_text: str, workspace_id: str) ->
 
     # Parse common error details from response
     detail = ""
-    if "stopped" in response_text.lower():
+    if "not running" in response_text.lower() or "not found" in response_text.lower():
         return (
-            f"Workspace '{workspace_id}' is stopped.\n"
-            "  Attach to start it: wafer workspaces attach " + workspace_id
+            f"Workspace '{workspace_id}' not found or not running.\n"
+            "  Check status: wafer workspaces list\n"
+            "  Create new:   wafer workspaces create <name>"
         )
 
     if "timeout" in response_text.lower():
@@ -85,6 +78,12 @@ def _friendly_error(status_code: int, response_text: str, workspace_id: str) ->
             "  Or set default: wafer config set defaults.exec_timeout 600"
         )
 
+    if "creating" in response_text.lower():
+        return (
+            f"Workspace '{workspace_id}' is still creating.\n"
+            "  Check status: wafer workspaces list"
+        )
+
     # Generic error with response detail
     try:
         import json
@@ -114,6 +113,14 @@ def _list_workspaces_raw() -> list[dict]:
         raise RuntimeError(f"Could not reach API: {e}") from e
 
     assert isinstance(workspaces, list), "API must return a list of workspaces"
+    
+    for ws in workspaces:
+        status = ws.get("status", "unknown")
+        assert status in VALID_STATUSES or status == "unknown", (
+            f"Workspace {ws.get('id', 'unknown')} has invalid status '{status}'. "
+            f"Valid statuses: {VALID_STATUSES}"
+        )
+    
     return workspaces
 
 
@@ -186,9 +193,15 @@ def list_workspaces(json_output: bool = False) -> str:
     except httpx.RequestError as e:
         raise RuntimeError(f"Could not reach API: {e}") from e
 
-    # Validate API response shape
     assert isinstance(workspaces, list), "API must return a list of workspaces"
 
+    for ws in workspaces:
+        status = ws.get("status", "unknown")
+        assert status in VALID_STATUSES or status == "unknown", (
+            f"Workspace {ws.get('id', 'unknown')} has invalid status '{status}'. "
+            f"Valid statuses: {VALID_STATUSES}"
+        )
+
     if json_output:
         return json.dumps(workspaces, indent=2)
 
@@ -198,10 +211,14 @@ def list_workspaces(json_output: bool = False) -> str:
     lines = ["Workspaces:", ""]
     for ws in workspaces:
         status = ws.get("status", "unknown")
-        status_icon = {"running": "●", "stopped": "○", "queued": "◐"}.get(status, "?")
+        status_icon = {"running": "●", "creating": "◐"}.get(status, "?")
         lines.append(f"  {status_icon} {ws['name']} ({ws['id']})")
         lines.append(f"    GPU: {ws.get('gpu_type', 'N/A')} | Image: {ws.get('image', 'N/A')}")
         lines.append(f"    Status: {status} | Created: {ws.get('created_at', 'N/A')}")
+        if status == "running" and ws.get("ssh_host") and ws.get("ssh_port") and ws.get("ssh_user"):
+            lines.append(
+                f"    SSH: ssh -p {ws['ssh_port']} {ws['ssh_user']}@{ws['ssh_host']}"
+            )
         lines.append("")
 
     return "\n".join(lines)
@@ -211,6 +228,7 @@ def create_workspace(
     name: str,
     gpu_type: str = "B200",
     image: str | None = None,
+    wait: bool = False,
     json_output: bool = False,
 ) -> str:
     """Create a new workspace.
@@ -219,6 +237,7 @@ def create_workspace(
         name: Workspace name (must be unique)
         gpu_type: GPU type (default: B200)
         image: Docker image (optional, uses default if not specified)
+        wait: If True, stream provisioning progress and return SSH credentials
         json_output: If True, return raw JSON; otherwise return formatted text
 
     Returns:
@@ -276,193 +295,114 @@ def create_workspace(
     assert "id" in workspace, "API response must contain workspace id"
     assert "name" in workspace, "API response must contain workspace name"
 
+    if wait:
+        ssh_info = _wait_for_provisioning(workspace["id"])
+        if json_output:
+            payload = {
+                "workspace_id": workspace["id"],
+                "ssh_host": ssh_info["ssh_host"],
+                "ssh_port": ssh_info["ssh_port"],
+                "ssh_user": ssh_info["ssh_user"],
+            }
+            return json.dumps(payload, indent=2)
+        return (
+            f"Workspace ready: {workspace['name']} ({workspace['id']})\n"
+            f"SSH: ssh -p {ssh_info['ssh_port']} {ssh_info['ssh_user']}@{ssh_info['ssh_host']}"
+        )
+
     if json_output:
         return json.dumps(workspace, indent=2)
 
-    return f"Created workspace: {workspace['name']} ({workspace['id']})"
-
+    return (
+        f"Creating workspace: {workspace['name']} ({workspace['id']})\n"
+        "Check status with: wafer workspaces list\n"
+        "Estimated time: ~30 seconds"
+    )
 
-def delete_workspace(workspace_id: str, json_output: bool = False) -> str:
-    """Delete a workspace.
 
-    Args:
-        workspace_id: Workspace ID to delete
-        json_output: If True, return raw JSON; otherwise return formatted text
+def _wait_for_provisioning(workspace_id: str) -> dict[str, str | int]:
+    """Wait for workspace provisioning to complete via SSE."""
+    import sys
 
-    Returns:
-        Deletion status as string
-    """
     assert workspace_id, "Workspace ID must be non-empty"
-
     api_url, headers = _get_client()
 
     try:
-        with httpx.Client(timeout=30.0, headers=headers) as client:
-            response = client.delete(f"{api_url}/v1/workspaces/{workspace_id}")
-            response.raise_for_status()
-            result = response.json()
-    except httpx.HTTPStatusError as e:
-        if e.response.status_code == 401:
-            raise RuntimeError("Not authenticated. Run: wafer login") from e
-        if e.response.status_code == 404:
-            raise RuntimeError(f"Workspace not found: {workspace_id}") from e
-        raise RuntimeError(f"API error: {e.response.status_code} - {e.response.text}") from e
-    except httpx.RequestError as e:
-        raise RuntimeError(f"Could not reach API: {e}") from e
+        with httpx.Client(timeout=None, headers=headers) as client:
+            with client.stream(
+                "POST",
+                f"{api_url}/v1/workspaces/{workspace_id}/provision-stream",
+            ) as response:
+                if response.status_code != 200:
+                    error_body = response.read().decode("utf-8", errors="replace")
+                    raise RuntimeError(
+                        _friendly_error(response.status_code, error_body, workspace_id)
+                    )
 
-    if json_output:
-        return json.dumps(result, indent=2)
+                ssh_info: dict[str, str | int] | None = None
+                for line in response.iter_lines():
+                    if not line or not line.startswith("data: "):
+                        continue
+                    content = line[6:]
+                    if content.startswith("[STATUS:"):
+                        status = content[8:-1]
+                        print(f"[wafer] {status.lower()}...", file=sys.stderr)
+                        if status == "ERROR":
+                            raise RuntimeError(
+                                "Workspace provisioning failed. Check status with: wafer workspaces list"
+                            )
+                    elif content.startswith("[SSH:"):
+                        parts = content[5:-1].split(":")
+                        if len(parts) != 3:
+                            raise RuntimeError("Malformed SSH info in provisioning stream")
+                        ssh_info = {
+                            "ssh_host": parts[0],
+                            "ssh_port": int(parts[1]),
+                            "ssh_user": parts[2],
+                        }
+                        break
 
-    return f"Deleted workspace: {workspace_id}"
+                if ssh_info is None:
+                    raise RuntimeError("Provisioning did not return SSH credentials")
+                return ssh_info
+    except httpx.RequestError as e:
+        raise RuntimeError(f"Could not reach API: {e}") from e
 
 
-def attach_workspace(workspace_id: str, json_output: bool = False) -> str:
-    """Attach to a workspace (get SSH credentials).
+def delete_workspace(workspace_id: str, json_output: bool = False) -> str:
+    """Delete a workspace.
 
     Args:
-        workspace_id: Workspace ID to attach to
+        workspace_id: Workspace ID to delete
         json_output: If True, return raw JSON; otherwise return formatted text
 
     Returns:
-        SSH connection info as string
+        Deletion status as string
     """
     assert workspace_id, "Workspace ID must be non-empty"
 
     api_url, headers = _get_client()
 
     try:
-        with httpx.Client(timeout=120.0, headers=headers) as client:
-            response = client.post(f"{api_url}/v1/workspaces/{workspace_id}/attach")
+        with httpx.Client(timeout=30.0, headers=headers) as client:
+            response = client.delete(f"{api_url}/v1/workspaces/{workspace_id}")
             response.raise_for_status()
-            attach_info = response.json()
+            result = response.json()
     except httpx.HTTPStatusError as e:
         if e.response.status_code == 401:
             raise RuntimeError("Not authenticated. Run: wafer login") from e
         if e.response.status_code == 404:
             raise RuntimeError(f"Workspace not found: {workspace_id}") from e
-        if e.response.status_code == 503:
-            raise RuntimeError("No GPU available. Please try again later.") from e
         raise RuntimeError(f"API error: {e.response.status_code} - {e.response.text}") from e
     except httpx.RequestError as e:
         raise RuntimeError(f"Could not reach API: {e}") from e
 
-    # Validate API response has required SSH fields
-    assert "ssh_host" in attach_info, "API response must contain ssh_host"
-    assert "ssh_port" in attach_info, "API response must contain ssh_port"
-    assert "ssh_user" in attach_info, "API response must contain ssh_user"
-    assert "private_key_pem" in attach_info, "API response must contain private_key_pem"
-
     if json_output:
-        return json.dumps(attach_info, indent=2)
-
-    # Write private key to temp file and generate SSH config
-    ssh_host = attach_info["ssh_host"]
-    ssh_port = attach_info["ssh_port"]
-    ssh_user = attach_info["ssh_user"]
-    private_key = attach_info["private_key_pem"]
-
-    # Validate field values before using them
-    assert ssh_host, "ssh_host must be non-empty"
-    assert isinstance(ssh_port, int), "ssh_port must be an integer"
-    assert ssh_port > 0, "ssh_port must be positive"
-    assert ssh_user, "ssh_user must be non-empty"
-    assert private_key, "private_key_pem must be non-empty"
-
-    # Save private key
-    key_dir = Path.home() / ".wafer" / "keys"
-    key_dir.mkdir(parents=True, exist_ok=True)
-    key_path = key_dir / f"{workspace_id}.pem"
-    key_path.write_text(private_key)
-    key_path.chmod(0o600)
-
-    # Generate SSH config entry
-    config_entry = f"""
-# Wafer workspace: {workspace_id}
-Host wafer-{workspace_id}
-    HostName {ssh_host}
-    Port {ssh_port}
-    User {ssh_user}
-    IdentityFile {key_path}
-    StrictHostKeyChecking no
-    UserKnownHostsFile /dev/null
-"""
-
-    lines = [
-        f"Attached to workspace: {workspace_id}",
-        "",
-        "SSH Connection:",
-        f"  ssh -i {key_path} -p {ssh_port} {ssh_user}@{ssh_host}",
-        "",
-        "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)
-
-
-def get_ssh_credentials(workspace_id: str) -> tuple[SSHCredentials, str]:
-    """Get SSH credentials for a workspace.
-
-    Calls attach API, saves key file, returns credentials for SSH.
-
-    Args:
-        workspace_id: Workspace ID or name
-
-    Returns:
-        Tuple of (SSHCredentials, resolved_workspace_id)
-
-    Raises:
-        RuntimeError: If attach fails
-    """
-    assert workspace_id, "Workspace ID must be non-empty"
+        return json.dumps(result, indent=2)
 
-    api_url, headers = _get_client()
+    return f"Deleted workspace: {workspace_id}"
 
-    try:
-        with httpx.Client(timeout=120.0, headers=headers) as client:
-            response = client.post(f"{api_url}/v1/workspaces/{workspace_id}/attach")
-            response.raise_for_status()
-            attach_info = response.json()
-    except httpx.HTTPStatusError as e:
-        if e.response.status_code == 401:
-            raise RuntimeError("Not authenticated. Run: wafer login") from e
-        if e.response.status_code == 404:
-            raise RuntimeError(f"Workspace not found: {workspace_id}") from e
-        if e.response.status_code == 503:
-            raise RuntimeError("No GPU available. Please try again later.") from e
-        raise RuntimeError(f"API error: {e.response.status_code} - {e.response.text}") from e
-    except httpx.RequestError as e:
-        raise RuntimeError(f"Could not reach API: {e}") from e
 
-    # Validate and extract fields
-    resolved_id = attach_info.get("workspace_id", workspace_id)
-    ssh_host = attach_info.get("ssh_host")
-    ssh_port = attach_info.get("ssh_port")
-    ssh_user = attach_info.get("ssh_user")
-    private_key = attach_info.get("private_key_pem")
-
-    assert ssh_host, "API response must contain ssh_host"
-    assert isinstance(ssh_port, int) and ssh_port > 0, "ssh_port must be positive integer"
-    assert ssh_user, "API response must contain ssh_user"
-    assert private_key, "API response must contain private_key_pem"
-
-    # Save private key using resolved ID
-    key_dir = Path.home() / ".wafer" / "keys"
-    key_dir.mkdir(parents=True, exist_ok=True)
-    key_path = key_dir / f"{resolved_id}.pem"
-    key_path.write_text(private_key)
-    key_path.chmod(0o600)
-
-    return SSHCredentials(
-        host=ssh_host,
-        port=ssh_port,
-        user=ssh_user,
-        key_path=key_path,
-    ), resolved_id
 
 
 def sync_files(
@@ -495,9 +435,23 @@ def sync_files(
     assert workspace_id, "Workspace ID must be non-empty"
     assert local_path.exists(), f"Path not found: {local_path}"
 
-    # Get SSH credentials (also wakes up workspace if needed)
-    # resolved_id is the UUID, workspace_id might be a name
-    creds, resolved_id = get_ssh_credentials(workspace_id)
+    ws = get_workspace_raw(workspace_id)
+    resolved_id = ws["id"]
+    workspace_status = ws.get("status")
+    assert workspace_status in VALID_STATUSES, (
+        f"Workspace {workspace_id} has invalid status '{workspace_status}'. "
+        f"Valid statuses: {VALID_STATUSES}"
+    )
+    if workspace_status != "running":
+        raise RuntimeError(
+            f"Workspace is {workspace_status}. Wait for it to be running before syncing."
+        )
+    ssh_host = ws.get("ssh_host")
+    ssh_port = ws.get("ssh_port")
+    ssh_user = ws.get("ssh_user")
+    assert ssh_host, "Workspace missing ssh_host"
+    assert isinstance(ssh_port, int) and ssh_port > 0, "Workspace missing valid ssh_port"
+    assert ssh_user, "Workspace missing ssh_user"
 
     # Build rsync command
     # -a: archive mode (preserves permissions, etc.)
@@ -510,13 +464,17 @@ def sync_files(
         # Single file: sync the file itself
         source = str(local_path)
 
+    # Build SSH command for rsync
+    # If key_path is None (BYOK model), SSH will use default key from ~/.ssh/
+    ssh_opts = f"-p {ssh_port} -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null"
+    
     rsync_cmd = [
         "rsync",
         "-avz",
         "-e",
-        f"ssh -i {creds.key_path} -p {creds.port} -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null",
+        f"ssh {ssh_opts}",
         source,
-        f"{creds.user}@{creds.host}:/workspace/",
+        f"{ssh_user}@{ssh_host}:/workspace/",
     ]
 
     try:
@@ -592,16 +550,8 @@ def _init_sync_state(workspace_id: str) -> str | None:
         return None
 
 
-def get_workspace(workspace_id: str, json_output: bool = False) -> str:
-    """Get details of a specific workspace.
-
-    Args:
-        workspace_id: Workspace ID to get
-        json_output: If True, return raw JSON; otherwise return formatted text
-
-    Returns:
-        Workspace details as string
-    """
+def get_workspace_raw(workspace_id: str) -> dict:
+    """Get workspace details as raw JSON dict."""
     assert workspace_id, "Workspace ID must be non-empty"
 
     api_url, headers = _get_client()
@@ -620,9 +570,29 @@ def get_workspace(workspace_id: str, json_output: bool = False) -> str:
     except httpx.RequestError as e:
         raise RuntimeError(f"Could not reach API: {e}") from e
 
-    # Validate API response has required fields
     assert "id" in workspace, "API response must contain workspace id"
     assert "name" in workspace, "API response must contain workspace name"
+    
+    status = workspace.get("status", "unknown")
+    assert status in VALID_STATUSES or status == "unknown", (
+        f"Workspace {workspace['id']} has invalid status '{status}'. "
+        f"Valid statuses: {VALID_STATUSES}"
+    )
+    
+    return workspace
+
+
+def get_workspace(workspace_id: str, json_output: bool = False) -> str:
+    """Get details of a specific workspace.
+
+    Args:
+        workspace_id: Workspace ID to get
+        json_output: If True, return raw JSON; otherwise return formatted text
+
+    Returns:
+        Workspace details as string
+    """
+    workspace = get_workspace_raw(workspace_id)
 
     if json_output:
         return json.dumps(workspace, indent=2)
@@ -646,11 +616,8 @@ def get_workspace(workspace_id: str, json_output: bool = False) -> str:
             f"  Port: {workspace.get('ssh_port', 22)}",
             f"  User: {workspace.get('ssh_user', 'root')}",
         ])
-    elif status in ("stopped", "created"):
-        lines.extend([
-            "",
-            "SSH: Run 'wafer workspaces attach' to get SSH credentials",
-        ])
+    elif status == "creating":
+        lines.extend(["", "SSH: available once workspace is running"])
 
     return "\n".join(lines)
 
@@ -730,6 +697,7 @@ def exec_command(
     command: str,
     timeout_seconds: int | None = None,
     routing: str | None = None,
+    pull_image: bool = False,
 ) -> int:
     """Execute a command in workspace, streaming output.
 
@@ -753,7 +721,7 @@ def exec_command(
     # Base64 encode command to avoid escaping issues
     command_b64 = base64.b64encode(command.encode("utf-8")).decode("utf-8")
 
-    request_body: dict = {"command_b64": command_b64}
+    request_body: dict = {"command_b64": command_b64, "pull_image": pull_image}
     if timeout_seconds:
         request_body["timeout_seconds"] = timeout_seconds
 
@@ -803,3 +771,83 @@ def exec_command(
         ) from e
     except httpx.RequestError as e:
         raise RuntimeError(f"Could not reach API: {e}") from e
+
+
+def exec_command_capture(
+    workspace_id: str,
+    command: str,
+    timeout_seconds: int | None = None,
+    routing: str | None = None,
+    pull_image: bool = False,
+) -> tuple[int, str]:
+    """Execute a command in workspace and capture output.
+
+    Similar to exec_command but returns output as string instead of printing.
+
+    Args:
+        workspace_id: Workspace ID or name
+        command: Command to execute
+        timeout_seconds: Execution timeout (default: 300)
+        routing: Routing hint - "auto", "gpu", "cpu", or "baremetal"
+
+    Returns:
+        Tuple of (exit_code, output_string)
+    """
+    import base64
+
+    assert workspace_id, "Workspace ID must be non-empty"
+    assert command, "Command must be non-empty"
+
+    api_url, headers = _get_client()
+
+    # Base64 encode command to avoid escaping issues
+    command_b64 = base64.b64encode(command.encode("utf-8")).decode("utf-8")
+
+    request_body: dict = {"command_b64": command_b64, "pull_image": pull_image}
+    if timeout_seconds:
+        request_body["timeout_seconds"] = timeout_seconds
+
+    if routing:
+        request_body["requirements"] = {"routing": routing}
+
+    output_lines: list[str] = []
+
+    try:
+        with httpx.Client(timeout=None, headers=headers) as client:
+            with client.stream(
+                "POST",
+                f"{api_url}/v1/workspaces/{workspace_id}/exec",
+                json=request_body,
+            ) as response:
+                if response.status_code != 200:
+                    error_body = response.read().decode("utf-8", errors="replace")
+                    raise RuntimeError(
+                        _friendly_error(response.status_code, error_body, workspace_id)
+                    )
+
+                exit_code = 0
+                for line in response.iter_lines():
+                    if not line or not line.startswith("data: "):
+                        continue
+
+                    event = _parse_sse_content(line[6:])
+
+                    # Skip sync events
+                    if event.sync_event:
+                        continue
+
+                    if event.output is not None:
+                        output_lines.append(event.output)
+
+                    if event.exit_code is not None:
+                        exit_code = event.exit_code
+                        break
+
+                return exit_code, "\n".join(output_lines)
+
+    except httpx.HTTPStatusError as e:
+        raise RuntimeError(
+            _friendly_error(e.response.status_code, e.response.text, workspace_id)
+        ) from e
+    except httpx.RequestError as e:
+        raise RuntimeError(f"Could not reach API: {e}") from e

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wafer-cli
-Version: 0.2.9
+Version: 0.2.11
 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.9.dist-info → wafer_cli-0.2.11.dist-info}/RECORD

@@ -1,36 +1,40 @@
-wafer/GUIDE.md,sha256=Z_jsSgHAS6bFa83VKhG9jxjUK1XpLjR1fEIKapDa_6g,3195
+wafer/GUIDE.md,sha256=G6P4aFZslEXiHmVjtTB3_OIpGK5d1tSiqxtawASVUZg,3588
 wafer/__init__.py,sha256=kBM_ONCpU6UUMBOH8Tmg4A88sNFnbaD59o61cJs-uYM,90
 wafer/analytics.py,sha256=Xxw3bbY3XLgedSJPwzIOBJIjyycIiornWCpjoWbTKYU,8190
-wafer/api_client.py,sha256=cPULiTxqOAYYSfDTNJgd-6Pqrt3IM4Gm9903U7yGIwY,6163
+wafer/api_client.py,sha256=i_Az2b2llC3DSW8yOL-BKqa7LSKuxOr8hSN40s-oQXY,6313
 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=To50huPpXV0wv5oH2mx0LJ5vTWt2WRyjYsyrhvf-_2c,220933
+wafer/cli.py,sha256=c7IEKZ-Ge-w4LQ1GVAqvuKkodBYtT6NnxNeGf6me9pc,252787
 wafer/config.py,sha256=h5Eo9_yfWqWGoPNdVQikI9GoZVUeysunSYiixf1mKcw,3411
-wafer/corpus.py,sha256=yTF3UA5bOa8BII2fmcXf-3WsIsM5DX4etysv0AzVknE,8912
-wafer/evaluate.py,sha256=ss4847PC2wrua9wtYECkNzBv5Oww_79o9CIBwvVpI94,169607
+wafer/corpus.py,sha256=x5aFhCsTSAtgzFG9AMFpqq92Ej63mXofL-vvvpjj1sM,12913
+wafer/evaluate.py,sha256=Lf_H6Afrdo4k9JOnI27wchFwEteqy73gKt5gLQgaXSE,172671
 wafer/global_config.py,sha256=fhaR_RU3ufMksDmOohH1OLeQ0JT0SDW1hEip_zaP75k,11345
 wafer/gpu_run.py,sha256=TwqXy72T7f2I7e6n5WWod3xgxCPnDhU0BgLsB4CUoQY,9716
 wafer/inference.py,sha256=tZCO5i05FKY27ewis3CSBHFBeFbXY3xwj0DSjdoMY9s,4314
-wafer/kernel_scope.py,sha256=ynfGdIOd2U-jFpyJGPq0pwW7NkGAbz7TWZaLs_TxQy8,16127
+wafer/kernel_scope.py,sha256=lQDSTx_IBIhjUOkBCOohB13MV7HjkH_dLcvJRs02DHE,20850
 wafer/ncu_analyze.py,sha256=rAWzKQRZEY6E_CL3gAWUaW3uZ4kvQVZskVCPDpsFJuE,24633
-wafer/nsys_analyze.py,sha256=dRsYNYp1IqzGSPrQuEMW5vRbIxr-VrQwQbotLSrPvlY,6795
+wafer/nsys_analyze.py,sha256=AhNcjPaapB0QCbqiHRXvyy-ccjevvVwEyxes84D28JU,36124
+wafer/nsys_profile.py,sha256=JNB6EgMlKbLnF0vw0av97BSfZRvT8Zrj2QbwbaUKtdw,15497
+wafer/output.py,sha256=SL8f6AccacGY486bHHxc_zHkFNiqPFWJPycSFGUGWHc,8002
 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/ssh_keys.py,sha256=9kSdhV_dg9T6pQu2JmNQptarkkwGtN9rLyRkI1bW4i4,8094
 wafer/target_lock.py,sha256=SDKhNzv2N7gsphGflcNni9FE5YYuAMuEthngAJEo4Gs,7809
 wafer/targets.py,sha256=9r-iRWoKSH5cQl1LcamaX-T7cNVOg99ngIm_hlRk-qU,26922
+wafer/targets_ops.py,sha256=FJQhlQ4MfOMN5ZNaVfqUvrkRwGjOXI22cNTIEVSKeSE,21488
 wafer/tracelens.py,sha256=g9ZIeFyNojZn4uTd3skPqIrRiL7aMJOz_-GOd3aiyy4,7998
-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/wevin_cli.py,sha256=4cZ05GFCGBq11ekVQH_AgaqnITVq6IUfwwHo6CeHFN4,22179
+wafer/workspaces.py,sha256=kN8-XFffodFflI9cuIllqd6VQGFnlV1h-Z28oBh4Lms,30100
+wafer/skills/wafer-guide/SKILL.md,sha256=KWetJw2TVTbz11_nzqazqOJWWRlbHRFShs4sOoreiWo,3255
 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.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,,
+wafer_cli-0.2.11.dist-info/METADATA,sha256=JK2VwDV7PgVjmRA5utdsWOLsT1xY1CRbp8WkqpFO4cA,560
+wafer_cli-0.2.11.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+wafer_cli-0.2.11.dist-info/entry_points.txt,sha256=WqB7hB__WhtPY8y1cO2sZiUz7fCq6Ik-usAigpeFvWE,41
+wafer_cli-0.2.11.dist-info/top_level.txt,sha256=2MK1IVMWfpLL8BZCQ3E9aG6L6L666gSA_teYlwan4fs,6
+wafer_cli-0.2.11.dist-info/RECORD,,