plato-sdk-v2 2.0.50__py3-none-any.whl → 2.2.4__py3-none-any.whl

plato/v1/cli/pm.py

@@ -3,24 +3,28 @@
 import asyncio
 import json
 import os
+import re
 import shutil
 import tempfile
 from pathlib import Path
 
 import httpx
 import typer
-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
+from plato._generated.api.v1.organization import get_organization_members
 from plato._generated.api.v1.simulator import (
     add_simulator_review,
+    update_simulator,
     update_simulator_status,
     update_tag,
 )
 from plato._generated.api.v2.sessions import state as sessions_state
 from plato._generated.models import (
     AddReviewRequest,
+    AppApiV1SimulatorRoutesUpdateSimulatorRequest,
+    Authentication,
     Outcome,
     ReviewType,
     UpdateStatusRequest,
@@ -35,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
 # =============================================================================
@@ -50,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")
 
 
 # =============================================================================
@@ -57,6 +70,70 @@ pm_app.add_typer(submit_app, name="submit")
 # =============================================================================
 
 
+def parse_simulator_artifact(
+    simulator: str | None,
+    artifact: str | None,
+    require_artifact: bool = False,
+    command_name: str = "command",
+) -> tuple[str | None, str | None]:
+    """
+    Parse simulator and artifact from CLI args, supporting colon notation.
+
+    Supports:
+        -s simulator                    # Simulator only
+        -s simulator -a <artifact-uuid> # Explicit artifact
+        -s simulator:<artifact-uuid>    # Colon notation
+
+    Args:
+        simulator: The -s/--simulator arg value
+        artifact: The -a/--artifact arg value
+        require_artifact: If True, artifact is required
+        command_name: Name of command for error messages
+
+    Returns:
+        (simulator_name, artifact_id) tuple
+    """
+    simulator_name = None
+    artifact_id = artifact or ""
+
+    if simulator:
+        # Check for colon notation: sim:artifact
+        if ":" in simulator:
+            sim_part, colon_part = simulator.split(":", 1)
+            simulator_name = sim_part
+            if UUID_PATTERN.match(colon_part):
+                artifact_id = colon_part
+            else:
+                console.print(f"[red]❌ Invalid artifact UUID after colon: '{colon_part}'[/red]")
+                console.print()
+                console.print("[yellow]Usage:[/yellow]")
+                console.print(f"  plato pm {command_name} -s <simulator>                      # Simulator only")
+                console.print(f"  plato pm {command_name} -s <simulator> -a <artifact-uuid>   # With artifact")
+                console.print(f"  plato pm {command_name} -s <simulator>:<artifact-uuid>      # Colon notation")
+                raise typer.Exit(1)
+        else:
+            simulator_name = simulator
+
+    if not simulator_name:
+        console.print("[red]❌ Simulator name is required[/red]")
+        console.print()
+        console.print("[yellow]Usage:[/yellow]")
+        console.print(f"  plato pm {command_name} -s <simulator>                      # Simulator only")
+        console.print(f"  plato pm {command_name} -s <simulator> -a <artifact-uuid>   # With artifact")
+        console.print(f"  plato pm {command_name} -s <simulator>:<artifact-uuid>      # Colon notation")
+        raise typer.Exit(1)
+
+    if require_artifact and not artifact_id:
+        console.print("[red]❌ Artifact ID is required[/red]")
+        console.print()
+        console.print("[yellow]Usage:[/yellow]")
+        console.print(f"  plato pm {command_name} -s <simulator> -a <artifact-uuid>   # With artifact flag")
+        console.print(f"  plato pm {command_name} -s <simulator>:<artifact-uuid>      # Colon notation")
+        raise typer.Exit(1)
+
+    return simulator_name, artifact_id or None
+
+
 def _get_base_url() -> str:
     """Get base URL with /api suffix stripped."""
     base_url = os.getenv("PLATO_BASE_URL", "https://plato.so")
@@ -95,6 +172,21 @@ def _list_pending_reviews(review_type: str):
                 x_api_key=api_key,
             )
 
