hud-python 0.4.54__py3-none-any.whl → 0.4.56__py3-none-any.whl

hud/cli/dev.py

@@ -25,6 +25,7 @@ def show_dev_server_info(
     inspector: bool,
     interactive: bool,
     env_dir: Path | None = None,
+    new: bool = False,
 ) -> str:
     """Show consistent server info for both Python and Docker modes.
 
@@ -125,6 +126,7 @@ async def run_mcp_module(
     verbose: bool,
     inspector: bool,
     interactive: bool,
+    new: bool = False,
 ) -> None:
     """Run an MCP module directly."""
     # Check if this is a reload (not first run)
@@ -222,14 +224,53 @@ async def run_mcp_module(
 
     # Show server info only on first run
     if not is_reload:
-        show_dev_server_info(
-            server_name=mcp_server.name or "mcp-server",
-            port=port,
-            transport=transport,
-            inspector=inspector,
-            interactive=interactive,
-            env_dir=Path.cwd().parent if (Path.cwd().parent / "environment").exists() else None,
-        )
+        # Try dynamic trace first for HTTP mode (only if --new)
+        live_trace_url: str | None = None
+        if transport == "http" and new:
+            try:
+                local_mcp_config: dict[str, dict[str, Any]] = {
+                    "hud": {
+                        "url": f"http://localhost:{port}/mcp",
+                        "headers": {},
+                    }
+                }
+
+                from hud.cli.flows.dev import create_dynamic_trace
+
+                live_trace_url = await create_dynamic_trace(
+                    mcp_config=local_mcp_config,
+                    build_status=False,
+                    environment_name=mcp_server.name or "mcp-server",
+                )
+            except Exception:  # noqa: S110
+                pass
+
+        # Show UI using shared flow logic
+        if transport == "http" and live_trace_url and new:
+            # Minimal UI with live trace
+            from hud.cli.flows.dev import generate_cursor_deeplink, show_dev_ui
+
+            server_name = mcp_server.name or "mcp-server"
+            cursor_deeplink = generate_cursor_deeplink(server_name, port)
+
+            show_dev_ui(
+                live_trace_url=live_trace_url,
+                server_name=server_name,
+                port=port,
+                cursor_deeplink=cursor_deeplink,
+                is_docker=False,
+            )
+        else:
+            # Full UI for HTTP without trace, or stdio mode
+            show_dev_server_info(
+                server_name=mcp_server.name or "mcp-server",
+                port=port,
+                transport=transport,
+                inspector=inspector,
+                interactive=interactive,
+                env_dir=Path.cwd().parent if (Path.cwd().parent / "environment").exists() else None,
+                new=new,
+            )
 
     # Check if there's an environment backend and remind user to start it (first run only)
     if not is_reload:
@@ -238,7 +279,8 @@ async def run_mcp_module(
         if env_dir.exists() and (env_dir / "server.py").exists():
             hud_console.info("")
             hud_console.info(
-                f"{hud_console.sym.FLOW} Don't forget to start the environment backend in another terminal:"
+                f"{hud_console.sym.FLOW} Don't forget to start the environment backend in another "
+                "terminal:"
             )
             hud_console.info("   cd environment && uv run python uvicorn server:app --reload")
 
@@ -347,6 +389,7 @@ def run_with_reload(
     verbose: bool,
     inspector: bool,
     interactive: bool,
+    new: bool = False,
 ) -> None:
     """Run module with file watching and auto-reload."""
     try:
@@ -389,6 +432,11 @@ def run_with_reload(
 
         if verbose:
             cmd.append("--verbose")
+
+        if new:
+            cmd.append("--new")
+
+        if verbose:
             hud_console.info(f"Starting: {' '.join(cmd)}")
 
         # Mark as reload after first run to suppress logs
@@ -454,7 +502,12 @@ def run_with_reload(
 
 
 def run_docker_dev_server(
-    port: int, verbose: bool, inspector: bool, interactive: bool, docker_args: list[str]
+    port: int,
+    verbose: bool,
+    inspector: bool,
+    interactive: bool,
+    docker_args: list[str],
+    new: bool = False,
 ) -> None:
     """Run MCP server in Docker with volume mounts, expose via local HTTP proxy."""
     import typer
@@ -462,6 +515,11 @@ def run_docker_dev_server(
 
     from hud.server import MCPServer
 
+    # Ensure Docker CLI and daemon are available before proceeding
+    from .utils.docker import require_docker_running
+
+    require_docker_running()
+
     cwd = Path.cwd()
 
     # Find environment directory (current or parent with hud.lock.yaml)
@@ -528,15 +586,6 @@ def run_docker_dev_server(
         env_dir=env_dir,
     )
 
-    # Env flags already injected by create_docker_run_command
-
-    # Print startup info
-    hud_console.header("HUD Development Mode (Docker)")
-
-    if verbose:
-        hud_console.section_title("Docker Command")
-        hud_console.info(" ".join(docker_cmd))
-
     # Create MCP config pointing to the Docker container's stdio
     mcp_config = {
         "docker": {
@@ -545,15 +594,62 @@ def run_docker_dev_server(
         }
     }
 
-    # Show consistent server info
-    show_dev_server_info(
-        server_name=image_name,
-        port=port,
-        transport="http",  # Docker mode always uses HTTP proxy
-        inspector=inspector,
-        interactive=interactive,
-        env_dir=env_dir,
-    )
+    # Attempt to create dynamic trace early (before any UI)
+    import asyncio as _asy
+
+    from hud.cli.flows.dev import create_dynamic_trace, generate_cursor_deeplink, show_dev_ui
+
+    live_trace_url: str | None = None
+    if new:
+        try:
+            local_mcp_config: dict[str, dict[str, Any]] = {
+                "hud": {
+                    "url": f"http://localhost:{port}/mcp",
+                    "headers": {},
+                }
+            }
+            live_trace_url = _asy.run(
+                create_dynamic_trace(
+                    mcp_config=local_mcp_config,
+                    build_status=True,
+                    environment_name=image_name,
+                )
+            )
+        except Exception:  # noqa: S110
+            pass
+
+    # Show appropriate UI
+    if live_trace_url and new:
+        # Minimal UI with live trace
+        cursor_deeplink = generate_cursor_deeplink(image_name, port)
+        show_dev_ui(
+            live_trace_url=live_trace_url,
+            server_name=image_name,
+            port=port,
+            cursor_deeplink=cursor_deeplink,
+            is_docker=True,
+        )
+    else:
+        # Full UI
+        hud_console.header("HUD Development Mode (Docker)")
+        if verbose:
+            hud_console.section_title("Docker Command")
+            hud_console.info(" ".join(docker_cmd))
+        show_dev_server_info(
+            server_name=image_name,
+            port=port,
+            transport="http",
+            inspector=inspector,
+            interactive=interactive,
+            env_dir=env_dir,
+            new=new,
+        )
+        hud_console.dim_info(
+            "",
+            "Container restarts on file changes (mounted volumes), "
+            "if changing tools run hud dev again",
+        )
+        hud_console.info("")
 
     # Suppress logs unless verbose
     if not verbose:
@@ -562,13 +658,6 @@ def run_docker_dev_server(
         logging.getLogger("uvicorn").setLevel(logging.ERROR)
         os.environ["FASTMCP_DISABLE_BANNER"] = "1"
 
-    # Note about hot-reload behavior
-    hud_console.dim_info(
-        "",
-        "Container restarts on file changes (mounted volumes), if changing tools run hud dev again",
-    )
-    hud_console.info("")
-
     # Create and run proxy with HUD helpers
     async def run_proxy() -> None:
         from fastmcp import FastMCP
@@ -617,6 +706,7 @@ def run_mcp_dev_server(
     watch: list[str] | None,
     docker: bool = False,
     docker_args: list[str] | None = None,
+    new: bool = False,
 ) -> None:
     """Run MCP development server with hot-reload."""
     docker_args = docker_args or []
@@ -627,12 +717,12 @@ def run_mcp_dev_server(
         hud_console.note("Detected Dockerfile - using Docker mode with volume mounts")
         hud_console.dim_info("Tip", "Use 'hud dev --help' to see all options")
         hud_console.info("")
-        run_docker_dev_server(port, verbose, inspector, interactive, docker_args)
+        run_docker_dev_server(port, verbose, inspector, interactive, docker_args, new)
         return
 
     # Route to Docker mode if explicitly requested
     if docker:
-        run_docker_dev_server(port, verbose, inspector, interactive, docker_args)
+        run_docker_dev_server(port, verbose, inspector, interactive, docker_args, new)
         return
 
     transport = "stdio" if stdio else "http"
@@ -676,6 +766,6 @@ def run_mcp_dev_server(
     is_child = os.environ.get("_HUD_DEV_CHILD") == "1"
 
     if is_child:
-        asyncio.run(run_mcp_module(module, transport, port, verbose, False, False))
+        asyncio.run(run_mcp_module(module, transport, port, verbose, False, False, new))
     else:
-        run_with_reload(module, watch_paths, transport, port, verbose, inspector, interactive)
+        run_with_reload(module, watch_paths, transport, port, verbose, inspector, interactive, new)

hud/cli/eval.py

@@ -22,6 +22,28 @@ logger = logging.getLogger(__name__)
 hud_console = HUDConsole()
 
 
+def _tasks_use_local_mcp(tasks: list[Task]) -> bool:
+    """Return True if any task's MCP config uses a local command instead of a URL.
+
+    A config is considered local when a server entry contains a 'command' key and
+    does not provide a 'url'.
+    """
+    try:
+        for t in tasks:
+            cfg = getattr(t, "mcp_config", {}) or {}
+            if not isinstance(cfg, dict):
+                continue
+            for server_cfg in cfg.values():
+                if isinstance(server_cfg, dict) and (
+                    "command" in server_cfg and not server_cfg.get("url")
+                ):
+                    return True
+        return False
+    except Exception:
+        # Be conservative: if detection fails, do not block
+        return False
+
+
 def get_available_models() -> list[dict[str, str | None]]:
     """Fetch available models from the HUD API (only ready models).
 
