plato-sdk-v2 2.0.50__py3-none-any.whl → 2.2.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/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")