+            # Fetch organization members to map user IDs to usernames
+            user_id_to_name: dict[int, str] = {}
+            try:
+                members = await get_organization_members.asyncio(
+                    client=client,
+                    x_api_key=api_key,
+                )
+                for member in members:
+                    user_id = member.get("id")
+                    username = member.get("username") or member.get("email", "")
+                    if user_id is not None:
+                        user_id_to_name[user_id] = username
+            except Exception:
+                pass  # Continue without usernames if fetch fails
+
             # Filter by target status
             pending_review = []
             for sim in simulators:
@@ -110,6 +202,7 @@ def _list_pending_reviews(review_type: str):
             # Build table
             table = Table(title=f"Simulators Pending {review_type.title()} Review")
             table.add_column("Name", style="cyan", no_wrap=True)
+            table.add_column("Assignees", style="magenta", no_wrap=True)
             table.add_column("Notes", style="white", max_width=40)
             artifact_col_name = "base_artifact_id" if review_type == "base" else "data_artifact_id"
             table.add_column(artifact_col_name, style="green", no_wrap=True)
@@ -128,7 +221,16 @@ def _list_pending_reviews(review_type: str):
                 artifact_id = config.get(artifact_key, "") if isinstance(config, dict) else ""
                 artifact_id = artifact_id or "-"
 
-                table.add_row(name, notes, artifact_id)
+                # Get assignees based on review type (env_assignees for base, data_assignees for data)
+                assignee_key = "env_assignees" if review_type == "base" else "data_assignees"
+                assignee_ids = config.get(assignee_key, []) if isinstance(config, dict) else []
+                assignee_names = []
+                if assignee_ids:
+                    for uid in assignee_ids:
+                        assignee_names.append(user_id_to_name.get(uid, str(uid)))
+                assignees_str = ", ".join(assignee_names) if assignee_names else "-"
+
+                table.add_row(name, assignees_str, notes, artifact_id)
 
             console.print(table)
             console.print(f"\n[cyan]Total: {len(pending_review)} simulator(s) pending {review_type} review[/cyan]")
@@ -141,10 +243,19 @@ def list_base():
     """
     List simulators pending base/environment review.
 
-    Shows all simulators with status: env_review_requested
+    Shows simulators waiting for environment review (status: env_review_requested).
+    Use this to see what needs reviewing before running 'plato pm review base'.
+
+    USAGE:
 
-    Example:
         plato pm list base
+
+    OUTPUT COLUMNS:
+
+        - Name: Simulator name
+        - Assignees: Who's assigned to review
+        - Notes: Any notes about the simulator
+        - base_artifact_id: The artifact to review
     """
     _list_pending_reviews("base")
 
@@ -154,10 +265,19 @@ def list_data():
     """
     List simulators pending data review.
 
-    Shows all simulators with status: data_review_requested
+    Shows simulators waiting for data review (status: data_review_requested).
+    Use this to see what needs reviewing before running 'plato pm review data'.
+
+    USAGE:
 
-    Example:
         plato pm list data
+
+    OUTPUT COLUMNS:
+
+        - Name: Simulator name
+        - Assignees: Who's assigned to review
+        - Notes: Any notes about the simulator
+        - data_artifact_id: The artifact to review
     """
     _list_pending_reviews("data")
 
@@ -169,40 +289,50 @@ def list_data():
 
 @review_app.command(name="base")
 def review_base(
-    simulator: str = typer.Option(None, "--simulator", "-s", help="Simulator name"),
-    artifact: str = typer.Option(None, "--artifact", "-a", help="Artifact ID (uses base_artifact_id if not provided)"),
+    simulator: str = typer.Option(
+        None,
+        "--simulator",
+        "-s",
+        help="Simulator name. Supports colon notation: -s sim:<artifact-uuid>",
+    ),
+    artifact: str = typer.Option(
+        None,
+        "--artifact",
+        "-a",
+        help="Artifact UUID to review. If not provided, uses server's base_artifact_id.",
+    ),
+    skip_review: bool = typer.Option(
+        False,
+        "--skip-review",
+        help="Run login flow and check state, but skip interactive review. For automated verification.",
+    ),
 ):
     """
-    Review base/environment artifact session (reviewer testing the environment).
+    Review base/environment artifact for a simulator.
 
-    Opens simulator with artifact in browser for manual testing.
-    At the end, prompts to pass (→ env_approved) or reject (→ env_in_progress).
+    Opens the simulator in a browser for manual testing. After testing,
+    you can pass (→ env_approved) or reject (→ env_in_progress).
 
-    Requires simulator status: env_review_requested
+    SPECIFYING SIMULATOR AND ARTIFACT:
 
-    Example:
-        plato pm review base --simulator espocrm
-        plato pm review base -s espocrm -a abc123
-    """
-    api_key = require_api_key()
+        -s <simulator>                      Use server's base_artifact_id
+        -s <simulator> -a <artifact-uuid>   Explicit artifact
+        -s <simulator>:<artifact-uuid>      Colon notation (same as above)
 