@@ -265,7 +287,33 @@ async def run_single_task(
             "Using first task from dataset (run with --full to run the entire dataset)..."
         )
 
-    task_prompt = task.prompt[:50] + "..." if len(task.prompt) > 50 else task.prompt
+    # Warn/confirm if the task uses local MCP config
+    try:
+        if group_size > 1 and _tasks_use_local_mcp([task]):
+            hud_console.warning(
+                "Detected a local MCP configuration (uses 'command' instead of a 'url')."
+            )
+            hud_console.info(
+                "Ensure there are no exposed port conflicts during Docker runs/builds in eval."
+            )
+            proceed = hud_console.confirm(
+                "Proceed with running local MCP servers for this evaluation?",
+                default=True,
+            )
+            if not proceed:
+                # Provide a helpful next step
+                hud_console.hint("You can convert tasks to remote with: hud convert <tasks_file>")
+                raise typer.Exit(1)
+            # Always show the convert hint for awareness
+            hud_console.hint(
+                "Avoid local port conflicts by converting to remote: hud convert <tasks_file>"
+            )
+    except typer.Exit:
+        raise
+    except Exception as e:
+        hud_console.debug(f"Local MCP confirmation skipped due to error: {e}")
+
+    task_prompt = task.prompt
 
     # Use grouped evaluation if group_size > 1
     agent_config: dict[str, Any] = {}
