plato-sdk-v2 2.3.3__py3-none-any.whl → 2.4.1__py3-none-any.whl

plato/v1/cli/main.py

@@ -9,6 +9,7 @@ import typer
 from dotenv import load_dotenv
 
 from plato.v1.cli.agent import agent_app
+from plato.v1.cli.chronos import chronos_app
 from plato.v1.cli.pm import pm_app
 from plato.v1.cli.sandbox import sandbox_app
 from plato.v1.cli.utils import console
@@ -71,6 +72,7 @@ app.add_typer(sandbox_app, name="sandbox")
 app.add_typer(pm_app, name="pm")
 app.add_typer(agent_app, name="agent")
 app.add_typer(world_app, name="world")
+app.add_typer(chronos_app, name="chronos")
 
 
 # =============================================================================

plato/v1/cli/pm.py

@@ -753,16 +753,16 @@ def review_data(
     is_installed = "site-packages" in str(package_dir)
 
     if is_installed:
-        extension_source_path = package_dir / "extensions" / "envgen-recorder"
+        extension_source_path = package_dir / "extensions" / "envgen-recorder-old"
     else:
         repo_root = package_dir.parent.parent.parent  # plato-client/
-        extension_source_path = repo_root / "extensions" / "envgen-recorder"
+        extension_source_path = repo_root / "extensions" / "envgen-recorder-old"
 
     # 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"
+            env_path = Path(plato_client_dir_env) / "extensions" / "envgen-recorder-old"
             if env_path.exists():
                 extension_source_path = env_path
 

plato/v1/cli/sandbox.py

@@ -131,6 +131,9 @@ def sandbox_start(
     timeout: int = typer.Option(1800, "--timeout", help="VM lifetime in seconds (default: 30 minutes)"),
     no_reset: bool = typer.Option(False, "--no-reset", help="Skip initial reset after ready"),
     json_output: bool = typer.Option(False, "--json", "-j", help="Output as JSON"),
+    working_dir: Path = typer.Option(
+        None, "--working-dir", "-w", help="Working directory for .sandbox.yaml and .plato/"
+    ),
 ):
     """
     Start a sandbox environment.
@@ -377,7 +380,7 @@ def sandbox_start(
                     console.print("[cyan]  Generating SSH key pair...[/cyan]")
 
                 base_url = os.getenv("PLATO_BASE_URL", "https://plato.so")
-                ssh_info = setup_ssh_for_sandbox(base_url, job_id, username=ssh_username)
+                ssh_info = setup_ssh_for_sandbox(base_url, job_id, username=ssh_username, working_dir=working_dir)
                 ssh_host = ssh_info["ssh_host"]
                 ssh_config_path = ssh_info["config_path"]
                 ssh_private_key_path = ssh_info["private_key_path"]
@@ -489,7 +492,7 @@ def sandbox_start(
         # Add heartbeat PID
         if heartbeat_pid:
             state["heartbeat_pid"] = heartbeat_pid
-        save_sandbox_state(state)
+        save_sandbox_state(state, working_dir)
 
         # Close the plato client (heartbeat process keeps session alive)
         plato.close()
@@ -1641,6 +1644,8 @@ def sandbox_state_cmd(
                 return True, False, None
         return False, False, None
 
+    all_mutations = []
+
     if session_id:
         if not json_output:
             console.print(f"[cyan]Getting state for session: {session_id}[/cyan]")
@@ -1648,6 +1653,7 @@ def sandbox_state_cmd(
             response = sessions_state.sync(
                 client=client,
                 session_id=session_id,
+                merge_mutations=True,
                 x_api_key=api_key,
             )
             if response and response.results:
@@ -1661,6 +1667,13 @@ def sandbox_state_cmd(
                     has_error = has_error or e
                     if msg:
                         error_message = msg
+                    # Extract mutations from state
+                    if isinstance(result, dict) and "state" in result:
+                        state_data = result.get("state", {})
+                        if isinstance(state_data, dict):
+                            mutations = state_data.get("mutations", [])
+                            if mutations:
+                                all_mutations.extend(mutations)
     elif job_id:
         if not json_output:
             console.print(f"[cyan]Getting state for job: {job_id}[/cyan]")
@@ -1676,6 +1689,13 @@ def sandbox_state_cmd(
                 has_mutations = m
                 has_error = e
                 error_message = msg
+                # Extract mutations from state
+                if isinstance(state_dict, dict) and "state" in state_dict:
+                    state_data = state_dict.get("state", {})
+                    if isinstance(state_data, dict):
+                        mutations = state_data.get("mutations", [])
+                        if mutations:
+                            all_mutations.extend(mutations)
     elif job_group_id:
         if not json_output:
             console.print(f"[cyan]Getting state for job_group: {job_group_id}[/cyan]")
@@ -1683,6 +1703,7 @@ def sandbox_state_cmd(
             response = sessions_state.sync(
                 client=client,
                 session_id=job_group_id,
+                merge_mutations=True,
                 x_api_key=api_key,
             )
             if response and response.results:
@@ -1696,6 +1717,13 @@ def sandbox_state_cmd(
                     has_error = has_error or e
                     if msg:
                         error_message = msg
+                    # Extract mutations from state
+                    if isinstance(result, dict) and "state" in result:
+                        state_data = result.get("state", {})
+                        if isinstance(state_data, dict):
+                            mutations = state_data.get("mutations", [])
+                            if mutations:
+                                all_mutations.extend(mutations)
     else:
         console.print("[red]❌ .sandbox.yaml missing session_id, job_id, or job_group_id[/red]")
         raise typer.Exit(1)
@@ -1716,6 +1744,26 @@ def sandbox_state_cmd(
         elif state_dict:
             console.print("\n[bold]Environment State:[/bold]")
             console.print(json.dumps(state_dict, indent=2, default=str))
+
+            # Display mutations if any
+            if all_mutations:
+                console.print(f"\n[bold red]Mutations ({len(all_mutations)}):[/bold red]")
+                # Group by table and action for summary
+                from collections import defaultdict
+
+                table_ops: dict[str, dict[str, int]] = defaultdict(lambda: {"INSERT": 0, "UPDATE": 0, "DELETE": 0})
+                for mutation in all_mutations:
+                    table = mutation.get("table_name", mutation.get("table", "unknown"))
+                    op = mutation.get("action", mutation.get("operation", "UNKNOWN")).upper()
+                    if op in table_ops[table]:
+                        table_ops[table][op] += 1
+
+                console.print("\n  [dim]Table                           INSERT  UPDATE  DELETE[/dim]")
+                console.print("  [dim]───────────────────────────────────────────────────────[/dim]")
+                for table, ops in sorted(table_ops.items(), key=lambda x: sum(x[1].values()), reverse=True):
+                    console.print(f"  {table:<30} {ops['INSERT']:>6}  {ops['UPDATE']:>6}  {ops['DELETE']:>6}")
+            else:
+                console.print("\n[green]No mutations recorded[/green]")
         else:
             console.print("[yellow]No state returned[/yellow]")
 
@@ -1816,8 +1864,6 @@ def sandbox_clear_audit(
 
     for name, db_config in db_listeners:
         db_type = db_config.get("db_type", "postgresql").lower()
-        db_host = db_config.get("db_host", "127.0.0.1")
-        db_port = db_config.get("db_port", 5432 if db_type == "postgresql" else 3306)
         db_user = db_config.get("db_user", "postgres" if db_type == "postgresql" else "root")
         db_password = db_config.get("db_password", "")
         db_database = db_config.get("db_database", "postgres")
@@ -1826,10 +1872,16 @@ def sandbox_clear_audit(
             console.print(f"[cyan]Clearing audit_log for listener '{name}' ({db_type})...[/cyan]")
 
         # Build SQL command based on db_type
+        # Use docker exec since psql/mysql aren't installed on the VM directly
         if db_type == "postgresql":
-            sql_cmd = f"PGPASSWORD='{db_password}' psql -h {db_host} -p {db_port} -U {db_user} -d {db_database} -c 'TRUNCATE TABLE audit_log RESTART IDENTITY CASCADE'"
+            # Find the postgres container and truncate all audit_log tables across all schemas
+            # Use $body$ delimiter instead of $$ to avoid shell expansion
+            truncate_sql = "DO \\$body\\$ DECLARE r RECORD; BEGIN FOR r IN SELECT schemaname FROM pg_tables WHERE tablename = 'audit_log' LOOP EXECUTE format('TRUNCATE TABLE %I.audit_log RESTART IDENTITY CASCADE', r.schemaname); END LOOP; END \\$body\\$;"
+            sql_cmd = f"CONTAINER=$(docker ps --format '{{{{.Names}}}}\\t{{{{.Image}}}}' | grep -i postgres | head -1 | cut -f1) && docker exec $CONTAINER psql -U {db_user} -d {db_database} -c \"{truncate_sql}\""
         elif db_type in ("mysql", "mariadb"):
-            sql_cmd = f"mysql -h {db_host} -P {db_port} -u {db_user} -p'{db_password}' {db_database} -e 'SET FOREIGN_KEY_CHECKS=0; DELETE FROM audit_log; SET FOREIGN_KEY_CHECKS=1;'"
+            # Find the mysql/mariadb container and exec into it
+            # Use mariadb client (mysql is a symlink or may not exist in newer mariadb images)
+            sql_cmd = f"CONTAINER=$(docker ps --format '{{{{.Names}}}}\\t{{{{.Image}}}}' | grep -iE 'mysql|mariadb' | head -1 | cut -f1) && docker exec $CONTAINER mariadb -u {db_user} -p'{db_password}' {db_database} -e 'SET FOREIGN_KEY_CHECKS=0; DELETE FROM audit_log; SET FOREIGN_KEY_CHECKS=1;'"
         else:
             if not json_output:
                 console.print(f"[yellow]⚠ Unsupported db_type '{db_type}' for listener '{name}'[/yellow]")

plato/v1/cli/ssh.py

@@ -9,21 +9,21 @@ from cryptography.hazmat.primitives import serialization
 from cryptography.hazmat.primitives.asymmetric import ed25519
 
 
-def get_plato_dir() -> Path:
+def get_plato_dir(working_dir: Path | str | None = None) -> Path:
     """Get the directory for plato config/SSH files.
 
-    Uses /workspace/.plato if /workspace exists (container environment),
-    otherwise uses ~/.plato (local development).
+    Args:
+        working_dir: If provided, returns working_dir/.plato (for container/agent use).
+                     If None, returns ~/.plato (local development).
     """
-    workspace = Path("/workspace")
-    if workspace.exists() and workspace.is_dir():
-        return workspace / ".plato"
+    if working_dir is not None:
+        return Path(working_dir) / ".plato"
     return Path.home() / ".plato"
 
 
-def get_next_sandbox_number() -> int:
+def get_next_sandbox_number(working_dir: Path | str | None = None) -> int:
     """Find next available sandbox number by checking existing config files."""
-    plato_dir = get_plato_dir()
+    plato_dir = get_plato_dir(working_dir)
     if not plato_dir.exists():
         return 1
 
@@ -41,13 +41,13 @@ def get_next_sandbox_number() -> int:
     return max_num + 1
 
 
-def generate_ssh_key_pair(sandbox_num: int) -> tuple[str, str]:
+def generate_ssh_key_pair(sandbox_num: int, working_dir: Path | str | None = None) -> tuple[str, str]:
     """
     Generate a new ed25519 SSH key pair for a specific sandbox.
 
     Returns (public_key_str, private_key_path).
     """
-    plato_dir = get_plato_dir()
+    plato_dir = get_plato_dir(working_dir)
     plato_dir.mkdir(mode=0o700, exist_ok=True)
 
     private_key_path = plato_dir / f"ssh_{sandbox_num}_key"
@@ -136,6 +136,7 @@ def create_ssh_config(
     username: str,
     private_key_path: str,
     sandbox_num: int,
+    working_dir: Path | str | None = None,
 ) -> str:
     """
     Create a temporary SSH config file for a specific sandbox.
@@ -172,7 +173,7 @@ def create_ssh_config(
     TCPKeepAlive yes
 """
 
-    plato_dir = get_plato_dir()
+    plato_dir = get_plato_dir(working_dir)
     plato_dir.mkdir(mode=0o700, exist_ok=True)
 
     config_path = plato_dir / f"ssh_{sandbox_num}.conf"
@@ -182,7 +183,12 @@ def create_ssh_config(
     return str(config_path)
 
 
-def setup_ssh_for_sandbox(base_url: str, job_public_id: str, username: str = "plato") -> dict:
+def setup_ssh_for_sandbox(
+    base_url: str,
+    job_public_id: str,
+    username: str = "plato",
+    working_dir: Path | str | None = None,
+) -> dict:
     """
     Set up SSH access for a sandbox - generates keys and creates config.
 
@@ -190,14 +196,14 @@ def setup_ssh_for_sandbox(base_url: str, job_public_id: str, username: str = "pl
 
     Returns dict with: ssh_host, config_path, public_key, private_key_path
     """
-    sandbox_num = get_next_sandbox_number()
+    sandbox_num = get_next_sandbox_number(working_dir)
     ssh_host = f"sandbox-{sandbox_num}"
 
     # Choose random port between 2200 and 2299
     local_port = random.randint(2200, 2299)
 
     # Generate SSH key pair
-    public_key, private_key_path = generate_ssh_key_pair(sandbox_num)
+    public_key, private_key_path = generate_ssh_key_pair(sandbox_num, working_dir)
 
     # Create SSH config file
     config_path = create_ssh_config(
@@ -208,6 +214,7 @@ def setup_ssh_for_sandbox(base_url: str, job_public_id: str, username: str = "pl
         username=username,
         private_key_path=private_key_path,
         sandbox_num=sandbox_num,
+        working_dir=working_dir,
     )
 
     return {

plato/v1/cli/templates/world-runner.Dockerfile

@@ -0,0 +1,27 @@
+# World runner image for plato chronos dev
+# Includes git, docker CLI, and Python dependencies
+
+FROM python:3.12-slim
+
+# Install git and docker CLI
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    git \
+    curl \
+    ca-certificates \
+    && curl -fsSL https://get.docker.com -o get-docker.sh \
+    && sh get-docker.sh \
+    && rm get-docker.sh \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install uv for fast package installation
+RUN pip install --no-cache-dir uv
+
+WORKDIR /world
+
+# Entry point expects:
+# - /world mounted with world source
+# - /python-sdk mounted with plato SDK source (optional, for dev)
+# - /config.json mounted with config
+# - WORLD_NAME env var set
+CMD ["bash", "-c", "if [ -d /python-sdk ]; then uv pip install --system /python-sdk; fi && uv pip install --system . 2>/dev/null || pip install -q . && plato-world-runner run --world $WORLD_NAME --config /config.json"]

plato/v1/cli/utils.py

@@ -15,32 +15,52 @@ console = Console()
 SANDBOX_FILE = ".sandbox.yaml"
 
 
-def get_sandbox_state() -> dict | None:
-    """Read sandbox state from .sandbox.yaml in current directory."""
-    sandbox_file = Path.cwd() / SANDBOX_FILE
+def get_sandbox_state(working_dir: Path | str | None = None) -> dict | None:
+    """Read sandbox state from .sandbox.yaml.
+
+    Args:
+        working_dir: Directory containing .sandbox.yaml. If None, uses cwd.
+    """
+    base_dir = Path(working_dir) if working_dir else Path.cwd()
+    sandbox_file = base_dir / SANDBOX_FILE
     if not sandbox_file.exists():
         return None
     with open(sandbox_file) as f:
         return yaml.safe_load(f)
 
 
-def save_sandbox_state(state: dict) -> None:
-    """Save sandbox state to .sandbox.yaml in current directory."""
-    sandbox_file = Path.cwd() / SANDBOX_FILE
+def save_sandbox_state(state: dict, working_dir: Path | str | None = None) -> None:
+    """Save sandbox state to .sandbox.yaml.
+
+    Args:
+        state: State dict to save.
+        working_dir: Directory to save .sandbox.yaml in. If None, uses cwd.
+    """
+    base_dir = Path(working_dir) if working_dir else Path.cwd()
+    sandbox_file = base_dir / SANDBOX_FILE
     with open(sandbox_file, "w") as f:
         yaml.dump(state, f, default_flow_style=False)
 
 
-def remove_sandbox_state() -> None:
-    """Remove .sandbox.yaml from current directory."""
-    sandbox_file = Path.cwd() / SANDBOX_FILE
+def remove_sandbox_state(working_dir: Path | str | None = None) -> None:
+    """Remove .sandbox.yaml.
+
+    Args:
+        working_dir: Directory containing .sandbox.yaml. If None, uses cwd.
+    """
+    base_dir = Path(working_dir) if working_dir else Path.cwd()
+    sandbox_file = base_dir / SANDBOX_FILE
     if sandbox_file.exists():
         sandbox_file.unlink()
 
 
-def require_sandbox_state() -> dict:
-    """Get sandbox state or exit with error."""
-    state = get_sandbox_state()
+def require_sandbox_state(working_dir: Path | str | None = None) -> dict:
+    """Get sandbox state or exit with error.
+
+    Args:
+        working_dir: Directory containing .sandbox.yaml. If None, uses cwd.
+    """
+    state = get_sandbox_state(working_dir)
     if not state:
         console.print("[red]No sandbox found in current directory[/red]")
         console.print("\n[yellow]Start a sandbox with:[/yellow]")

plato/worlds/README.md

@@ -28,7 +28,8 @@ Create a JSON config file:
   },
   "git_token": "ghp_...",
   "session_id": "local-test-001",
-  "callback_url": ""
+  "otel_url": "",
+  "upload_url": ""
 }
 ```