-    # Track if simulator was provided via CLI arg
-    simulator_provided_via_arg = simulator is not None
+    EXAMPLES:
 
-    # Use arg or prompt for simulator name
-    simulator_name = simulator
-    if not simulator_name:
-        simulator_name = typer.prompt("Enter simulator name").strip()
-    if not simulator_name:
-        console.print("[red]❌ Simulator name is required[/red]")
-        raise typer.Exit(1)
+        plato pm review base -s espocrm
+        plato pm review base -s espocrm -a e9c25ca5-1234-5678-9abc-def012345678
+        plato pm review base -s espocrm:e9c25ca5-1234-5678-9abc-def012345678
 
-    # Artifact ID: use arg, or prompt only if simulator was NOT provided via arg
-    artifact_id_input = artifact or ""
-    if not artifact_id_input and not simulator_provided_via_arg:
-        artifact_id_input = typer.prompt(
-            "Enter artifact ID (or press Enter to use base_artifact_id)", default=""
-        ).strip()
+    Requires simulator status: env_review_requested
+    """
+    api_key = require_api_key()
+
+    # Parse simulator and artifact from args (artifact not required - falls back to server config)
+    simulator_name, artifact_id_input = parse_simulator_artifact(
+        simulator, artifact, require_artifact=False, command_name="review base"
+    )
 
     async def _review_base():
         base_url = _get_base_url()
@@ -215,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,
@@ -227,10 +360,16 @@ def review_base(
 
             console.print(f"[cyan]Current status:[/cyan] {current_status}")
 
-            # Use provided artifact ID or fall back to base_artifact_id from config
-            artifact_id = artifact_id_input if artifact_id_input else current_config.get("base_artifact_id")
+            # Use provided artifact ID or fall back to base_artifact_id from server config
+            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 and simulator has no base_artifact_id set[/red]")
+                console.print("[red]❌ No artifact ID provided.[/red]")
+                console.print(
+                    "[yellow]This simulator hasn't been submitted yet, so there's no base artifact on record.[/yellow]"
+                )
+                console.print(
+                    "[yellow]Specify the artifact ID from your snapshot using: plato pm review base --artifact <artifact_id>[/yellow]"
+                )
                 raise typer.Exit(1)
 
             console.print(f"[cyan]Using artifact:[/cyan] {artifact_id}")
@@ -259,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)
 
@@ -272,6 +413,60 @@ def review_base(
                     if public_url:
                         await page.goto(public_url)
 
+                # 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(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("\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
+
                 console.print("\n" + "=" * 60)
                 console.print("[bold green]Environment Review Session Active[/bold green]")
                 console.print("=" * 60)
@@ -281,7 +476,7 @@ def review_base(
                 console.print("=" * 60)
 
                 # Show recent env review if available
-                reviews = current_config.get("reviews", [])
+                reviews = current_config.get("reviews") or []
                 env_reviews = [r for r in reviews if r.get("review_type") == "env"]
                 if env_reviews:
                     env_reviews.sort(key=lambda r: r.get("timestamp_iso", ""), reverse=True)
@@ -320,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:
@@ -331,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]")
@@ -407,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(
@@ -461,57 +664,89 @@ def review_base(
 @review_app.command(name="data")
 def review_data(
     simulator: str = typer.Option(
-        None, "--simulator", "-s", help="Simulator name (navigates to {simulator}.web.plato.so)"
+        None,
+        "--simulator",
+        "-s",
+        help="Simulator name. Supports colon notation: -s sim:<artifact-uuid>",
+    ),
+    artifact: str = typer.Option(
+        None,
+        "--artifact",
+        "-a",
+        help="Artifact UUID to review. If not provided, uses server's data_artifact_id.",
     ),
 ):
     """
     Launch browser with EnvGen Recorder extension for data review.
 