@@ -387,6 +435,56 @@ async def run_full_dataset(
         hud_console.error(f"No tasks found in: {source}")
         raise typer.Exit(1)
 
+    # Warn/confirm once if any task uses local MCP config
+    try:
+        if _tasks_use_local_mcp(tasks):
+            hud_console.warning(
+                "Detected local MCP configurations (use 'command' instead of a 'url')."
+            )
+            hud_console.info(
+                "When running many tasks concurrently, exposed host ports from Docker may conflict."
+            )
+            proceed = hud_console.confirm(
+                "Proceed with running local MCP servers for this evaluation?",
+                default=True,
+            )
+            if not proceed:
+                # Helpful hint when source is a file path
+                try:
+                    path = Path(source)
+                    if path.exists():
+                        hud_console.hint(
+                            f"You can convert tasks to remote with: hud convert {path.name}"
+                        )
+                    else:
+                        hud_console.hint(
+                            "You can convert tasks to remote with: hud convert <tasks_file>"
+                        )
+                except Exception:
+                    hud_console.hint(
+                        "You can convert tasks to remote with: hud convert <tasks_file>"
+                    )
+                raise typer.Exit(1)
+            # Always show the convert hint for awareness
+            try:
+                path = Path(source)
+                if path.exists():
+                    hud_console.hint(
+                        f"Convert to remote to avoid port conflicts: hud convert {path.name}"
+                    )
+                else:
+                    hud_console.hint(
+                        "Convert to remote to avoid port conflicts: hud convert <tasks_file>"
+                    )
+            except Exception:
+                hud_console.hint(
+                    "Convert to remote to avoid port conflicts: hud convert <tasks_file>"
+                )
+    except typer.Exit:
+        raise
+    except Exception as e:
+        hud_console.debug(f"Local MCP confirmation skipped due to error: {e}")
+
     # Convert Task objects to dicts for dataset runners
     dataset_or_tasks = [task.model_dump() for task in tasks]
 

hud/cli/flows/dev.py

@@ -0,0 +1,155 @@
+from __future__ import annotations
+
+import base64
+import contextlib
+import json
+import logging
+from typing import Any
+
+from hud.settings import settings
+from hud.shared.requests import make_request
+from hud.utils.hud_console import hud_console
+
+logger = logging.getLogger(__name__)
+
+
+async def create_dynamic_trace(
+    *,
+    mcp_config: dict[str, dict[str, Any]],
+    build_status: bool,
+    environment_name: str,
+) -> str | None:
+    """
+    Create a dynamic trace for HUD dev sessions when running in HTTP mode.
+
+    Sends a POST to the HUD API with:
+      - mcp_config: points to the local MCP config (same as Cursor)
+      - build_status: True if Docker mode (built image), False if basic Python mode
+      - environment_name: Name of the environment/server/image
+
+    Returns the full URL to the live trace when successful, otherwise None.
+    """
+    api_base = settings.hud_api_url.rstrip("/")
+    # Endpoint TBD; use a sensible default path that the backend can wire up
+    url = f"{api_base}/dev/dynamic-traces"
+
+    payload = {
+        "mcp_config": mcp_config,
+        "build_status": bool(build_status),
+        "environment_name": environment_name,
+    }
+
+    # Best-effort; if missing API key, log and continue
+    api_key = settings.api_key
+    if not api_key:
+        logger.warning("Skipping dynamic trace creation; missing HUD_API_KEY")
+        return None
+
+    try:
+        resp = await make_request("POST", url=url, json=payload, api_key=api_key)
+        # New API returns an id; construct the URL as https://hud.so/trace/{id}
+        trace_id = None
+        if isinstance(resp, dict):
+            trace_id = resp.get("id")
+            if trace_id is None:
+                data = resp.get("data", {}) or {}
+                if isinstance(data, dict):
+                    trace_id = data.get("id")
+            # Backcompat: if url is provided directly
+            if not trace_id:
+                direct_url = resp.get("url") or (resp.get("data", {}) or {}).get("url")
+                if isinstance(direct_url, str) and direct_url:
+                    return direct_url
+
+        if isinstance(trace_id, str) and trace_id:
+            return f"https://hud.so/trace/{trace_id}"
+        return None
+    except Exception as e:
+        # Do not interrupt dev flow
+        try:
+            preview = json.dumps(payload)[:500]
+            logger.warning("Failed to create dynamic dev trace: %s | payload=%s", e, preview)
+        except Exception:
+            logger.warning("Failed to create dynamic dev trace: %s", e)
+        return None
+
+
+def show_dev_ui(
+    *,
+    live_trace_url: str,
+    server_name: str,
+    port: int,
+    cursor_deeplink: str,
+    is_docker: bool = False,
+) -> None:
+    """
+    Show the minimal dev UI with live trace link.
+
+    This is called only when we have a successful trace URL.
+    For full UI mode, the caller should use show_dev_server_info() directly.
+
+    Args:
+        live_trace_url: URL to the live trace
+        server_name: Name of the server/image
+        port: Port the server is running on
+        cursor_deeplink: Pre-generated Cursor deeplink URL
+        is_docker: Whether this is Docker mode (affects hot-reload message)
+    """
+    import webbrowser
+
+    from rich.panel import Panel
+
+    # Show header first
+    hud_console.header("HUD Development Server", icon="🚀")
+
+    # Try to open the live trace in the default browser
+    with contextlib.suppress(Exception):
+        # new=2 -> open in a new tab, if possible
+        webbrowser.open(live_trace_url, new=2)
+
+    # Show panel with just the link
+    # Center the link and style it: blue, bold, underlined
+    link_markup = f"[bold underline rgb(108,113,196)][link={live_trace_url}]{live_trace_url}[/link][/bold underline rgb(108,113,196)]"  # noqa: E501
+    # Use center alignment by surrounding with spaces via justify
+    from rich.align import Align
+
+    panel = Panel(
+        Align.center(link_markup),
+        title="🔗 Live Dev Trace",
+        border_style="rgb(192,150,12)",  # HUD gold
+        padding=(1, 2),
+    )
+    hud_console.console.print(panel)
+
+    # Show other info below
+    label = "Base image" if is_docker else "Server"
+    hud_console.info("")
+    hud_console.info(f"{hud_console.sym.ITEM} {label}: {server_name}")
+    hud_console.info(f"{hud_console.sym.ITEM} Cursor: {cursor_deeplink}")
+    hud_console.info("")
+    hud_console.info(f"{hud_console.sym.SUCCESS} Hot-reload enabled")
+    if is_docker:
+        hud_console.dim_info(
+            "",
+            "Container restarts on file changes (mounted volumes), "
+            "if changing tools run hud dev again",
+        )
+    hud_console.info("")
+
+
+def generate_cursor_deeplink(server_name: str, port: int) -> str:
+    """Generate a Cursor deeplink for the MCP server.
+
+    Args:
+        server_name: Name of the server
+        port: Port the server is running on
+
+    Returns:
+        Cursor deeplink URL
+    """
+    server_config = {"url": f"http://localhost:{port}/mcp"}
+    config_json = json.dumps(server_config, indent=2)
+    config_base64 = base64.b64encode(config_json.encode()).decode()
+    return (
+        f"cursor://anysphere.cursor-deeplink/mcp/install?name={server_name}&config={config_base64}"
+    )

hud/cli/flows/tasks.py

@@ -11,7 +11,7 @@ import yaml
 
 from hud.cli.push import push_environment
 from hud.cli.utils.docker import require_docker_running
-from hud.cli.utils.env_check import ensure_built, find_environment_dir
+from hud.cli.utils.env_check import find_environment_dir
 from hud.cli.utils.registry import extract_name_and_tag
 from hud.utils.hud_console import hud_console
 from hud.utils.tasks import load_tasks
@@ -56,7 +56,9 @@ def _validate_tasks(tasks: list[Task]) -> bool:
     return True
 
 
-def _ensure_pushed(env_dir: Path, lock_data: dict[str, Any]) -> dict[str, Any]:
+def _ensure_pushed(
+    env_dir: Path, lock_data: dict[str, Any], check_docker: bool = True
+) -> dict[str, Any]:
     """Ensure the environment is pushed to a registry; return updated lock data."""
     pushed = bool(lock_data.get("push"))
     if not pushed:
@@ -64,7 +66,8 @@ def _ensure_pushed(env_dir: Path, lock_data: dict[str, Any]) -> dict[str, Any]:
         if not hud_console.confirm("Push to a registry now (runs 'hud push')?", default=True):
             raise typer.Exit(1)
         # Check Docker availability before attempting a push
-        require_docker_running()
+        if check_docker:
+            require_docker_running()
 
         # If Docker or login is not configured, the push function will fail and halt.
         push_environment(str(env_dir), yes=True)
@@ -293,9 +296,24 @@ def convert_tasks_to_remote(tasks_file: str) -> str:
         hud_console.hint("Ensure you're in or near your environment folder before running 'hud rl'")
         raise typer.Exit(1)
 
-    # Ensure built and pushed
-    lock_data = ensure_built(env_dir, interactive=True)
-    lock_data = _ensure_pushed(env_dir, lock_data)
+    # For convert command, we don't need Docker running - just check for lock file
+    # This avoids showing Docker-related messages during conversion
+    lock_path = env_dir / "hud.lock.yaml"
+    if not lock_path.exists():
+        hud_console.error("No hud.lock.yaml found. The environment needs to be built first.")
+        hud_console.info("Run 'hud build' in the environment directory to build it.")
+        raise typer.Exit(1)
+
+    # Load lock data directly
+    try:
+        with open(lock_path) as f:
+            lock_data: dict[str, Any] = yaml.safe_load(f) or {}
+    except Exception as e:
+        hud_console.error(f"Failed to read hud.lock.yaml: {e}")
+        raise typer.Exit(1) from e
+
+    # Check if pushed - don't check Docker for convert command
+    lock_data = _ensure_pushed(env_dir, lock_data, check_docker=False)
 
     # Derive remote image name org/name:tag
     remote_image = _derive_remote_image(lock_data)
@@ -387,8 +405,11 @@ def convert_tasks_to_remote(tasks_file: str) -> str:
             f"Detected env vars in .env that look like API keys: {names_preview}.\n"
             "Include them as remote headers (values will be ${VAR} placeholders)?"
         )
