veris-cli 2.23.0__tar.gz → 2.25.0__tar.gz

{veris_cli-2.23.0 → veris_cli-2.25.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: veris-cli
-Version: 2.23.0
+Version: 2.25.0
 Summary: CLI to connect local agents to the Veris backend
 Project-URL: Homepage, https://github.com/veris-ai/veris-cli
 Project-URL: Bug Tracker, https://github.com/veris-ai/veris-cli/issues

{veris_cli-2.23.0 → veris_cli-2.25.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "veris-cli"
-version = "2.23.0"
+version = "2.25.0"
 description = "CLI to connect local agents to the Veris backend"
 readme = "README.md"
 requires-python = ">=3.11"

{veris_cli-2.23.0 → veris_cli-2.25.0}/src/veris_cli/api.py

@@ -212,12 +212,13 @@ class VerisAPI:
         scenario_set_id: str,
         environment_id: str,
         config: Optional[dict] = None,
+        auto_evaluate: bool = False,
     ) -> dict[str, Any]:
         """Create a new run."""
         payload: dict[str, Any] = {
             "scenario_set_id": scenario_set_id,
             "environment_id": environment_id,
-            "auto_evaluate": False,
+            "auto_evaluate": auto_evaluate,
         }
         if config:
             payload["config"] = config
@@ -431,6 +432,32 @@ class VerisAPI:
             _raise_for_status(response)
             return response.content
 
+    # Managed Setup
+    def create_submit(self, environment_id: str) -> dict[str, Any]:
+        """Get a signed upload URL for submitting agent source code."""
+        with httpx.Client(
+            base_url=self.base_url, headers=self._headers(), timeout=self.DEFAULT_TIMEOUT
+        ) as client:
+            response = client.post(f"/v1/environments/{environment_id}/submit")
+            _raise_for_status(response)
+            return response.json()
+
+    def notify_submit_uploaded(self, environment_id: str) -> dict[str, Any]:
+        """Confirm that the submit tarball has been uploaded."""
+        with httpx.Client(base_url=self.base_url, headers=self._headers(), timeout=30) as client:
+            response = client.post(f"/v1/environments/{environment_id}/submit/uploaded")
+            _raise_for_status(response)
+            return response.json()
+
+    def get_managed_config(self, environment_id: str) -> dict[str, Any]:
+        """Get managed config files (signed download URLs) for an environment."""
+        with httpx.Client(
+            base_url=self.base_url, headers=self._headers(), timeout=self.DEFAULT_TIMEOUT
+        ) as client:
+            response = client.get(f"/v1/environments/{environment_id}/managed-config")
+            _raise_for_status(response)
+            return response.json()
+
     # Sandbox metadata
     def list_services(self) -> dict[str, Any]:
         """List available sandbox mock services."""

{veris_cli-2.23.0 → veris_cli-2.25.0}/src/veris_cli/build_context.py

@@ -31,6 +31,7 @@ def create_build_context(
     project_root: Path,
     output_path: Path | None = None,
     dockerfile: Path | str | None = None,
+    require_dockerfile: bool = True,
 ) -> tuple[Path, int]:
     """Create a tar.gz build context from the project root.
 
@@ -43,6 +44,8 @@ def create_build_context(
         output_path: Where to write the tarball. If None, uses a tempfile.
         dockerfile: Dockerfile path (absolute or relative to project_root). Defaults
             to `.veris/Dockerfile.sandbox` when None.
+        require_dockerfile: If False, skip Dockerfile validation and inclusion.
+            Used by ``env submit`` where no Dockerfile exists yet.
 
     Returns:
         Tuple of (tarball_path, size_bytes).
@@ -57,18 +60,20 @@ def create_build_context(
         os.close(fd)
         output_path = Path(tmp)
 
-    if dockerfile is None:
-        dockerfile_path = project_root / ".veris" / "Dockerfile.sandbox"
-        dockerfile_label = ".veris/Dockerfile.sandbox"
-    else:
-        df = Path(dockerfile)
-        dockerfile_path = df if df.is_absolute() else project_root / df
-        dockerfile_label = str(dockerfile)
-    if not dockerfile_path.exists():
-        raise ValueError(f"{dockerfile_label} not found")
+    dockerfile_rel: str | None = None
+    if require_dockerfile:
+        if dockerfile is None:
+            dockerfile_path = project_root / ".veris" / "Dockerfile.sandbox"
+            dockerfile_label = ".veris/Dockerfile.sandbox"
+        else:
+            df = Path(dockerfile)
+            dockerfile_path = df if df.is_absolute() else project_root / df
+            dockerfile_label = str(dockerfile)
+        if not dockerfile_path.exists():
+            raise ValueError(f"{dockerfile_label} not found")
+        dockerfile_rel = str(dockerfile_path.relative_to(project_root))
 
     file_count = 0
-    dockerfile_rel = str(dockerfile_path.relative_to(project_root))
     dockerfile_added = False
 
     with tarfile.open(output_path, "w:gz") as tar:
@@ -99,11 +104,11 @@ def create_build_context(
                 full_path = Path(root) / f
                 tar.add(str(full_path), arcname=rel_path)
                 file_count += 1
-                if rel_path == dockerfile_rel:
+                if dockerfile_rel and rel_path == dockerfile_rel:
                     dockerfile_added = True
 
         # If the Dockerfile wasn't added (e.g. its dir was ignored), add it explicitly
-        if not dockerfile_added:
+        if require_dockerfile and not dockerfile_added and dockerfile_rel:
             tar.add(str(dockerfile_path), arcname=dockerfile_rel)
             file_count += 1
 

{veris_cli-2.23.0 → veris_cli-2.25.0}/src/veris_cli/commands/env.py

@@ -2,6 +2,7 @@
 
 import sys
 import time
+from datetime import UTC, datetime
 from pathlib import Path
 
 import click
@@ -364,8 +365,9 @@ def env_create(ctx, name: str | None, agent_name: str | None):
                 if unconfigured:
                     import questionary
 
+                    _NEW_TARGET = "__new__"
                     choices = [questionary.Choice(title=t, value=t) for t in unconfigured] + [
-                        questionary.Choice(title="Create a new target", value=None),
+                        questionary.Choice(title="Create a new target", value=_NEW_TARGET),
                     ]
                     selected = questionary.select(
                         "Existing targets found in veris.yaml. Set up environment for:",
@@ -373,7 +375,7 @@ def env_create(ctx, name: str | None, agent_name: str | None):
                     ).ask()
                     if selected is None:
                         return
-                    if selected:
+                    if selected and selected != _NEW_TARGET:
                         name = selected
                         # Pull the agent name from the target block
                         t_obj = parsed.get_target(selected)
@@ -444,9 +446,12 @@ def env_create(ctx, name: str | None, agent_name: str | None):
         output.print_success(f"Environment created: {env_id}")
         output.print_info(f"Environment ID saved to .veris/config.yaml under target '{env_name}'")
         output.print_info("\nNext steps:")
-        output.print_info("  1. Edit .veris/Dockerfile.sandbox to configure your agent")
-        output.print_info("  2. Review .veris/veris.yaml settings")
-        output.print_info("  3. Run 'veris env push' to build and push your agent")
+        output.print_info("  Option A — Self-serve:")
+        output.print_info("    1. Edit .veris/Dockerfile.sandbox and .veris/veris.yaml")
+        output.print_info("    2. Run 'veris env push' to build and push your agent")
+        output.print_info("  Option B — Let Veris set it up:")
+        output.print_info("    1. Run 'veris env submit' to upload your code")
+        output.print_info("    2. We'll email you when your environment is ready")
 
     except ValueError as e:
         output.print_error(str(e))
@@ -645,6 +650,83 @@ def _resolve_or_create_cross_profile(
     return None
 
 
+@env.command(name="submit")
+@click.option("--env-id", default=None, help="Environment ID (overrides config)")
+@target_option
+@click.pass_context
+def env_submit(ctx, env_id: str | None, target: str | None):
+    """Submit your repo for managed environment setup.
+
+    Packages your project into a tarball and uploads it to Veris. The team
+    will generate your Dockerfile.sandbox and veris.yaml. You'll receive an
+    email when the setup is complete.
+
+    \b
+    After receiving the email:
+      veris env config pull       # Pull generated config files
+      veris env push      # Build and push your agent
+    """
+    profile = get_profile(ctx)
+    resolved_target = resolve_target(target, profile)
+
+    # Prompt for target selection if multiple targets and none resolved
+    if not resolved_target and not env_id and sys.stdin.isatty():
+        veris_yaml_path = Path.cwd() / ".veris" / "veris.yaml"
+        parsed = _try_load_veris_yaml(veris_yaml_path)
+        if parsed and len(parsed.target_names) > 1:
+            import questionary
+
+            resolved_target = questionary.select(
+                "Multiple targets found. Submit which one?",
+                choices=parsed.target_names,
+            ).ask()
+            if not resolved_target:
+                return
+
+    env_id = resolve_env_id(profile, env_id, resolved_target)
+
+    tarball_path = None
+    try:
+        from veris_cli.build_context import create_build_context
+
+        output.print_info("Packaging project...")
+        tarball_path, size = create_build_context(Path.cwd(), require_dockerfile=False)
+        size_mb = size / 1024 / 1024
+        output.print_success(f"Package size: {size_mb:.1f} MB")
+
+        api = VerisAPI(profile=profile)
+        submit_result = api.create_submit(env_id)
+        upload_url = submit_result["upload_url"]
+
+        output.print_info("Uploading...")
+        with open(tarball_path, "rb") as f:
+            upload_resp = httpx.put(
+                upload_url,
+                content=f,
+                headers={"Content-Type": "application/gzip"},
+                timeout=300,
+            )
+        if upload_resp.status_code not in (200, 201):
+            output.print_error(f"Upload failed: {upload_resp.status_code}")
+            sys.exit(1)
+        output.print_success("Upload complete")
+
+        api.notify_submit_uploaded(env_id)
+        output.print_success("Submitted for managed setup!")
+        output.print_info("You'll receive an email when your environment is ready.")
+        output.print_info("Then run 'veris env push' to build and deploy.")
+
+    except ValueError as e:
+        output.print_error(str(e))
+        sys.exit(1)
+    except Exception as e:
+        output.print_error(f"Submit failed: {e}")
+        sys.exit(1)
+    finally:
+        if tarball_path:
+            tarball_path.unlink(missing_ok=True)
+
+
 @env.command(name="push")
 @click.option("--tag", default="latest", help="Image tag (default: latest)")
 @click.option("--env-id", default=None, help="Environment ID (overrides config)")
@@ -674,6 +756,16 @@ def env_push(ctx, tag: str, env_id: str | None, target: str | None):
     parsed = _load_veris_yaml(veris_yaml_path)
     resolved_target = resolve_target(target, profile, parsed_veris_yaml=parsed)
 
+    if not resolved_target and not env_id and sys.stdin.isatty() and len(parsed.target_names) > 1:
+        import questionary
+
+        resolved_target = questionary.select(
+            "Multiple targets found. Push which one?",
+            choices=parsed.target_names,
+        ).ask()
+        if not resolved_target:
+            return
+
     try:
         target_obj = parsed.get_target(resolved_target)
     except KeyError as e:
@@ -682,9 +774,6 @@ def env_push(ctx, tag: str, env_id: str | None, target: str | None):
 
     dockerfile_rel = target_obj.resolved_dockerfile()
     dockerfile_path = Path.cwd() / dockerfile_rel
-    if not dockerfile_path.exists():
-        output.print_error(f"{dockerfile_rel} not found. Run 'veris env create' first.")
-        sys.exit(1)
 
     if not env_id and not target:
         env_id = _migrate_legacy_config(profile, resolved_target, parsed)
@@ -693,9 +782,59 @@ def env_push(ctx, tag: str, env_id: str | None, target: str | None):
     if not env_id:
         env_id = resolve_env_id(profile, env_id, resolved_target)
 
+    api = VerisAPI(profile=profile)
+
+    if not dockerfile_path.exists():
+        output.print_error(
+            f"{dockerfile_rel} not found. Run 'veris env create' or 'veris env config pull' first."
+        )
+        sys.exit(1)
+
+    # Config sync guard: check if remote config was updated since last sync.
+    # Prevents accidentally overwriting team-generated config with local scaffold.
+    try:
+        env_info = api.get_environment(env_id)
+    except Exception:
+        env_info = {}
+
+    remote_config_at = env_info.get("config_updated_at")
+    pc = ProjectConfig(profile=profile, target=resolved_target)
+    local_synced_at = pc.get_config_synced_at()
+
+    if remote_config_at and (not local_synced_at or remote_config_at > local_synced_at):
+        if sys.stdin.isatty():
+            import questionary
+
+            action = questionary.select(
+                "Remote config was updated since your last sync.",
+                choices=[
+                    questionary.Choice(title="Pull remote config (overwrites local)", value="pull"),
+                    questionary.Choice(title="Push local config (overwrites remote)", value="push"),
+                    questionary.Choice(title="Cancel", value="cancel"),
+                ],
+            ).ask()
+            if action == "cancel" or action is None:
+                return
+            if action == "pull":
+                ctx.invoke(config_pull, env_id=env_id, target=resolved_target)
+                # Reload target config after pull (resolved_target stays the same)
+                parsed = _load_veris_yaml(veris_yaml_path)
+                target_obj = parsed.get_target(resolved_target)
+                dockerfile_rel = target_obj.resolved_dockerfile()
+                dockerfile_path = Path.cwd() / dockerfile_rel
+        else:
+            output.print_error(
+                "Remote config was updated since your last sync. Run 'veris env config pull' first."
+            )
+            sys.exit(1)
+
     try:
-        api = VerisAPI(profile=profile)
         api.upload_environment_config(env_id, target_obj.to_upload_dict())
+        # Re-fetch to get the server-assigned config_updated_at
+        updated_env = api.get_environment(env_id)
+        pc.set_config_synced_at(
+            updated_env.get("config_updated_at") or datetime.now(UTC).isoformat()
+        )
         output.print_success("Config validated and uploaded")
     except Exception as e:
         detail = getattr(e, "detail", str(e))
@@ -704,7 +843,6 @@ def env_push(ctx, tag: str, env_id: str | None, target: str | None):
 
     # On-prem clusters route through the customer's external registry instead of Cloud Build.
     try:
-        env_info = api.get_environment(env_id)
         if env_info.get("image_registry_url"):
             tag_result = api.create_image_tag(env_id, tag)
             if tag_result.get("pull_credentials"):
@@ -871,9 +1009,48 @@ def config_push(ctx, file_path: str | None, env_id: str, target: str | None):
         output.print_error(str(e))
         sys.exit(1)
 
+    api = VerisAPI(profile=profile)
+    pc = ProjectConfig(profile=profile, target=resolved_target)
+
+    # Config sync guard
+    try:
+        env_info = api.get_environment(env_id)
+    except Exception:
+        env_info = {}
+
+    remote_config_at = env_info.get("config_updated_at")
+    local_synced_at = pc.get_config_synced_at()
+
+    if remote_config_at and (not local_synced_at or remote_config_at > local_synced_at):
+        if sys.stdin.isatty():
+            import questionary
+
+            action = questionary.select(
+                "Remote config was updated since your last sync.",
+                choices=[
+                    questionary.Choice(title="Pull remote config (overwrites local)", value="pull"),
+                    questionary.Choice(title="Push local config (overwrites remote)", value="push"),
+                    questionary.Choice(title="Cancel", value="cancel"),
+                ],
+            ).ask()
+            if action == "cancel" or action is None:
+                return
+            if action == "pull":
+                # Delegate to config pull logic
+                output.print_info("Pulling remote config...")
+                ctx.invoke(config_pull, env_id=env_id, target=resolved_target)
+                return
+        else:
+            output.print_error(
+                "Remote config was updated since your last sync. Run 'veris env config pull' first."
+            )
+            sys.exit(1)
+
     try:
-        api = VerisAPI(profile=profile)
         api.upload_environment_config(env_id, target_obj.to_upload_dict())
+        env_info = api.get_environment(env_id)
+        config_ts = env_info.get("config_updated_at") or datetime.now(UTC).isoformat()
+        pc.set_config_synced_at(config_ts)
         output.print_success(f"Config uploaded for environment {env_id}")
     except Exception as e:
         detail = getattr(e, "detail", str(e))
@@ -881,6 +1058,78 @@ def config_push(ctx, file_path: str | None, env_id: str, target: str | None):
         sys.exit(1)
 
 
+@config.command(name="pull")
+@click.option("--env-id", default=None, help="Environment ID (uses project config if omitted)")
+@target_option
+@click.pass_context
+def config_pull(ctx, env_id: str | None, target: str | None):
+    """Pull config files from Veris to local .veris/ directory.
+
+    Downloads the Dockerfile.sandbox and veris.yaml from the backend.
+    Use after 'veris env submit' (managed setup) or to sync with
+    remote config changes.
+
+    Example: veris env config pull
+    """
+    profile = get_profile(ctx)
+    resolved_target = resolve_target(target, profile)
+    env_id = resolve_env_id(profile, env_id, resolved_target)
+
+    try:
+        api = VerisAPI(profile=profile)
+        result = api.get_managed_config(env_id)
+
+        status = result.get("status", "created")
+        if status != "ready":
+            output.print_info(f"Environment status: {status}")
+            if status == "pending":
+                output.print_info(
+                    "Your environment is being set up. You'll receive an email when it's ready."
+                )
+            else:
+                output.print_info("No remote config available. Run 'veris env submit' first.")
+            return
+
+        veris_dir = Path.cwd() / ".veris"
+        veris_dir.mkdir(parents=True, exist_ok=True)
+
+        dockerfile_url = result.get("dockerfile_url")
+        if dockerfile_url:
+            resp = httpx.get(dockerfile_url, timeout=60)
+            if resp.status_code == 200:
+                (veris_dir / "Dockerfile.sandbox").write_text(resp.text)
+                output.print_success("Downloaded .veris/Dockerfile.sandbox")
+            else:
+                output.print_warning("Failed to download Dockerfile.sandbox")
+
+        veris_yaml_url = result.get("veris_yaml_url")
+        if veris_yaml_url and resolved_target:
+            resp = httpx.get(veris_yaml_url, timeout=60)
+            if resp.status_code == 200:
+                flat_config = yaml.safe_load(resp.text)
+                # Merge into existing veris.yaml to preserve other targets
+                yaml_path = veris_dir / "veris.yaml"
+                if yaml_path.exists():
+                    existing = yaml.safe_load(yaml_path.read_text()) or {}
+                else:
+                    existing = {"version": "1.0"}
+                existing.setdefault("version", "1.0")
+                existing[resolved_target] = flat_config
+                yaml_path.write_text(yaml.dump(existing, default_flow_style=False, sort_keys=False))
+                output.print_success("Downloaded .veris/veris.yaml")
+            else:
+                output.print_warning("Failed to download veris.yaml")
+
+        # Save sync timestamp
+        env_detail = api.get_environment(env_id)
+        config_ts = env_detail.get("config_updated_at") or datetime.now(UTC).isoformat()
+        ProjectConfig(profile=profile, target=resolved_target).set_config_synced_at(config_ts)
+
+    except Exception as e:
+        output.print_error(f"Failed to pull config: {e}")
+        sys.exit(1)
+
+
 @env.group()
 def vars():
     """Environment variable management."""

{veris_cli-2.23.0 → veris_cli-2.25.0}/src/veris_cli/commands/simulations.py

@@ -30,6 +30,11 @@ def simulations():
     help="Simulation timeout in seconds (60-3600)",
 )
 @click.option("--image-tag", default=None, help="Image tag to use (default: latest)")
+@click.option(
+    "--auto-evaluate/--no-auto-evaluate",
+    default=True,
+    help="Auto-trigger evaluation on completion (default: enabled)",
+)
 @click.pass_context
 def simulations_create(
     ctx,
@@ -37,6 +42,7 @@ def simulations_create(
     env_id: str,
     simulation_timeout: int,
     image_tag: str,
+    auto_evaluate: bool,
 ):
     """Create a new simulation run."""
     profile = get_profile(ctx)
@@ -71,6 +77,7 @@ def simulations_create(
             scenario_set_id=scenario_set_id,
             environment_id=env_id,
             config=config or None,
+            auto_evaluate=auto_evaluate,
         )
 
         run_id = result.get("id")

{veris_cli-2.23.0 → veris_cli-2.25.0}/src/veris_cli/config.py

@@ -312,6 +312,16 @@ class ProjectConfig:
             raw.pop("active_target", None)
         self.save(raw)
 
+    def get_config_synced_at(self) -> Optional[str]:
+        """Get the last config sync timestamp (ISO format)."""
+        return self._load_scope().get("config_synced_at")
+
+    def set_config_synced_at(self, timestamp: str) -> None:
+        """Save the config sync timestamp (ISO format)."""
+        scope = self._load_scope()
+        scope["config_synced_at"] = timestamp
+        self._save_scope(scope)
+
     def get_ci_config(self) -> dict:
         """Get CI config block from project config (profile-level, not per-target)."""
         return self._load_profile().get("ci", {})