agentcore-cli 0.31.1__py3-none-any.whl

agentcore/cli/commands/dev/terminal_mode.py

@@ -0,0 +1,379 @@
+"""`agentcore dev --no-browser`: line-oriented replacement for the Ink DevScreen + useDevServer hook.
+
+Upstream renders a full-screen TUI. Per PORTING.md this port asks the same questions with prompts:
+pick an agent (or harness), start the dev server with logs streamed to the terminal, then read
+messages from a ``> `` prompt and stream responses token by token.
+
+Input conventions (keyboard shortcuts upstream → commands here):
+  ``!cmd``     run a shell command locally (``! exec``)
+  ``!!cmd``    run a shell command in the dev container (Container agents)
+  ``list``     refresh MCP tools (MCP agents); ``tool_name {"arg": "value"}`` calls a tool
+  ``/clear``   clear the conversation (C), ``/restart`` restart the server (Ctrl+R),
+  ``/quit``    stop and exit (Esc / Ctrl+Q / Ctrl+D)
+"""
+
+import json
+import os
+import re
+import subprocess
+import sys
+import threading
+import uuid
+from typing import Any
+
+import typer
+
+from agentcore.cli import interactive
+from agentcore.lib.errors.types import DevServerConnectionError, DevServerError
+from agentcore.lib.schemas.io.path_resolver import find_config_root
+from agentcore.logging import DevLogger
+from agentcore.operations.dev import (
+    call_mcp_tool,
+    create_dev_server,
+    fetch_a2a_agent_card,
+    find_available_port,
+    format_mcp_tool_list,
+    get_dev_config,
+    get_dev_port,
+    get_dev_supported_agents,
+    get_endpoint_url,
+    invoke_a2a_streaming,
+    invoke_agent_streaming,
+    invoke_agui_streaming,
+    list_mcp_tools,
+    load_dev_env,
+    load_project_config,
+    requires_exact_dev_port,
+    wait_for_port,
+)
+from agentcore.operations.dev.container_runtime import detect_container_runtime
+from agentcore.operations.dev.dev_server import DevServerCallbacks, DevServerOptions
+from agentcore.operations.dev.invoke_types import InvokeStreamingOptions
+
+READY_MARKERS = ("Application startup complete", "Uvicorn running", "Server listening")
+_LEVEL_PREFIX = {"error": "❌ ", "warn": "⚠️  ", "system": "→ ", "response": "", "info": "  "}
+
+
+class _Session:
+    def __init__(
+        self, working_dir: str, port: int, port_explicit: bool, agent_name: str, headers: dict[str, str] | None
+    ):
+        self.working_dir = working_dir
+        self.target_port = port
+        self.port_explicit = port_explicit
+        self.headers = headers
+        self.project = load_project_config(working_dir)
+        self.config_root = find_config_root(working_dir)
+        runtime = next((r for r in self.project.runtimes if r.name == agent_name), None) if self.project else None
+        dev_env = load_dev_env(working_dir, runtime) if self.config_root else None
+        self.env_vars: dict[str, str] = dev_env.env_vars if dev_env else {}
+        memories = (self.project.memories if self.project else None) or []
+        if dev_env and memories and dev_env.deployed_memory_count < len(memories):
+            self._print("warn", "Memory is configured but not deployed yet. Run `agentcore deploy` to use it locally.")
+        self.config = get_dev_config(working_dir, self.project, self.config_root, agent_name)
+        self.protocol = self.config.protocol if self.config else "HTTP"
+        self.actual_port = port
+        self.server: Any = None
+        self.logger: DevLogger | None = None
+        self.ready = threading.Event()
+        self.exited = threading.Event()
+        self.recent_errors: list[str] = []
+        self.mcp_session_id: str | None = None
+        self.mcp_tools: list[dict[str, Any]] = []
+        self.agui_thread_id = str(uuid.uuid4())
+        self.restarting = False
+        self.instance = 0
+
+    def _print(self, level: str, message: str) -> None:
+        print(f"{_LEVEL_PREFIX.get(level, '')}{message}", flush=True)
+
+    def add_log(self, level: str, message: str) -> None:
+        if level == "error":
+            self.recent_errors = [*self.recent_errors, message][-5:]
+        self._print(level, message)
+        if self.logger:
+            self.logger.log(level, message)  # type: ignore[arg-type]
+
+    def start(self, is_restart: bool = False) -> bool:
+        assert self.config is not None
+        self.logger = DevLogger(base_dir=self.working_dir, agent_name=self.config.agent_name)
+        target = get_dev_port(
+            self.project, self.config.agent_name, self.config.protocol, self.target_port, self.port_explicit
+        )
+        port_free = True
+        if is_restart:
+            port_free = wait_for_port(self.actual_port)
+            if not port_free:
+                self.add_log("warn", f"Port {self.actual_port} not released, finding new port")
+        if requires_exact_dev_port(self.config.protocol):
+            if find_available_port(target) != target:
+                self.add_log("error", f"Port {target} is in use. {self.config.protocol} agents require port {target}.")
+                return False
+            port = target
+        else:
+            port = self.actual_port if is_restart and port_free else find_available_port(target)
+            if not is_restart and port != target:
+                if self.port_explicit:
+                    self.add_log(
+                        "error",
+                        f"Port {target} is in use. Free it or pass a different --port "
+                        "(no port is chosen automatically when --port is set explicitly).",
+                    )
+                    return False
+                self.add_log("warn", f"Port {target} in use, using {port}")
+        self.actual_port = port
+        self.instance += 1
+        instance = self.instance
+        self.ready.clear()
+        self.exited.clear()
+
+        def on_log(level: str, message: str) -> None:
+            if instance != self.instance:
+                return
+            if not self.ready.is_set() and any(m in message for m in READY_MARKERS):
+                self.ready.set()
+                self.add_log("system", f"Server ready at {get_endpoint_url(port, self.protocol)}")
+            else:
+                self.add_log(level, message)
+
+        def on_exit(code: int | None) -> None:
+            if instance != self.instance:
+                return
+            if self.restarting:
+                self.restarting = False
+                return
+            self.exited.set()
+            self.add_log(
+                "system",
+                f"Server crashed (code {code}) — check logs above for details"
+                if code not in (0, None)
+                else f"Server exited (code {'null' if code is None else code})",
+            )
+
+        self.server = create_dev_server(
+            self.config,
+            DevServerOptions(port=port, env_vars=self.env_vars, callbacks=DevServerCallbacks(on_log, on_exit)),
+        )
+        return self.server.start() is not None
+
+    def stop(self) -> None:
+        if self.server:
+            self.server.kill()
+        if self.logger:
+            self.logger.finalize()
+
+    def restart(self) -> None:
+        self.add_log("system", "Restarting server...")
+        self.restarting = True
+        if self.server:
+            self.server.kill()
+        self.start(is_restart=True)
+
+    # --- interaction ------------------------------------------------------------------------
+
+    def fetch_mcp_tools(self) -> None:
+        try:
+            result = list_mcp_tools(self.actual_port, self.logger, self.headers)
+            self.mcp_tools, self.mcp_session_id = result.tools, result.session_id
+        except Exception as err:  # noqa: BLE001
+            self.add_log("error", f"Failed to list MCP tools: {err}")
+            self.mcp_tools = []
+
+    def invoke(self, message: str) -> None:
+        if self.protocol == "MCP":
+            if message.strip().lower() == "list":
+                self.fetch_mcp_tools()
+                print(format_mcp_tool_list(self.mcp_tools))
+                return
+            match = re.match(r"^(\S+)\s*(.*)", message)
+            if not match:
+                return
+            tool_name, args_str = match.group(1), match.group(2).strip()
+            try:
+                args = json.loads(args_str) if args_str else {}
+                result = call_mcp_tool(
+                    self.actual_port, tool_name, args, self.mcp_session_id, self.logger, self.headers
+                )
+                print(f"Result: {result}")
+                if self.logger:
+                    self.logger.log("system", f"MCP call: {tool_name}({args_str})")
+                    self.logger.log("response", result)
+            except Exception as err:  # noqa: BLE001
+                self.add_log("error", f"MCP call failed: {err}")
+            return
+
+        options = InvokeStreamingOptions(
+            port=self.actual_port,
+            message=message,
+            logger=self.logger,
+            headers=self.headers,
+            on_status=(lambda s: print(f"\n[{s}]", end="", flush=True)) if self.protocol == "A2A" else None,
+            thread_id=self.agui_thread_id if self.protocol == "AGUI" else None,
+        )
+        stream = (
+            invoke_a2a_streaming(options)
+            if self.protocol == "A2A"
+            else invoke_agui_streaming(options)
+            if self.protocol == "AGUI"
+            else invoke_agent_streaming(options)
+        )
+        content = ""
+        try:
+            for chunk in stream:
+                content += chunk
+                sys.stdout.write(chunk)
+                sys.stdout.flush()
+            sys.stdout.write("\n")
+            if self.logger:
+                self.logger.log("system", f"→ {message}")
+                self.logger.log("response", content)
+        except Exception as err:  # noqa: BLE001
+            if content:
+                sys.stdout.write("\n")
+            raw = str(err) or "Unknown error"
+            show_hint = False
+            if isinstance(err, DevServerError):
+                error_msg = raw or f"Server error ({err.status_code})"
+                show_hint = True
+            elif isinstance(err, DevServerConnectionError):
+                error_msg = "\n".join(self.recent_errors) if self.recent_errors else f"Connection failed: {raw}"
+                show_hint = bool(self.recent_errors)
+            else:
+                error_msg = f"Failed: {raw}"
+            self.add_log("error", f"Failed: {raw}")
+            print(error_msg, file=sys.stderr)
+            if show_hint:
+                print("See logs for full stack trace.", file=sys.stderr)
+
+    def run_spawn(self, args: list[str], label: str, command: str, cwd: str | None = None, env: Any = None) -> None:
+        try:
+            proc = subprocess.run(args, cwd=cwd, env=env, stdin=subprocess.DEVNULL, capture_output=True)
+        except OSError as err:
+            self.add_log("error", f"{label} failed: {err}")
+            print(f"Error: {err}", file=sys.stderr)
+            return
+        output = proc.stdout.decode(errors="replace") + proc.stderr.decode(errors="replace")
+        if proc.returncode > 0:
+            output += f"\n[exit code: {proc.returncode}]"
+        print(output or "(no output)")
+        if self.logger:
+            self.logger.log("system", f"{label}: {command}")
+            self.logger.log("response", output)
+
+    def exec_local(self, command: str) -> None:
+        self.run_spawn(["bash", "-c", command], "exec", command, self.working_dir, {**os.environ, **self.env_vars})
+
+    def exec_container(self, command: str) -> None:
+        runtime = detect_container_runtime()
+        if runtime is None:
+            self.add_log("error", "No container runtime found (docker, podman, or finch required)")
+            return
+        name = f"agentcore-dev-{self.config.agent_name if self.config else ''}".lower()
+        self.run_spawn([runtime.binary, "exec", name, "bash", "-c", command], "container exec", command)
+
+
+def _pick_target(project: Any, agent_name: str | None) -> tuple[str | None, str | None]:
+    """(agent, harness) selection, mirroring DevScreen's select-agent mode."""
+    agents = [a.name for a in get_dev_supported_agents(project)]
+    harnesses = [h.name for h in project.harnesses or []]
+    if agent_name:
+        return agent_name, None
+    if len(agents) == 1 and not harnesses:
+        return agents[0], None
+    if not agents and len(harnesses) == 1:
+        return None, harnesses[0]
+    choices = [interactive.Choice(a, ("agent", a), description="Agent") for a in agents] + [
+        interactive.Choice(h, ("harness", h), description="Harness") for h in harnesses
+    ]
+    kind, name = interactive.select("Select Target" if harnesses else "Select Agent", choices)
+    return (name, None) if kind == "agent" else (None, name)
+
+
+def run_terminal_mode(
+    working_dir: str,
+    port: int,
+    port_explicit: bool,
+    agent_name: str | None,
+    headers: dict[str, str] | None,
+    skip_deploy: bool,
+) -> None:
+    from agentcore.cli.commands.dev._deps import run_cli_deploy
+
+    interactive.require_tty()
+    project = load_project_config(working_dir)
+    if project is None or (not get_dev_supported_agents(project) and not (project.harnesses or [])):
+        typer.secho("No agents or harnesses defined in project.", fg=typer.colors.RED)
+        typer.echo("Dev mode requires at least one agent with an entrypoint or a harness.")
+        typer.echo("Run " + typer.style("agentcore add agent", fg=typer.colors.BLUE) + " to create one.")
+        return
+
+    agent, harness = _pick_target(project, agent_name)
+    if harness:
+        if not skip_deploy:
+            run_cli_deploy()
+        _run_harness_chat(harness, headers)
+        return
+
+    session = _Session(working_dir, port, port_explicit, agent or "", headers)
+    if session.config is None:
+        typer.echo("No dev-supported agents found.", err=True)
+        raise typer.Exit(1)
+    print(f"Agent: {session.config.agent_name}")
+    if session.protocol != "HTTP":
+        print(f"Protocol: {session.protocol}")
+    if not session.start():
+        session.stop()
+        raise typer.Exit(1)
+    print(f"Server: {get_endpoint_url(session.actual_port, session.protocol)}")
+    if session.logger:
+        print(f"Log: {session.logger.get_relative_log_path()}")
+
+    while not session.ready.is_set() and not session.exited.is_set():
+        session.ready.wait(0.25)
+    if session.protocol == "MCP" and session.ready.is_set():
+        session.fetch_mcp_tools()
+        if session.mcp_tools:
+            print(format_mcp_tool_list(session.mcp_tools))
+    if session.protocol == "A2A" and session.ready.is_set():
+        card = fetch_a2a_agent_card(session.actual_port, session.logger)
+        if card:
+            print(f"A2A agent: {card.get('name') or 'unnamed'}")
+
+    is_container = session.config.build_type == "Container"
+    exec_hint = "! exec local · !! exec container" if is_container else "! exec"
+    print(f"Enter to send · {exec_hint} · /restart · /clear · /quit")
+    try:
+        while True:
+            try:
+                line = input("> ")
+            except EOFError:
+                break
+            text = line.strip()
+            if not text:
+                continue
+            if text in ("/quit", "/exit"):
+                break
+            if text == "/restart":
+                session.restart()
+                continue
+            if text == "/clear":
+                session.agui_thread_id = str(uuid.uuid4())
+                print("\x1b[2J\x1b[H", end="")
+                continue
+            if text.startswith("!!") and is_container:
+                session.exec_container(text[2:].strip())
+            elif text.startswith("!"):
+                session.exec_local(text[1:].strip())
+            else:
+                session.invoke(line)
+    except KeyboardInterrupt:
+        print()
+    finally:
+        session.stop()
+
+
+def _run_harness_chat(harness_name: str, headers: dict[str, str] | None = None) -> None:
+    """Harness dev runs against the deployed service: reuse the interactive invoke flow (InvokeScreen)."""
+    from agentcore.cli.commands.invoke.interactive import run_invoke_interactive
+
+    run_invoke_interactive(harness_name=harness_name)

agentcore/cli/commands/exec/__init__.py

@@ -0,0 +1,29 @@
+"""`agentcore exec` (port of src/cli/commands/exec)."""
+
+import typer
+
+from agentcore.cli.commands.exec.action import (
+    ExecContext,
+    handle_exec_one_shot,
+    handle_shell_session,
+    load_exec_context,
+    run_interactive_shell,
+)
+from agentcore.cli.commands.exec.types import ExecOptions, ExecResult
+
+__all__ = [
+    "ExecContext",
+    "ExecOptions",
+    "ExecResult",
+    "handle_exec_one_shot",
+    "handle_shell_session",
+    "load_exec_context",
+    "register",
+    "run_interactive_shell",
+]
+
+
+def register(app: typer.Typer) -> None:
+    from agentcore.cli.commands.exec.command import register_exec
+
+    register_exec(app)