plato-sdk-v2 2.0.64__py3-none-any.whl → 2.3.4__py3-none-any.whl

plato/v1/cli/agent.py

@@ -6,13 +6,16 @@ import re
 import shutil
 import subprocess
 import sys
-import tempfile
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 import typer
 
 from plato.v1.cli.utils import console, require_api_key
 
+if TYPE_CHECKING:
+    from plato.agents.build import BuildConfig
+
 
 def _extract_schemas(pkg_path: Path, package_name: str) -> tuple[dict | None, dict | None, dict | None]:
     """Extract Config, BuildConfig, and SecretsConfig schemas from the agent package.
@@ -279,8 +282,7 @@ def _publish_agent_image(
     description: str,
     dry_run: bool,
     schema_data: dict | None = None,
-    template_variables: dict[str, str] | None = None,
-    secrets_schema: dict | None = None,
+    build_config: "BuildConfig | None" = None,
 ) -> None:
     """Common logic for publishing an agent Docker image to ECR."""
     import httpx
@@ -298,9 +300,27 @@ def _publish_agent_image(
     console.print("[cyan]Building Docker image...[/cyan]")
     local_tag = f"{agent_name}:{version}"
 
+    # Build docker command with build args from config
+    docker_cmd = ["docker", "build", "--progress=plain", "-t", local_tag]
+
+    # Add --target prod if Dockerfile has multi-stage builds
+    dockerfile_path = build_path / "Dockerfile"
+    if dockerfile_path.exists():
+        dockerfile_content = dockerfile_path.read_text()
+        if "FROM" in dockerfile_content and "AS prod" in dockerfile_content:
+            docker_cmd.extend(["--target", "prod"])
+            console.print("[cyan]Using target: prod[/cyan]")
+
+    # Add build args from build config's env dict
+    if build_config and build_config.env:
+        for key, value in build_config.env.items():
+            docker_cmd.extend(["--build-arg", f"{key}={value}"])
+
+    docker_cmd.append(str(build_path))
+
     # Use Popen to stream output in real-time
     process = subprocess.Popen(
-        ["docker", "build", "--progress=plain", "-t", local_tag, str(build_path)],
+        docker_cmd,
         stdout=subprocess.PIPE,
         stderr=subprocess.STDOUT,
         text=True,
@@ -309,6 +329,9 @@ def _publish_agent_image(
 
     # Stream build output
     build_output = []
+    if process.stdout is None:
+        console.print("[red]Error: Failed to capture Docker build output[/red]")
+        raise typer.Exit(1)
     for line in iter(process.stdout.readline, ""):
         line = line.rstrip()
         if line:
@@ -405,10 +428,6 @@ def _publish_agent_image(
             "description": description,
             "config_schema": schema_data,
         }
-        if template_variables:
-            registration_data["template_variables"] = template_variables
-        if secrets_schema:
-            registration_data["secrets_schema"] = secrets_schema
         response = client.post(
             "/v2/agents/register",
             json=registration_data,
@@ -431,6 +450,11 @@ def _publish_agent_image(
     console.print(f"[cyan]Artifact ID:[/cyan] {reg_result['artifact_id']}")
     console.print(f"[cyan]Image:[/cyan] {ecr_image}")
 
+    # Clean up local images after successful push
+    console.print("[dim]Cleaning up local images...[/dim]")
+    subprocess.run(["docker", "rmi", local_tag], capture_output=True)
+    subprocess.run(["docker", "rmi", ecr_image], capture_output=True)
+
 
 def _publish_package(path: str, repo: str, dry_run: bool = False):
     """
@@ -545,6 +569,8 @@ def _publish_package(path: str, repo: str, dry_run: bool = False):
     upload_url = f"{api_url}/v2/pypi/{repo}/"
     console.print(f"\n[cyan]Uploading to {upload_url}...[/cyan]")
 