-    Opens Chrome with the extension installed. If --simulator is provided,
-    navigates to {simulator}.web.plato.so and auto-loads the sim in the extension.
-    Otherwise navigates to sims.plato.so.
+    Opens Chrome with the EnvGen Recorder extension installed for reviewing
+    data artifacts. Close the browser when done.
+
+    SPECIFYING SIMULATOR AND ARTIFACT:
 
-    When done, simply close the browser to exit.
+        -s <simulator>                      Use server's data_artifact_id
+        -s <simulator> -a <artifact-uuid>   Explicit artifact
+        -s <simulator>:<artifact-uuid>      Colon notation (same as above)
+
+    EXAMPLES:
 
-    Example:
-        plato pm review data
         plato pm review data -s fathom
+        plato pm review data -s fathom -a e9c25ca5-1234-5678-9abc-def012345678
+        plato pm review data -s fathom:e9c25ca5-1234-5678-9abc-def012345678
+
+    Requires simulator status: data_review_requested
     """
     api_key = require_api_key()
 
+    # Parse simulator and artifact from args (artifact not required - falls back to server config)
+    simulator_name, artifact_id = parse_simulator_artifact(
+        simulator, artifact, require_artifact=False, command_name="review data"
+    )
+
     # Determine target URL based on simulator
-    if simulator:
-        target_url = f"https://{simulator}.web.plato.so"
-        console.print(f"[cyan]Simulator:[/cyan] {simulator}")
-    else:
-        target_url = "https://sims.plato.so"
+    target_url = f"https://{simulator_name}.web.plato.so"
+    console.print(f"[cyan]Simulator:[/cyan] {simulator_name}")
 
-    # If simulator provided, fetch and show recent data reviews
+    # Fetch simulator config and get artifact ID if not provided
     recent_review = None
-    if simulator:
 
-        async def _fetch_recent_review():
-            base_url = _get_base_url()
-            async with httpx.AsyncClient(base_url=base_url, timeout=60.0) as client:
-                try:
-                    sim = await get_simulator_by_name.asyncio(
-                        client=client,
-                        name=simulator,
-                        x_api_key=api_key,
-                    )
-                    config = sim.config or {}
-                    reviews = config.get("reviews", [])
-                    # Find most recent data review
-                    data_reviews = [r for r in reviews if r.get("review_type") == "data"]
-                    if data_reviews:
-                        # Sort by timestamp (most recent first)
-                        data_reviews.sort(key=lambda r: r.get("timestamp_iso", ""), reverse=True)
-                        return data_reviews[0]
-                except Exception as e:
-                    console.print(f"[yellow]⚠️  Could not fetch recent reviews: {e}[/yellow]")
-                return None
+    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:
+                sim = await get_simulator_by_name.asyncio(
+                    client=client,
+                    name=simulator_name,
+                    x_api_key=api_key,
+                )
+                config = sim.config or {}
+
+                # If no artifact provided, try to get data_artifact_id from server
+                if not artifact_id:
+                    artifact_id = config.get("data_artifact_id")
+                    if artifact_id:
+                        console.print(f"[cyan]Using data_artifact_id from server:[/cyan] {artifact_id}")
+                    else:
+                        console.print("[yellow]No artifact specified and no data_artifact_id on server[/yellow]")
+
+                # Find most recent data review
+                reviews = config.get("reviews") or []
+                data_reviews = [r for r in reviews if r.get("review_type") == "data"]
+                if data_reviews:
+                    data_reviews.sort(key=lambda r: r.get("timestamp_iso", ""), reverse=True)
+                    return data_reviews[0]
+            except Exception as e:
+                console.print(f"[yellow]⚠️  Could not fetch simulator info: {e}[/yellow]")
+            return None
 
-        recent_review = handle_async(_fetch_recent_review())
+    recent_review = handle_async(_fetch_artifact_info())
+
+    if artifact_id:
+        console.print(f"[cyan]Artifact:[/cyan] {artifact_id}")
 
     # Find Chrome extension source
     package_dir = Path(__file__).resolve().parent.parent  # v1/
@@ -554,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(
@@ -690,12 +927,24 @@ def submit_base():
     """
     Submit base/environment artifact for review after snapshot.
 
