plato-sdk-v2 2.7.1__tar.gz → 2.7.3__tar.gz

{plato_sdk_v2-2.7.1 → plato_sdk_v2-2.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plato-sdk-v2
-Version: 2.7.1
+Version: 2.7.3
 Summary: Python SDK for the Plato API
 Author-email: Plato <support@plato.so>
 License-Expression: MIT

plato_sdk_v2-2.7.3/VERSION

@@ -0,0 +1 @@
+2.7.3

{plato_sdk_v2-2.7.1 → plato_sdk_v2-2.7.3}/plato/v1/cli/pm.py

@@ -544,9 +544,19 @@ def review_base(
                         console.print(f"[bold red]📋 Most Recent Base Review: REJECTED[/bold red] ({timestamp})")
                     else:
                         console.print(f"[bold green]📋 Most Recent Base Review: PASSED[/bold green] ({timestamp})")
-                    comments = recent_review.get("comments")
-                    if comments:
-                        console.print(f"[yellow]Reviewer Comments:[/yellow] {comments}")
+                    # Handle both old 'comments' field and new 'sim_comments' structure
+                    sim_comments = recent_review.get("sim_comments")
+                    if sim_comments:
+                        console.print("[yellow]Reviewer Comments:[/yellow]")
+                        for i, item in enumerate(sim_comments, 1):
+                            comment_text = item.get("comment", "")
+                            if comment_text:
+                                console.print(f"  {i}. {comment_text}")
+                    else:
+                        # Fallback to old comments field
+                        comments = recent_review.get("comments")
+                        if comments:
+                            console.print(f"[yellow]Reviewer Comments:[/yellow] {comments}")
 
                 console.print()
 
@@ -752,8 +762,6 @@ def review_data(
         simulator, artifact, require_artifact=False, command_name="review data"
     )
 
-    # Determine target URL based on simulator
-    target_url = f"https://{simulator_name}.web.plato.so"
     console.print(f"[cyan]Simulator:[/cyan] {simulator_name}")
 
     # Fetch simulator config and get artifact ID if not provided
@@ -802,21 +810,21 @@ def review_data(
     is_installed = "site-packages" in str(package_dir)
 
     if is_installed:
-        extension_source_path = package_dir / "extensions" / "envgen-recorder-old"
+        extension_source_path = package_dir / "extensions" / "data-review"
     else:
         repo_root = package_dir.parent.parent.parent  # plato-client/
-        extension_source_path = repo_root / "extensions" / "envgen-recorder-old"
+        extension_source_path = repo_root / "extensions" / "data-review"
 
     # Fallback to env var
     if not extension_source_path.exists():
         plato_client_dir_env = os.getenv("PLATO_CLIENT_DIR")
         if plato_client_dir_env:
-            env_path = Path(plato_client_dir_env) / "extensions" / "envgen-recorder-old"
+            env_path = Path(plato_client_dir_env) / "extensions" / "data-review"
             if env_path.exists():
                 extension_source_path = env_path
 
     if not extension_source_path.exists():
-        console.print("[red]❌ EnvGen Recorder extension not found[/red]")
+        console.print("[red]❌ Data Review extension not found[/red]")
         console.print(f"\n[yellow]Expected location:[/yellow] {extension_source_path}")
         raise typer.Exit(1)
 
@@ -829,14 +837,44 @@ def review_data(
     console.print(f"[green]✅ Extension copied to: {extension_path}[/green]")
 
     async def _review_data():
+        base_url = _get_base_url()
+        plato = AsyncPlato(api_key=api_key, base_url=base_url)
+        session = None
         playwright = None
         browser = None
 
         try:
+            # Check if we have an artifact ID to create a session
+            if not artifact_id:
+                console.print("[red]❌ No artifact ID available. Cannot create session.[/red]")
+                console.print("[yellow]Specify artifact with: plato pm review data -s simulator:artifact_id[/yellow]")
+                raise typer.Exit(1)
+
+            # Create session with artifact
+            console.print(f"[cyan]Creating {simulator_name} environment with artifact {artifact_id}...[/cyan]")
+            session = await plato.sessions.create(
+                envs=[Env.artifact(artifact_id)],
+                timeout=300,
+            )
+            console.print(f"[green]✅ Session created: {session.session_id}[/green]")
+
+            # Reset environment
+            console.print("[cyan]Resetting environment...[/cyan]")
+            await session.reset()
+            console.print("[green]✅ Environment reset complete![/green]")
+
+            # Get public URL
+            public_urls = await session.get_public_url()
+            first_alias = session.envs[0].alias if session.envs else None
+            public_url = public_urls.get(first_alias) if first_alias else None
+            if not public_url and public_urls:
+                public_url = list(public_urls.values())[0]
+            console.print(f"[cyan]Public URL:[/cyan] {public_url}")
+
             user_data_dir = Path.home() / ".plato" / "chrome-data"
             user_data_dir.mkdir(parents=True, exist_ok=True)
 
-            console.print("[cyan]Launching Chrome with EnvGen Recorder extension...[/cyan]")
+            console.print("[cyan]Launching Chrome with Data Review extension...[/cyan]")
 
             from playwright.async_api import async_playwright
 
@@ -877,13 +915,14 @@ def review_data(
             else:
                 console.print("[yellow]⚠️  Could not find extension ID. Please set API key manually.[/yellow]")
 
-            # Step 1: Navigate to target URL first
-            console.print(f"[cyan]Navigating to {target_url}...[/cyan]")
+            # Navigate to public URL (user logs in manually with displayed credentials)
+            console.print("[cyan]Opening environment...[/cyan]")
             main_page = await browser.new_page()
-            await main_page.goto(target_url, wait_until="domcontentloaded")
-            console.print(f"[green]✅ Loaded: {target_url}[/green]")
+            if public_url:
+                await main_page.goto(public_url)
+                console.print(f"[green]✅ Loaded: {public_url}[/green]")
 
-            # Step 2: Use options page to set API key
+            # Use options page to set API key
             if extension_id:
                 options_page = await browser.new_page()
                 try:
@@ -907,17 +946,16 @@ def review_data(
                     await options_page.close()
 
             # Bring main page to front
-            await main_page.bring_to_front()
+            if main_page:
+                await main_page.bring_to_front()
 
             console.print()
             console.print("[bold]Instructions:[/bold]")
-            console.print("  1. Click the EnvGen Recorder extension icon to open the sidebar")
-            if simulator:
-                console.print(f"  2. Click 'Configure Session' and enter '{simulator}' as the simulator name")
-            else:
-                console.print("  2. Click 'Configure Session' and enter a simulator name")
-            console.print("  3. Use the extension to record and submit reviews")
-            console.print("  4. When done, press Control-C to exit")
+            console.print("  1. Click the Data Review extension icon to open the sidebar")
+            console.print(f"  2. Enter '{simulator_name}' as the simulator name and click Start Review")
+            console.print("  3. Take screenshots and add comments for any issues")
+            console.print("  4. Select Pass or Reject and submit the review")
+            console.print("  5. When done, press Control-C to exit")
 
             # Show recent review if available
             if recent_review:
@@ -930,10 +968,20 @@ def review_data(
                 else:
                     console.print(f"[bold green]📋 Most Recent Data Review: PASSED[/bold green] ({timestamp})")
 
-                comments = recent_review.get("comments")
-                if comments:
+                # Handle both old 'comments' field and new 'sim_comments' structure
+                sim_comments = recent_review.get("sim_comments")
+                if sim_comments:
                     console.print("\n[yellow]Reviewer Comments:[/yellow]")
-                    console.print(f"  {comments}")
+                    for i, item in enumerate(sim_comments, 1):
+                        comment_text = item.get("comment", "")
+                        if comment_text:
+                            console.print(f"  {i}. {comment_text}")
+                else:
+                    # Fallback to old comments field
+                    comments = recent_review.get("comments")
+                    if comments:
+                        console.print("\n[yellow]Reviewer Comments:[/yellow]")
+                        console.print(f"  {comments}")
                 console.print("=" * 60)
 
             console.print()
@@ -954,6 +1002,8 @@ def review_data(
 
         finally:
             try:
+                if session:
+                    await session.close()
                 if browser:
                     await browser.close()
                 if playwright:
@@ -961,7 +1011,7 @@ def review_data(
                 if temp_ext_dir.exists():
                     shutil.rmtree(temp_ext_dir, ignore_errors=True)
             except Exception as e:
-                console.print(f"[yellow]⚠️  Browser cleanup error: {e}[/yellow]")
+                console.print(f"[yellow]⚠️  Cleanup error: {e}[/yellow]")
 
     handle_async(_review_data())
 

{plato_sdk_v2-2.7.1 → plato_sdk_v2-2.7.3}/plato/v2/utils/db_cleanup.py

@@ -12,6 +12,7 @@ from sqlalchemy.ext.asyncio import create_async_engine
 
 from plato._generated.api.v1.simulator import get_db_config
 from plato._generated.models import DbConfigResponse
+from plato.v2.utils.gateway_tunnel import GatewayTunnel, find_free_port
 from plato.v2.utils.models import (
     ApiCleanupResult,
     DatabaseCleanupResult,
@@ -19,12 +20,10 @@ from plato.v2.utils.models import (
     EnvironmentInfo,
     SessionCleanupResult,
 )
-from plato.v2.utils.proxy_tunnel import ProxyTunnel, find_free_port, make_db_url
+from plato.v2.utils.proxy_tunnel import make_db_url
 
 logger = logging.getLogger(__name__)
 
-TEMP_PASSWORD = "newpass"
-
 
 class DatabaseCleaner:
     """Handles database audit_log cleanup operations."""
@@ -145,14 +144,13 @@ class DatabaseCleaner:
         config: DbConfigResponse,
         local_port: int,
     ) -> DatabaseCleanupResult:
-        """Connect to a single DB via tunnel and truncate audit_log tables."""
+        """Connect to a single DB via gateway tunnel and truncate audit_log tables."""
         db_port = config.db_port
 
-        tunnel = ProxyTunnel(
-            env_id=job_id,
-            db_port=db_port,
-            temp_password=TEMP_PASSWORD,
-            host_port=local_port,
+        tunnel = GatewayTunnel(
+            job_id=job_id,
+            remote_port=db_port,
+            local_port=local_port,
         )
 
         try:

plato_sdk_v2-2.7.3/plato/v2/utils/gateway_tunnel.py

@@ -0,0 +1,221 @@
+"""TLS + SNI gateway tunnel for database connections.
+
+Routes traffic through gateway.plato.so:443 using SNI-based routing,
+replacing the deprecated HTTP CONNECT proxy approach.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+import socket
+import ssl
+
+logger = logging.getLogger(__name__)
+
+# Default gateway configuration
+DEFAULT_GATEWAY_HOST = "gateway.plato.so"
+DEFAULT_GATEWAY_PORT = 443
+
+
+def get_gateway_config() -> tuple[str, int]:
+    """Get gateway host and port from environment or defaults.
+
+    Returns:
+        Tuple of (host, port) for the gateway.
+    """
+    host = os.environ.get("PLATO_GATEWAY_HOST", DEFAULT_GATEWAY_HOST)
+    port = int(os.environ.get("PLATO_GATEWAY_PORT", str(DEFAULT_GATEWAY_PORT)))
+    return host, port
+
+
+def find_free_port(start_port: int = 55432) -> int:
+    """Find the first available TCP port starting from start_port."""
+    port = start_port
+    while port < 65535:
+        try:
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                s.bind(("127.0.0.1", port))
+                return port
+        except OSError:
+            port += 1
+    raise RuntimeError(f"No free port found starting from {start_port}")
+
+
+class GatewayTunnel:
+    """Async TLS + SNI gateway tunnel for database connections.
+
+    Routes local connections through gateway.plato.so using SNI-based routing.
+    This replaces the deprecated HTTP CONNECT proxy tunnel.
+
+    Usage:
+        tunnel = GatewayTunnel(job_id="abc123", remote_port=5432, local_port=55432)
+        await tunnel.start()
+        # Connect to localhost:55432 to reach the VM's port 5432
+        await tunnel.stop()
+    """
+
+    def __init__(
+        self,
+        job_id: str,
+        remote_port: int,
+        local_port: int,
+        gateway_host: str | None = None,
+        gateway_port: int | None = None,
+        verify_ssl: bool = True,
+    ):
+        """Initialize the gateway tunnel.
+
+        Args:
+            job_id: The job/environment ID to connect to.
+            remote_port: Port on the VM to forward to.
+            local_port: Local port to listen on.
+            gateway_host: Gateway hostname (default: from env or gateway.plato.so).
+            gateway_port: Gateway port (default: from env or 443).
+            verify_ssl: Whether to verify SSL certificates.
+        """
+        self.job_id = job_id
+        self.remote_port = remote_port
+        self.local_port = local_port
+        self.verify_ssl = verify_ssl
+
+        # Get gateway config
+        default_host, default_port = get_gateway_config()
+        self.gateway_host = gateway_host or default_host
+        self.gateway_port = gateway_port or default_port
+
+        # SNI for routing: {job_id}--{port}.gateway.plato.so
+        self.sni = f"{job_id}--{remote_port}.{self.gateway_host}"
+
+        self._server: asyncio.AbstractServer | None = None
+        self._client_tasks: set[asyncio.Task] = set()
+
+    async def _open_gateway_connection(
+        self,
+        timeout: float = 30.0,
+    ) -> tuple[asyncio.StreamReader, asyncio.StreamWriter]:
+        """Open a TLS connection to the gateway with SNI routing.
+
+        Returns:
+            Tuple of (reader, writer) for the gateway connection.
+        """
+        # Create SSL context
+        ssl_ctx = ssl.create_default_context()
+        if not self.verify_ssl:
+            ssl_ctx.check_hostname = False
+            ssl_ctx.verify_mode = ssl.CERT_NONE
+
+        # Connect with TLS, using SNI for routing
+        reader, writer = await asyncio.wait_for(
+            asyncio.open_connection(
+                self.gateway_host,
+                self.gateway_port,
+                ssl=ssl_ctx,
+                server_hostname=self.sni,  # SNI determines which VM/port to route to
+            ),
+            timeout=timeout,
+        )
+
+        # Enable TCP keepalive
+        sock = writer.get_extra_info("socket")
+        if isinstance(sock, socket.socket):
+            try:
+                sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
+                # macOS/BSD keepalive idle time
+                TCP_KEEPALIVE = getattr(socket, "TCP_KEEPALIVE", 0x10)
+                sock.setsockopt(socket.IPPROTO_TCP, TCP_KEEPALIVE, 30)
+            except OSError:
+                pass  # Best effort
+
+        return reader, writer
+
+    async def _pipe(
+        self,
+        src: asyncio.StreamReader,
+        dst: asyncio.StreamWriter,
+    ) -> None:
+        """Forward data from src to dst until EOF."""
+        try:
+            while True:
+                data = await src.read(65536)
+                if not data:
+                    break
+                dst.write(data)
+                await dst.drain()
+        except (ConnectionResetError, BrokenPipeError, OSError):
+            pass
+        finally:
+            try:
+                dst.close()
+                await dst.wait_closed()
+            except Exception:
+                pass
+
+    async def _handle_client(
+        self,
+        client_reader: asyncio.StreamReader,
+        client_writer: asyncio.StreamWriter,
+    ) -> None:
+        """Handle a single client connection by forwarding through gateway."""
+        task = asyncio.current_task()
+        if task:
+            self._client_tasks.add(task)
+
+        try:
+            # Connect to gateway via TLS with SNI
+            gateway_reader, gateway_writer = await self._open_gateway_connection()
+
+            # Bidirectional forwarding
+            await asyncio.gather(
+                self._pipe(client_reader, gateway_writer),
+                self._pipe(gateway_reader, client_writer),
+            )
+        except Exception as e:
+            logger.warning(f"Gateway tunnel error: {e}")
+            try:
+                client_writer.close()
+                await client_writer.wait_closed()
+            except Exception:
+                pass
+        finally:
+            if task:
+                self._client_tasks.discard(task)
+
+    async def start(self) -> None:
+        """Start the gateway tunnel server."""
+        logger.info(
+            f"Starting gateway tunnel: localhost:{self.local_port} -> "
+            f"{self.job_id}:{self.remote_port} via {self.gateway_host}"
+        )
+
+        self._server = await asyncio.start_server(
+            self._handle_client,
+            host="127.0.0.1",
+            port=self.local_port,
+        )
+
+        # Small delay to ensure binding is settled
+        await asyncio.sleep(0.1)
+
+        if not self._server.sockets:
+            raise RuntimeError("Gateway tunnel failed to start: no listening sockets")
+
+        logger.info(f"Gateway tunnel established on port {self.local_port}")
+
+    async def stop(self) -> None:
+        """Stop the gateway tunnel server."""
+        if self._server is not None:
+            logger.info("Stopping gateway tunnel")
+
+            # Stop accepting new connections
+            self._server.close()
+            await self._server.wait_closed()
+            self._server = None
+
+            # Cancel active client tasks
+            for t in list(self._client_tasks):
+                t.cancel()
+            self._client_tasks.clear()
+
+            logger.info("Gateway tunnel stopped")

plato_sdk_v2-2.7.1/VERSION

@@ -1 +0,0 @@
-2.7.1