agentcore-cli 0.31.1__py3-none-any.whl

agentcore/cli/commands/dev/browser_mode.py

@@ -0,0 +1,270 @@
+"""Port of commands/dev/browser-mode.ts: launch the web UI (agent-inspector) for `agentcore dev`."""
+
+import os
+import sys
+from dataclasses import dataclass, field
+from typing import Any
+
+import typer
+
+from agentcore.lib.schemas.io.config_io import ConfigIO
+from agentcore.lib.schemas.io.path_resolver import find_config_root, get_working_directory
+from agentcore.operations.dev import get_dev_config, get_dev_supported_agents, load_dev_env, load_project_config
+from agentcore.operations.dev.otel import OtelCollector, start_otel_collector
+from agentcore.operations.dev.web_ui import AgentInfo, HarnessInfo, run_web_ui
+
+
+def _deployed_memories(base_dir: str, on_log: Any) -> list[dict[str, str]] | None:
+    """Deployed memories of the first target (name, memoryId, region); None when unavailable."""
+    config_io = ConfigIO(base_dir=base_dir)
+    if not config_io.config_exists("state") or not config_io.config_exists("awsTargets"):
+        return None
+    try:
+        state = config_io.read_deployed_state()
+        targets = config_io.read_aws_deployment_targets()
+        target_name = next(iter(state.targets or {}), None)
+        if not target_name:
+            return None
+        target_state = state.targets[target_name]
+        target_config = next((t for t in targets if t.name == target_name), None)
+        if target_config is None:
+            return None
+        resources = target_state.resources if target_state else None
+        memories = [
+            {"name": name, "memoryId": m.memory_id, "region": target_config.region}
+            for name, m in ((resources.memories if resources else None) or {}).items()
+        ]
+        if not memories:
+            return None
+        names = ", ".join(m["name"] for m in memories)
+        on_log("info", f"Memory browsing enabled for {len(memories)} deployed memory(ies): {names}")
+        return memories
+    except Exception as err:  # noqa: BLE001
+        on_log("warn", f"Could not resolve deployed resources: {err}")
+        return None
+
+
+def _memory_call(base_dir: str, on_log: Any, args: dict[str, Any], search: bool) -> dict[str, Any]:
+    memories = _deployed_memories(base_dir, on_log)
+    if not memories:
+        return {"success": False, "error": "No deployed AgentCore Memory found"}
+    memory = next((m for m in memories if m["name"] == args.get("memoryName")), None)
+    if memory is None:
+        return {"success": False, "error": f'Memory "{args.get("memoryName")}" not found in deployed state'}
+    from agentcore.operations.memory.list_memory_records import list_memory_records
+    from agentcore.operations.memory.retrieve_memory_records import retrieve_memory_records
+
+    common = {
+        "region": memory["region"],
+        "memory_id": memory["memoryId"],
+        "memory_strategy_id": args.get("strategyId"),
+        **(
+            {"namespace": args["namespace"]} if args.get("namespace") else {"namespace_path": args.get("namespacePath")}
+        ),
+    }
+    result = (
+        retrieve_memory_records(search_query=args["searchQuery"], **common) if search else list_memory_records(**common)
+    )
+    if result.success:
+        return {"success": True, **(result.value or {})}
+    return {"success": False, "error": str(result.error)}
+
+
+def get_browser_agent_info(project: Any | None) -> list[AgentInfo]:
+    if project is None:
+        return []
+    names = [r.name for r in project.runtimes]
+    return [
+        {
+            "name": agent.name,
+            "buildType": agent.build,
+            "protocol": agent.protocol or "HTTP",
+            "runtimeIndex": names.index(agent.name),
+        }
+        for agent in get_dev_supported_agents(project)
+    ]
+
+
+def get_browser_selected_agent(agent_name: str | None, agents: list[AgentInfo]) -> str | None:
+    if agent_name is not None:
+        return agent_name
+    return agents[0]["name"] if len(agents) == 1 else None
+
+
+@dataclass
+class BrowserModeOptions:
+    working_dir: str
+    project: Any
+    port: int
+    port_explicit: bool = False
+    agent_name: str | None = None
+    harness_name: str | None = None
+    otel_env_vars: dict[str, str] = field(default_factory=dict)
+    collector: OtelCollector | None = None
+
+
+def launch_browser_dev() -> None:
+    """Standalone browser dev entry point (used from the TUI upstream)."""
+    from agentcore.cli.commands.dev._deps import is_deploy_skippable, run_cli_deploy
+
+    working_dir = get_working_directory()
+    project = load_project_config(working_dir)
+    if project is None or (not project.runtimes and not (project.harnesses or [])):
+        print("Error: No agents or harnesses defined in project.", file=sys.stderr)
+        raise typer.Exit(1)
+    if (project.harnesses or []) and not project.runtimes and not is_deploy_skippable():
+        run_cli_deploy()
+    config_root = find_config_root(working_dir)
+    collector, otel_env = start_otel_collector(os.path.join(config_root or working_dir, ".cli", "traces"))
+    run_browser_mode(BrowserModeOptions(working_dir, project, 8080, otel_env_vars=otel_env, collector=collector))
+
+
+def _cloudwatch_handlers(base_dir: str) -> tuple[Any, Any]:
+    from agentcore.operations.resolve_agent import load_deployed_project_config, resolve_agent_or_harness
+
+    def resolve(agent_name: str | None, harness_name: str | None) -> Any:
+        context = load_deployed_project_config(ConfigIO(base_dir=base_dir))
+        return resolve_agent_or_harness(context, runtime=agent_name, harness=harness_name)
+
+    def on_list(agent_name: Any, harness_name: Any, start_time: Any = None, end_time: Any = None) -> dict[str, Any]:
+        try:
+            from agentcore.operations.traces import list_traces
+
+            resolved = resolve(agent_name, harness_name)
+            if not resolved.success:
+                return {"success": False, "error": resolved.error}
+            agent = resolved.agent
+            result = list_traces(
+                region=agent.region,
+                runtime_id=agent.runtime_id,
+                agent_name=agent.agent_name,
+                start_time=start_time,
+                end_time=end_time,
+            )
+            return (
+                {"success": True, **result.value} if result.success else {"success": False, "error": str(result.error)}
+            )
+        except Exception as err:  # noqa: BLE001
+            return {"success": False, "error": f"Failed to list CloudWatch traces: {err}"}
+
+    def on_get(
+        agent_name: Any, harness_name: Any, trace_id: str, start_time: Any = None, end_time: Any = None
+    ) -> dict[str, Any]:
+        try:
+            from agentcore.operations.traces import fetch_trace_records
+
+            resolved = resolve(agent_name, harness_name)
+            if not resolved.success:
+                return {"success": False, "error": resolved.error}
+            result = fetch_trace_records(
+                region=resolved.agent.region,
+                runtime_id=resolved.agent.runtime_id,
+                trace_id=trace_id,
+                start_time=start_time,
+                end_time=end_time,
+                include_spans=True,
+            )
+            return (
+                {"success": True, **result.value} if result.success else {"success": False, "error": str(result.error)}
+            )
+        except Exception as err:  # noqa: BLE001
+            return {"success": False, "error": f"Failed to get CloudWatch trace: {err}"}
+
+    return on_list, on_get
+
+
+def run_browser_mode(opts: BrowserModeOptions) -> None:
+    working_dir, project = opts.working_dir, opts.project
+    config_root = find_config_root(working_dir)
+    # Browser mode serves every agent, so payment env vars are not narrowed to one runtime.
+    env_vars = load_dev_env(working_dir).env_vars
+
+    supported = get_dev_supported_agents(project)
+    if not supported and not (project.harnesses or []):
+        print("Error: No dev-supported agents found.", file=sys.stderr)
+        raise typer.Exit(1)
+    if opts.agent_name and not any(a.name == opts.agent_name for a in supported):
+        print(f'Error: Agent "{opts.agent_name}" not found or does not support dev mode.', file=sys.stderr)
+        raise typer.Exit(1)
+
+    def on_log(level: str, msg: str) -> None:
+        if level == "error":
+            print(f"Web UI: {msg}", file=sys.stderr)
+
+    otel_env = opts.otel_env_vars or {}
+    agent_info = get_browser_agent_info(project)
+    base_dir = config_root or working_dir
+
+    harness_info: list[HarnessInfo] = []
+    try:
+        config_io = ConfigIO(base_dir=base_dir)
+        if config_io.config_exists("state") and config_io.config_exists("awsTargets"):
+            state = config_io.read_deployed_state()
+            targets = config_io.read_aws_deployment_targets()
+            target_name = next(iter(state.targets or {}), None)
+            target_config = next((t for t in targets if t.name == target_name), None) if target_name else None
+            if target_config is not None:
+                resources = state.targets[target_name].resources if state.targets[target_name] else None
+                for harness in project.harnesses or []:
+                    h_state = ((resources.harnesses if resources else None) or {}).get(harness.name)
+                    if h_state:
+                        harness_info.append(HarnessInfo(harness.name, h_state.harness_arn, target_config.region))
+                if harness_info:
+                    names = ", ".join(h.name for h in harness_info)
+                    on_log("info", f"Found {len(harness_info)} deployed harness(es): {names}")
+    except Exception:  # noqa: BLE001 - harness discovery is best-effort
+        pass
+
+    def get_env_vars() -> dict[str, str]:
+        return {**load_dev_env(working_dir).env_vars, **otel_env}
+
+    def dev_config(name: str) -> Any:
+        return get_dev_config(working_dir, load_project_config(working_dir), config_root, name)
+
+    def reload_agents() -> list[AgentInfo]:
+        return get_browser_agent_info(load_project_config(working_dir))
+
+    collector = opts.collector
+    on_list_cw, on_get_cw = _cloudwatch_handlers(base_dir)
+    run_web_ui(
+        log_label="dev",
+        on_log=on_log,
+        server_options={
+            "mode": "dev",
+            "agents": agent_info,
+            "harnesses": harness_info,
+            "selected_agent": get_browser_selected_agent(opts.agent_name, agent_info),
+            "selected_harness": opts.harness_name,
+            "agent_base_port": opts.port if opts.port_explicit else None,
+            "env_vars": {**env_vars, **otel_env},
+            "get_env_vars": get_env_vars,
+            "config_root": config_root,
+            "get_dev_config": dev_config,
+            "reload_agents": reload_agents if config_root else None,
+            "on_list_traces": (lambda a, s=None, e=None: collector.list_traces(a, s, e)) if collector else None,
+            "on_get_trace": (lambda a, t, s=None, e=None: collector.get_trace_spans(a, t)) if collector else None,
+            "on_list_cloud_watch_traces": on_list_cw,
+            "on_get_cloud_watch_trace": on_get_cw,
+            "on_list_memory_records": lambda args: _memory_call(base_dir, on_log, args, False),
+            "on_retrieve_memory_records": lambda args: _memory_call(base_dir, on_log, args, True),
+        },
+    )
+
+
+def launch_tui_dev_screen_with_picker(working_dir: str, skip_deploy: bool = False) -> dict[str, str | None] | None:
+    """Prompt-based replacement for the DevScreen picker: deploy (harnesses), then pick a target."""
+    from agentcore.cli import interactive
+    from agentcore.cli.commands.dev._deps import run_cli_deploy
+
+    interactive.require_tty()
+    project = load_project_config(working_dir)
+    if project is None:
+        return None
+    agents = [a.name for a in get_dev_supported_agents(project)]
+    harnesses = [h.name for h in project.harnesses or []]
+    if harnesses and not agents and not skip_deploy:
+        run_cli_deploy()
+    if agents:
+        return {"agentName": agents[0] if len(agents) == 1 else None}
+    # The web UI handles harness selection when there is more than one.
+    return {"harnessName": harnesses[0] if len(harnesses) == 1 else None}