-    Worker submits base artifact for review after creating a snapshot.
-    Requires status: env_in_progress
-    Transitions to: env_review_requested
+    Reads simulator name and artifact ID from .sandbox.yaml (created by
+    plato sandbox start). Run this from the simulator directory after
+    creating a snapshot.
+
+    Transitions simulator from env_in_progress → env_review_requested.
+
+    USAGE:
+
+        plato pm submit base    # No args needed - reads from .sandbox.yaml
 
-    Example:
-        plato pm submit base
+    PREREQUISITES:
+
+        1. plato sandbox start --from-config
+        2. plato sandbox start-services
+        3. plato sandbox snapshot
+        4. plato pm submit base   ← you are here
+
+    Requires simulator status: env_in_progress
     """
     api_key = require_api_key()
 
@@ -706,10 +955,43 @@ def submit_base():
     )
     plato_config_path = require_sandbox_field(sandbox_data, "plato_config_path")
 
-    # Read plato-config.yml to get simulator name
+    # Read plato-config.yml to get simulator name and metadata
     plato_config = read_plato_config(plato_config_path)
     simulator_name = require_plato_config_field(plato_config, "service")
 
+    # Extract metadata from plato-config.yml
+    datasets = plato_config.get("datasets", {})
+    base_dataset = datasets.get("base", {})
+    metadata = base_dataset.get("metadata", {})
+
+    # Get metadata fields
+    config_description = metadata.get("description")
+    config_license = metadata.get("license")
+    config_source_code_url = metadata.get("source_code_url")
+    config_start_url = metadata.get("start_url")
+    config_favicon_url = metadata.get("favicon_url")  # Explicit favicon URL
+
+    # Get authentication from variables
+    variables = metadata.get("variables", [])
+    username = None
+    password = None
+    for var in variables:
+        if isinstance(var, dict):
+            var_name = var.get("name", "").lower()
+            var_value = var.get("value")
+            if var_name in ("username", "user", "email", "admin_email", "adminmail"):
+                username = var_value
+            elif var_name in ("password", "pass", "admin_password", "adminpass"):
+                password = var_value
+
+    # Use explicit favicon_url from config, or warn if missing
+    favicon_url = config_favicon_url
+    if not favicon_url:
+        console.print("[yellow]⚠️  No favicon_url in plato-config.yml metadata - favicon will not be set[/yellow]")
+        console.print(
+            "[yellow]   Add 'favicon_url: https://www.google.com/s2/favicons?domain=APPNAME.com&sz=32' to metadata[/yellow]"
+        )
+
     async def _submit_base():
         base_url = _get_base_url()
 
@@ -733,6 +1015,52 @@ def submit_base():
             console.print(f"[cyan]Current Status:[/cyan] {current_status}")
             console.print()
 
+            # Sync metadata from plato-config.yml to server
+            console.print("[cyan]Syncing metadata to server...[/cyan]")
+
+            # Build update request with metadata from plato-config.yml
+            update_fields: dict = {}
+
+            if config_description:
+                update_fields["description"] = config_description
+                console.print(f"  [dim]description:[/dim] {config_description[:50]}...")
+
+            if favicon_url:
+                update_fields["img_url"] = favicon_url
+                console.print(f"  [dim]img_url:[/dim] {favicon_url}")
+
+            if config_license:
+                update_fields["license"] = config_license
+                console.print(f"  [dim]license:[/dim] {config_license}")
+
+            if config_source_code_url:
+                update_fields["source_code_url"] = config_source_code_url
+                console.print(f"  [dim]source_code_url:[/dim] {config_source_code_url}")
+
+            if config_start_url:
+                update_fields["start_url"] = config_start_url
+                console.print(f"  [dim]start_url:[/dim] {config_start_url}")
+
+            if username and password:
+                update_fields["authentication"] = Authentication(user=username, password=password)
+                console.print(f"  [dim]authentication:[/dim] {username} / {'*' * len(password)}")
+
+            # Always include base_artifact_id
+            update_fields["base_artifact_id"] = artifact_id
+
+            try:
+                await update_simulator.asyncio(
+                    client=client,
+                    simulator_id=simulator_id,
+                    body=AppApiV1SimulatorRoutesUpdateSimulatorRequest(**update_fields),
+                    x_api_key=api_key,
+                )
+                console.print("[green]✅ Metadata synced to server[/green]")
+            except Exception as e:
+                console.print(f"[yellow]⚠️  Could not sync metadata: {e}[/yellow]")
+
+            console.print()
+
             # Update simulator status
             await update_simulator_status.asyncio(
                 client=client,
@@ -741,21 +1069,6 @@ def submit_base():
                 x_api_key=api_key,
             )
 
-            # Set base_artifact_id via tag update
-            try:
-                await update_tag.asyncio(
-                    client=client,
-                    body=UpdateTagRequest(
-                        simulator_name=simulator_name,
-                        artifact_id=artifact_id,
-                        tag_name="base-pending-review",
-                        dataset="base",
-                    ),
-                    x_api_key=api_key,
-                )
-            except Exception as e:
-                console.print(f"[yellow]⚠️  Could not set artifact tag: {e}[/yellow]")
-
             console.print("[green]✅ Environment review requested successfully![/green]")
             console.print(f"[cyan]Status:[/cyan] {current_status} → env_review_requested")
             console.print(f"[cyan]Base Artifact:[/cyan] {artifact_id}")
@@ -765,39 +1078,48 @@ def submit_base():
 
 @submit_app.command(name="data")
 def submit_data(
-    simulator: str = typer.Option(None, "--simulator", "-s", help="Simulator name"),
-    artifact: str = typer.Option(None, "--artifact", "-a", help="Artifact ID (required)"),
+    simulator: str = typer.Option(
+        None,
+        "--simulator",
+        "-s",
+        help="Simulator name. Supports colon notation: -s sim:<artifact-uuid>",
+    ),
+    artifact: str = typer.Option(
+        None,
+        "--artifact",
+        "-a",
+        help="Artifact UUID to submit for data review (required).",
+    ),
 ):
     """
     Submit data artifact for review after data generation.
 