-        if hud_console.confirm(prompt, default=True):
-            all_detected.update(missing)
+        if not hud_console.confirm(prompt, default=True):
+            # User cancelled - exit without creating the file
+            hud_console.info("Conversion cancelled by user")
+            raise typer.Exit(0)
+        all_detected.update(missing)
 
     # Final set of env vars to convert to headers
     provided_keys = all_detected
@@ -461,6 +482,5 @@ def convert_tasks_to_remote(tasks_file: str) -> str:
         f.write("\n")
 
     hud_console.success(f"Created remote tasks file: {remote_path.name}")
-    hud_console.hint("Proceeding with RL training on the remote environment")
 
     return str(remote_path)

hud/cli/init.py

@@ -23,6 +23,7 @@ PRESET_MAP: dict[str, str | None] = {
     "blank": "blank",
     "deep-research": "deepresearch",
     "browser": "browser",
+    "rubrics": "rubrics",
 }
 
 SKIP_DIR_NAMES = {"node_modules", "__pycache__", "dist", "build", ".next", ".git"}
@@ -91,6 +92,7 @@ def _prompt_for_preset() -> str:
             {"name": "blank", "message": "blank"},
             {"name": "deep-research", "message": "deep-research"},
             {"name": "browser", "message": "browser"},
+            {"name": "rubrics", "message": "rubrics"},
         ]
         display_choices = [c["message"] for c in choices]
         selected = questionary.select(
@@ -194,7 +196,7 @@ def create_environment(
     if preset_normalized not in PRESET_MAP:
         hud_console.warning(
             f"Unknown preset '{preset_normalized}', defaulting to 'blank' "
-            "(available: blank, deep-research, browser)"
+            "(available: blank, deep-research, browser, rubrics)"
         )
         preset_normalized = "blank"
 

hud/cli/utils/docker.py

@@ -308,7 +308,10 @@ def require_docker_running() -> None:
             "Is Docker running? Open Docker Desktop and wait until it reports 'Running'"
         )
         raise typer.Exit(1) from e
-    except Exception as e:
-        hud_console.error(f"Docker check failed: {e}")
+    except typer.Exit:
+        # Propagate cleanly without extra noise; hints already printed above
+        raise
+    except Exception:
+        # Unknown failure - keep output minimal and avoid stack traces
         hud_console.hint("Is the Docker daemon running?")
-        raise typer.Exit(1) from e
+        raise typer.Exit(1)  # noqa: B904

hud/clients/base.py

@@ -146,7 +146,7 @@ class BaseHUDClient(AgentMCPClient):
         except HudException:
             raise
         except Exception as e:
-            # Auto-converts to appropriate HUD exception type with hints
+            hud_console.error(f"Failed to initialize MCP client: {e}")
             raise HudException from e
 
         # Common hud behavior - fetch telemetry
@@ -333,7 +333,7 @@ class BaseHUDClient(AgentMCPClient):
             tool_info = {
                 "name": tool.name,
                 "description": tool.description,
-                "input_schema": tool.inputSchema,
+                "inputSchema": tool.inputSchema,
             }
             analysis["tools"].append(tool_info)