+    # api_key is guaranteed to be set (checked earlier when not dry_run)
+    assert api_key is not None, "api_key must be set when not in dry_run mode"
     try:
         result = subprocess.run(
             [
@@ -560,6 +586,7 @@ def _publish_package(path: str, repo: str, dry_run: bool = False):
             ],
             capture_output=True,
             text=True,
+            check=False,
         )
 
         if result.returncode == 0:
@@ -797,39 +824,10 @@ def agent_push(
             console.print(f"[yellow]Failed:[/yellow] {', '.join(failed)}")
         return
 
-    # Check if target is a Harbor agent name
-    if target in HARBOR_AGENTS:
-        harbor_version = _get_harbor_version()
-        console.print(f"[cyan]Harbor agent:[/cyan] {target}")
-        console.print(f"[cyan]Harbor version:[/cyan] {harbor_version}")
-
-        install_script = _get_harbor_install_script(target)
-        if not install_script:
-            console.print(f"[red]Error: Could not get install script for '{target}'[/red]")
-            console.print("[yellow]Make sure harbor is installed: pip install 'plato-sdk-v2[agents]'[/yellow]")
-            raise typer.Exit(1)
-
-        with tempfile.TemporaryDirectory() as tmpdir:
-            tmppath = Path(tmpdir)
-            aux_files = HARBOR_AGENT_AUX_FILES.get(target, [])
-            (tmppath / "Dockerfile").write_text(_build_harbor_dockerfile(aux_files))
-            (tmppath / "install.sh").write_text(install_script)
-            _copy_harbor_aux_files(target, tmppath)
-
-            _publish_agent_image(
-                agent_name=target,
-                version=harbor_version,
-                build_path=tmppath,
-                description=f"Harbor agent: {target}",
-                dry_run=dry_run,
-            )
-        return
-
-    # Otherwise, treat as a path to custom agent
+    # Treat target as a path to agent directory
     pkg_path = Path(target).resolve()
     if not pkg_path.exists():
-        console.print(f"[red]Error: '{target}' is not a Harbor agent name or valid path[/red]")
-        console.print(f"\n[yellow]Harbor agents:[/yellow] {', '.join(HARBOR_AGENTS.keys())}")
+        console.print(f"[red]Error: '{target}' is not a valid path[/red]")
         raise typer.Exit(1)
 
     _push_single_agent(pkg_path, dry_run)
@@ -837,6 +835,8 @@ def agent_push(
 
 def _push_single_agent(pkg_path: Path, dry_run: bool) -> None:
     """Push a single custom agent from a directory."""
+    from plato.agents.build import BuildConfig
+
     # Check for Dockerfile
     if not (pkg_path / "Dockerfile").exists():
         console.print(f"[red]Error: No Dockerfile found at {pkg_path}[/red]")
@@ -866,56 +866,61 @@ def _push_single_agent(pkg_path: Path, dry_run: bool) -> None:
         console.print("[red]Error: No version in pyproject.toml[/red]")
         raise typer.Exit(1)
 
-    # Extract short name
+    # Extract short name (remove common prefixes)
     short_name = package_name
-    for prefix in ("plato-agent-", "plato-"):
-        if short_name.startswith(prefix):
-            short_name = short_name[len(prefix) :]
+    for suffix in ("-agent",):
+        if short_name.endswith(suffix):
+            short_name = short_name[: -len(suffix)]
             break
 
-    # Extract Config (runtime), BuildConfig (build-time), and SecretsConfig schemas
-    console.print("[cyan]Looking for Config, BuildConfig, and SecretsConfig classes...[/cyan]")
-    schema_data, build_config_schema, secrets_schema = _extract_schemas(pkg_path, package_name)
+    # Load build config from pyproject.toml (optional, for build args)
+    build_config = None
+    try:
+        build_config = BuildConfig.from_pyproject(pkg_path)
+        if build_config.env:
+            console.print(f"[cyan]Build args:[/cyan] {list(build_config.env.keys())}")
+    except Exception:
+        pass  # Build config is optional
 
-    # Fall back to schema.json file for config_schema
-    if schema_data is None:
-        schema_file = pkg_path / "schema.json"
-        if schema_file.exists():
-            console.print(f"[cyan]Loading schema from {schema_file}[/cyan]")
-            try:
-                with open(schema_file) as f:
-                    schema_data = json.load(f)
-            except Exception as e:
-                console.print(f"[yellow]Warning: Failed to load schema.json: {e}[/yellow]")
+    # Load schema from entry point defined in pyproject.toml
+    schema_data = None
+    entry_points_config = pyproject.get("project", {}).get("entry-points", {}).get("plato.agents", {})
 
-    if schema_data:
-        console.print("[green]Config schema found (runtime config)[/green]")
+    if not entry_points_config:
+        console.print("[yellow]No plato.agents entry point in pyproject.toml - agent will have no schema[/yellow]")
     else:
-        console.print("[yellow]No Config schema found[/yellow]")
+        # Get the first (and typically only) entry point
+        # Format is: agent_name = "module_name:ClassName"
+        for ep_name, ep_value in entry_points_config.items():
+            try:
+                if ":" not in ep_value:
+                    console.print(f"[yellow]Invalid entry point format '{ep_value}' - expected 'module:Class'[/yellow]")
+                    continue
 
-    if secrets_schema:
-        console.print("[green]SecretsConfig schema found[/green]")
-    else:
-        console.print("[yellow]No SecretsConfig schema found[/yellow]")
-
-    # Extract template variables from BuildConfig schema
-    template_variables = _extract_template_variables(build_config_schema)
-    if template_variables:
-        console.print(f"[cyan]Template variables (from BuildConfig):[/cyan] {template_variables}")
-    elif build_config_schema:
-        console.print("[yellow]BuildConfig found but no template variables extracted[/yellow]")
-
-    # If this is a Harbor agent wrapper, generate install.sh from Harbor template
-    if short_name in HARBOR_AGENTS:
-        console.print(f"[cyan]Generating install.sh from Harbor template for {short_name}...[/cyan]")
-        install_script = _get_harbor_install_script(short_name, template_variables)
-        if install_script:
-            (pkg_path / "install.sh").write_text(install_script)
-            console.print("[green]install.sh generated[/green]")
-            # Copy auxiliary files if needed
-            _copy_harbor_aux_files(short_name, pkg_path)
-        else:
-            console.print("[yellow]Warning: Could not generate install.sh from Harbor template[/yellow]")
+                module_name, class_name = ep_value.split(":", 1)
+
+                # Add src/ to path and import
+                import sys
+
+                src_path = pkg_path / "src"
+                if src_path.exists():
+                    sys.path.insert(0, str(src_path))
+
+                try:
+                    module = __import__(module_name, fromlist=[class_name])
+                    agent_cls = getattr(module, class_name)
+                    schema_data = agent_cls.get_schema()
+                    console.print(f"[green]Loaded schema from {class_name}[/green]")
+                    break
+                finally:
+                    if src_path.exists() and str(src_path) in sys.path:
+                        sys.path.remove(str(src_path))
+
+            except Exception as e:
+                console.print(f"[yellow]Failed to load schema from entry point: {e}[/yellow]")
+
+    if not schema_data:
+        console.print("[yellow]No schema found (agent will have no config validation)[/yellow]")
 
     _publish_agent_image(
         agent_name=short_name,
@@ -924,8 +929,7 @@ def _push_single_agent(pkg_path: Path, dry_run: bool) -> None:
         description=description or f"Custom agent: {short_name}",
         dry_run=dry_run,
         schema_data=schema_data,
-        template_variables=template_variables,
-        secrets_schema=secrets_schema,
+        build_config=build_config,
     )
 
 

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,