plato-sdk-v2 2.1.11__py3-none-any.whl → 2.3.0__py3-none-any.whl

plato/v1/cli/main.py

@@ -11,6 +11,7 @@ from dotenv import load_dotenv
 from plato.v1.cli.agent import agent_app
 from plato.v1.cli.pm import pm_app
 from plato.v1.cli.sandbox import sandbox_app
+from plato.v1.cli.sim import sim_app
 from plato.v1.cli.utils import console
 from plato.v1.cli.world import world_app
 
@@ -69,6 +70,7 @@ app = typer.Typer(help="[bold blue]Plato CLI[/bold blue] - Manage Plato environm
 # Register sub-apps
 app.add_typer(sandbox_app, name="sandbox")
 app.add_typer(pm_app, name="pm")
+app.add_typer(sim_app, name="sim")
 app.add_typer(agent_app, name="agent")
 app.add_typer(world_app, name="world")
 

plato/v1/cli/pm.py

@@ -10,10 +10,6 @@ from pathlib import Path
 
 import httpx
 import typer
-
-# UUID pattern for detecting artifact IDs in sim:artifact notation
-UUID_PATTERN = re.compile(r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", re.IGNORECASE)
-from playwright.async_api import async_playwright
 from rich.table import Table
 
 from plato._generated.api.v1.env import get_simulator_by_name, get_simulators
@@ -43,9 +39,17 @@ from plato.v1.cli.utils import (
     require_sandbox_field,
     require_sandbox_state,
 )
+from plato.v1.cli.verify import pm_verify_app
 from plato.v2.async_.client import AsyncPlato
 from plato.v2.types import Env
 
+# =============================================================================
+# CONSTANTS
+# =============================================================================
+
+# UUID pattern for detecting artifact IDs in sim:artifact notation
+UUID_PATTERN = re.compile(r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", re.IGNORECASE)
+
 # =============================================================================
 # APP STRUCTURE
 # =============================================================================
@@ -58,6 +62,7 @@ submit_app = typer.Typer(help="Submit simulator artifacts for review")
 pm_app.add_typer(list_app, name="list")
 pm_app.add_typer(review_app, name="review")
 pm_app.add_typer(submit_app, name="submit")
+pm_app.add_typer(pm_verify_app, name="verify")
 
 
 # =============================================================================
@@ -340,6 +345,9 @@ def review_base(
         try:
             http_client = plato._http
 
+            # simulator_name is guaranteed set by parse_simulator_artifact (or we exit)
+            assert simulator_name is not None, "simulator_name must be set"
+
             # Get simulator by name
             sim = await get_simulator_by_name.asyncio(
                 client=http_client,
@@ -353,7 +361,7 @@ def review_base(
             console.print(f"[cyan]Current status:[/cyan] {current_status}")
 
             # Use provided artifact ID or fall back to base_artifact_id from server config
-            artifact_id = artifact_id_input if artifact_id_input else current_config.get("base_artifact_id")
+            artifact_id: str | None = artifact_id_input if artifact_id_input else current_config.get("base_artifact_id")
             if not artifact_id:
                 console.print("[red]❌ No artifact ID provided.[/red]")
                 console.print(
@@ -390,6 +398,8 @@ def review_base(
 
                 # Launch Playwright browser and login
                 console.print("[cyan]Launching browser and logging in...[/cyan]")
+                from playwright.async_api import async_playwright
+
                 playwright = await async_playwright().start()
                 browser = await playwright.chromium.launch(headless=False)
 
@@ -403,44 +413,57 @@ def review_base(
                     if public_url:
                         await page.goto(public_url)
 
-                # If skip_review, check state and exit without interactive loop
-                if skip_review:
-                    console.print("\n[cyan]Checking environment state after login...[/cyan]")
-                    try:
-                        state_response = await sessions_state.asyncio(
-                            client=http_client,
-                            session_id=session.session_id,
-                            merge_mutations=True,
-                            x_api_key=api_key,
-                        )
-                        if state_response and state_response.results:
-                            has_mutations = False
-                            for jid, result in state_response.results.items():
-                                state_data = result.state if hasattr(result, "state") else result
-                                if isinstance(state_data, dict):
-                                    mutations = state_data.pop("mutations", [])
-                                    console.print(f"\n[bold cyan]Job {jid}:[/bold cyan]")
-                                    console.print("\n[bold]State:[/bold]")
-                                    console.print(json.dumps(state_data, indent=2, default=str))
-                                    if mutations:
-                                        has_mutations = True
-                                        console.print(f"\n[bold red]Mutations ({len(mutations)}):[/bold red]")
-                                        console.print(json.dumps(mutations, indent=2, default=str))
-                                    else:
-                                        console.print("\n[green]No mutations recorded[/green]")
-
-                            if has_mutations:
-                                console.print("\n[bold red]⚠️  WARNING: Login flow created mutations![/bold red]")
-                                console.print("[yellow]The login flow should NOT modify database state.[/yellow]")
+                # ALWAYS check state after login to verify no mutations
+                console.print("\n[cyan]Checking environment state after login...[/cyan]")
+                has_mutations = False
+                has_errors = False
+                try:
+                    state_response = await sessions_state.asyncio(
+                        client=http_client,
+                        session_id=session.session_id,
+                        merge_mutations=True,
+                        x_api_key=api_key,
+                    )
+                    if state_response and state_response.results:
+                        for jid, result in state_response.results.items():
+                            state_data = result.state if hasattr(result, "state") else result
+                            console.print(f"\n[bold cyan]Job {jid}:[/bold cyan]")
+
+                            if isinstance(state_data, dict):
+                                # Check for error in state response
+                                if "error" in state_data:
+                                    has_errors = True
+                                    console.print("\n[bold red]❌ State API Error:[/bold red]")
+                                    console.print(f"[red]{state_data['error']}[/red]")
+                                    continue
+
+                                mutations = state_data.pop("mutations", [])
+                                console.print("\n[bold]State:[/bold]")
+                                console.print(json.dumps(state_data, indent=2, default=str))
+                                if mutations:
+                                    has_mutations = True
+                                    console.print(f"\n[bold red]Mutations ({len(mutations)}):[/bold red]")
+                                    console.print(json.dumps(mutations, indent=2, default=str))
+                                else:
+                                    console.print("\n[green]No mutations recorded[/green]")
                             else:
-                                console.print(
-                                    "\n[bold green]✅ Login flow verified - no mutations created[/bold green]"
-                                )
+                                console.print(f"[yellow]Unexpected state format: {type(state_data)}[/yellow]")
+
+                        if has_errors:
+                            console.print("\n[bold red]❌ State check failed due to errors![/bold red]")
+                            console.print("[yellow]The worker may not be properly connected.[/yellow]")
+                        elif has_mutations:
+                            console.print("\n[bold red]⚠️  WARNING: Login flow created mutations![/bold red]")
+                            console.print("[yellow]The login flow should NOT modify database state.[/yellow]")
                         else:
-                            console.print("[yellow]No state data available[/yellow]")
-                    except Exception as e:
-                        console.print(f"[red]❌ Error getting state: {e}[/red]")
+                            console.print("\n[bold green]✅ Login flow verified - no mutations created[/bold green]")
+                    else:
+                        console.print("[yellow]No state data available[/yellow]")
+                except Exception as e:
+                    console.print(f"[red]❌ Error getting state: {e}[/red]")
 
+                # If skip_review, exit without interactive loop
+                if skip_review:
                     console.print("\n[cyan]Skipping interactive review (--skip-review)[/cyan]")
                     return
 
@@ -492,9 +515,16 @@ def review_base(
                                 if state_response and state_response.results:
                                     for jid, result in state_response.results.items():
                                         state_data = result.state if hasattr(result, "state") else result
+                                        console.print(f"\n[bold cyan]Job {jid}:[/bold cyan]")
+
                                         if isinstance(state_data, dict):
+                                            # Check for error in state response
+                                            if "error" in state_data:
+                                                console.print("\n[bold red]❌ State API Error:[/bold red]")
+                                                console.print(f"[red]{state_data['error']}[/red]")
+                                                continue
+
                                             mutations = state_data.pop("mutations", [])
-                                            console.print(f"\n[bold cyan]Job {jid}:[/bold cyan]")
                                             console.print("\n[bold]State:[/bold]")
                                             console.print(json.dumps(state_data, indent=2, default=str))
                                             if mutations:
@@ -503,7 +533,6 @@ def review_base(
                                             else:
                                                 console.print("\n[yellow]No mutations recorded[/yellow]")
                                         else:
-                                            console.print(f"\n[bold cyan]Job {jid}:[/bold cyan]")
                                             console.print(json.dumps(state_data, indent=2, default=str))
                                 else:
                                     console.print("[yellow]No state data available[/yellow]")
@@ -579,9 +608,11 @@ def review_base(
             console.print(f"[cyan]Status:[/cyan] {current_status} → {new_status}")
 
             # If passed, automatically tag artifact as prod-latest
-            if outcome == "pass":
+            if outcome == "pass" and artifact_id:
                 console.print("\n[cyan]Tagging artifact as prod-latest...[/cyan]")
                 try:
+                    # simulator_name and artifact_id are guaranteed to be set at this point
+                    assert simulator_name is not None
                     await update_tag.asyncio(
                         client=http_client,
                         body=UpdateTagRequest(
@@ -681,6 +712,9 @@ def review_data(
 
     async def _fetch_artifact_info():
         nonlocal artifact_id
+        # simulator_name is guaranteed set by parse_simulator_artifact (or we exit)
+        assert simulator_name is not None, "simulator_name must be set"
+
         base_url = _get_base_url()
         async with httpx.AsyncClient(base_url=base_url, timeout=60.0) as client:
             try:
@@ -755,6 +789,8 @@ def review_data(
 
             console.print("[cyan]Launching Chrome with EnvGen Recorder extension...[/cyan]")
 
+            from playwright.async_api import async_playwright
+
             playwright = await async_playwright().start()
 
             browser = await playwright.chromium.launch_persistent_context(
@@ -1080,6 +1116,10 @@ def submit_data(
     )
 
     async def _submit_data():
+        # simulator_name and artifact_id are guaranteed set by parse_simulator_artifact with require_artifact=True
+        assert simulator_name is not None, "simulator_name must be set"
+        assert artifact_id is not None, "artifact_id must be set"
+
         base_url = _get_base_url()
 
         async with httpx.AsyncClient(base_url=base_url, timeout=60.0) as client:
@@ -1110,7 +1150,7 @@ def submit_data(
                 x_api_key=api_key,
             )
 
-            # Set data_artifact_id via tag update
+            # Set data_artifact_id via tag update (simulator_name and artifact_id already asserted above)
             try:
                 await update_tag.asyncio(
                     client=client,

plato/v1/cli/sandbox.py

@@ -17,12 +17,8 @@ from urllib.parse import quote
 
 import typer
 import yaml
-from playwright.async_api import async_playwright
 from rich.logging import RichHandler
 
-# UUID pattern for detecting artifact IDs in colon notation
-UUID_PATTERN = re.compile(r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", re.IGNORECASE)
-
 from plato._generated.api.v1.gitea import (
     create_simulator_repository,
     get_accessible_simulators,
@@ -74,11 +70,16 @@ from plato.v1.cli.utils import (
     require_sandbox_state,
     save_sandbox_state,
 )
+from plato.v1.cli.verify import sandbox_verify_app
 from plato.v2.async_.flow_executor import FlowExecutor
 from plato.v2.sync.client import Plato as PlatoV2
 from plato.v2.types import Env, SimConfigCompute
 
+# UUID pattern for detecting artifact IDs in colon notation
+UUID_PATTERN = re.compile(r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", re.IGNORECASE)
+
 sandbox_app = typer.Typer(help="Manage sandboxes for simulator development")
+sandbox_app.add_typer(sandbox_verify_app, name="verify")
 
 
 def format_public_url_with_router_target(public_url: str | None, service_name: str | None) -> str | None:
@@ -423,9 +424,10 @@ def sandbox_start(
                         listeners=listeners_dict,
                     )
 
+                    dataset_value = dataset_name or state_extras.get("dataset", "base")
                     setup_request = AppSchemasBuildModelsSetupSandboxRequest(
                         service=sim_name or "",
-                        dataset=dataset_name or state_extras.get("dataset", "base") or "",
+                        dataset=str(dataset_value) if dataset_value else "",
                         plato_dataset_config=dataset_config_obj,
                         ssh_public_key=ssh_public_key,
                     )
@@ -1047,6 +1049,9 @@ def sandbox_start_worker(
                     console.print(f"[cyan]Waiting for worker to be ready (timeout: {wait_timeout}s)...[/cyan]")
 
                 session_id = state.get("session_id")
+                if not session_id:
+                    console.print("[red]Session ID not found in .sandbox.yaml[/red]")
+                    raise typer.Exit(1)
                 start_time = time.time()
                 poll_interval = 10  # seconds between polls
                 worker_ready = False
@@ -1530,17 +1535,31 @@ def sandbox_flow(
             console.print(f"[red]❌ Failed to fetch flows from API: {e}[/red]")
             raise typer.Exit(1) from e
 
+    # At this point, url and flow_obj must be set (validated above)
+    if not url:
+        console.print("[red]❌ URL is not set[/red]")
+        raise typer.Exit(1)
+    if not flow_obj:
+        console.print("[red]❌ Flow object could not be loaded[/red]")
+        raise typer.Exit(1)
+
     console.print(f"[cyan]URL: {url}[/cyan]")
     console.print(f"[cyan]Flow name: {flow_name}[/cyan]")
 
+    # Capture for closure (narrowed types)
+    _url: str = url
+    _flow_obj: Flow = flow_obj
+
     async def _run():
+        from playwright.async_api import async_playwright
+
         browser = None
         try:
             async with async_playwright() as p:
                 browser = await p.chromium.launch(headless=False)
                 page = await browser.new_page()
-                await page.goto(url)
-                executor = FlowExecutor(page, flow_obj, screenshots_dir, log=_flow_logger)
+                await page.goto(_url)
+                executor = FlowExecutor(page, _flow_obj, screenshots_dir, log=_flow_logger)
                 await executor.execute()
                 console.print("[green]✅ Flow executed successfully[/green]")
         except Exception as e:
@@ -1601,8 +1620,23 @@ def sandbox_state_cmd(
     def check_mutations(result_dict: dict) -> tuple[bool, bool, str | None]:
         """Check if result has mutations or errors. Returns (has_mutations, has_error, error_msg)."""
         if isinstance(result_dict, dict):
-            if "error" in result_dict:
-                return False, True, result_dict.get("error")
+            # Check for state
+            state = result_dict.get("state", {})
+            if isinstance(state, dict):
+                # Check for error wrapped in state (from API layer transformation)
+                if "error" in state:
+                    return False, True, state["error"]
+                # Check for db state
+                db_state = state.get("db", {})
+                if isinstance(db_state, dict):
+                    mutations = db_state.get("mutations", [])
+                    if mutations:
+                        return True, False, None
+                    # Also check audit_log_count
+                    audit_count = db_state.get("audit_log_count", 0)
+                    if audit_count > 0:
+                        return True, False, None
+            # Check top-level mutations as fallback
             mutations = result_dict.get("mutations", [])
             if mutations:
                 return True, False, None
@@ -2004,6 +2038,10 @@ def sandbox_start_services(
             if not json_output:
                 console.print("[cyan]Step 3: Getting/creating repository...[/cyan]")
 
+            if sim_id is None:
+                console.print("[red]❌ Simulator ID not available[/red]")
+                raise typer.Exit(1)
+
             if has_repo:
                 repo = get_simulator_repository.sync(client=client, simulator_id=sim_id, x_api_key=api_key)
             else:

plato/v1/cli/sim.py

@@ -0,0 +1,11 @@
+"""Plato CLI - Simulator commands (stub)."""
+
+import typer
+
+sim_app = typer.Typer(help="Simulator management commands (coming soon)")
+
+
+@sim_app.command()
+def list():
+    """List available simulators."""
+    typer.echo("Simulator list command not yet implemented.")