-    Worker manually specifies artifact ID for data review.
-    Requires status: data_in_progress
-    Transitions to: data_review_requested
+    Transitions simulator from data_in_progress → data_review_requested.
+
+    SPECIFYING SIMULATOR AND ARTIFACT (both required):
+
+        -s <simulator> -a <artifact-uuid>   Explicit artifact
+        -s <simulator>:<artifact-uuid>      Colon notation (same as above)
+
+    EXAMPLES:
+
+        plato pm submit data -s espocrm -a e9c25ca5-1234-5678-9abc-def012345678
+        plato pm submit data -s espocrm:e9c25ca5-1234-5678-9abc-def012345678
 
-    Example:
-        plato pm submit data --simulator espocrm --artifact abc123
-        plato pm submit data -s espocrm -a abc123
+    Requires simulator status: data_in_progress
     """
     api_key = require_api_key()
 
-    # Use arg or prompt for simulator name
-    simulator_name = simulator
-    if not simulator_name:
-        simulator_name = typer.prompt("Enter simulator name").strip()
-    if not simulator_name:
-        console.print("[red]❌ Simulator name is required[/red]")
-        raise typer.Exit(1)
-
-    # Artifact ID is required
-    artifact_id = artifact
-    if not artifact_id:
-        artifact_id = typer.prompt("Enter artifact ID").strip()
-    if not artifact_id:
-        console.print("[red]❌ Artifact ID is required[/red]")
-        raise typer.Exit(1)
+    # Parse simulator and artifact from args (artifact IS required for data submit)
+    simulator_name, artifact_id = parse_simulator_artifact(
+        simulator, artifact, require_artifact=True, command_name="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:
@@ -828,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,