agentcore-cli 0.31.1__py3-none-any.whl

agentcore/cli/commands/exec/action.py

@@ -0,0 +1,442 @@
+"""Port of commands/exec/action.ts: one-shot and interactive (PTY over WebSocket) exec."""
+
+import os
+import queue
+import select
+import shutil
+import signal
+import sys
+import threading
+import time
+import uuid
+from dataclasses import dataclass
+from typing import Any
+
+from agentcore.aws.agentcore import ExecuteBashOptions, execute_bash_command
+from agentcore.aws.arn import region_from_arn
+from agentcore.aws.connect_shell import ShellReconnectOptions, connect_shell, start_keepalive
+from agentcore.aws.shell_framer import ShellChannel, ShellFramer, parse_status_frame
+from agentcore.cli.commands.exec.types import ExecOptions, ExecResult
+from agentcore.lib.schemas.io.config_io import ConfigIO
+
+
+@dataclass
+class ExecContext:
+    region: str
+    runtime_arn: str
+
+
+def _is_harness_arn(arn: str) -> bool:
+    return ":harness/" in arn
+
+
+def _assert_interactive_harness_unsupported(options: ExecOptions, ctx: ExecContext) -> ExecContext:
+    """The data plane rejects interactive shells on harness-linked runtimes; one-shot exec works."""
+    if options.interactive and _is_harness_arn(ctx.runtime_arn):
+        raise RuntimeError(
+            "Interactive shell (--it) is not supported for harness deployments yet. "
+            'Use one-shot exec instead, e.g. `agentcore exec "<command>"`.'
+        )
+    return ctx
+
+
+def _harness_arn_error(value: str) -> RuntimeError:
+    return RuntimeError(
+        f"--harness expects a harness ARN (…:harness/…), got '{value}'. Use --runtime for a runtime ARN."
+    )
+
+
+def load_exec_context(options: ExecOptions, config_io: ConfigIO | None = None) -> ExecContext:
+    """Resolve region + target ARN. A full ARN needs no project; a name is looked up in deployed state."""
+    if options.runtime_arn and options.harness_name:
+        raise RuntimeError("Cannot specify both --runtime and --harness.")
+
+    if options.runtime_arn and options.runtime_arn.startswith("arn:"):
+        region = options.region or region_from_arn(options.runtime_arn)
+        if region:
+            return _assert_interactive_harness_unsupported(options, ExecContext(region, options.runtime_arn))
+
+    if options.harness_name and options.harness_name.startswith("arn:"):
+        if not _is_harness_arn(options.harness_name):
+            raise _harness_arn_error(options.harness_name)
+        region = options.region or region_from_arn(options.harness_name)
+        if region:
+            return _assert_interactive_harness_unsupported(options, ExecContext(region, options.harness_name))
+
+    config_io = config_io or ConfigIO()
+    aws_targets = config_io.read_aws_deployment_targets()
+    deployed_state = config_io.read_deployed_state()
+
+    targets = deployed_state.targets or {}
+    target_names = list(targets)
+    if not target_names:
+        raise RuntimeError("No deployed targets found. Run `agentcore deploy` first.")
+    if options.target_name and options.target_name not in target_names:
+        raise RuntimeError(
+            f"Deployment target '{options.target_name}' not found. Available targets: {', '.join(target_names)}"
+        )
+    target_name = options.target_name or target_names[0]
+    target_config = next((t for t in aws_targets if t.name == target_name), None)
+    if target_config is None:
+        raise RuntimeError(f"Deployment target config '{target_name}' not found in aws-targets.")
+
+    target_state = targets.get(target_name)
+    resources = target_state.resources if target_state else None
+    runtimes = (resources.runtimes if resources else None) or {}
+    harnesses = (resources.harnesses if resources else None) or {}
+    region = options.region or target_config.region
+
+    if options.runtime_arn and options.runtime_arn.startswith("arn:"):
+        return _assert_interactive_harness_unsupported(options, ExecContext(region, options.runtime_arn))
+
+    if options.harness_name:
+        if options.harness_name.startswith("arn:"):
+            if not _is_harness_arn(options.harness_name):
+                raise _harness_arn_error(options.harness_name)
+            return _assert_interactive_harness_unsupported(options, ExecContext(region, options.harness_name))
+        harness_state = harnesses.get(options.harness_name)
+        if not harness_state:
+            raise RuntimeError(
+                f"Harness '{options.harness_name}' not found in target '{target_name}'. "
+                f"Available harnesses: {', '.join(harnesses)}"
+            )
+        return _assert_interactive_harness_unsupported(options, ExecContext(region, harness_state.harness_arn))
+
+    if options.runtime_arn:
+        agent_state = runtimes.get(options.runtime_arn)
+        if not agent_state or not agent_state.runtime_arn:
+            raise RuntimeError(
+                f"Agent '{options.runtime_arn}' not found in target '{target_name}'. "
+                f"Available agents: {', '.join(runtimes)}"
+            )
+        return _assert_interactive_harness_unsupported(options, ExecContext(region, agent_state.runtime_arn))
+
+    candidates = [r.runtime_arn for r in runtimes.values()] + [h.harness_arn for h in harnesses.values()]
+    candidates = [c for c in candidates if c]
+    if not candidates:
+        raise RuntimeError(f"No deployed runtimes or harnesses found in target '{target_name}'.")
+    if len(candidates) > 1:
+        raise RuntimeError(
+            f"Target '{target_name}' has multiple deploy targets. Specify one with --runtime <name> or "
+            f"--harness <name>: " + ", ".join([*runtimes, *harnesses])
+        )
+    return _assert_interactive_harness_unsupported(options, ExecContext(region, candidates[0]))
+
+
+# ---------------------------------------------------------------------------
+# One-shot exec
+# ---------------------------------------------------------------------------
+
+_DONE = object()
+
+
+def _write(stream: Any, text: str) -> None:
+    stream.write(text)
+    stream.flush()
+
+
+def handle_exec_one_shot(ctx: ExecContext, options: ExecOptions) -> ExecResult:
+    command = " ".join(options.command or [])
+    if not command:
+        return ExecResult(False, error=RuntimeError("No command provided for one-shot exec."))
+
+    stdout_buf = ""
+    stderr_buf = ""
+    timeout_sec = options.timeout if options.timeout is not None and options.timeout > 0 else None
+    exit_code: int | None = None
+    timed_out = ExecResult(
+        False, error=RuntimeError(f"Command timed out after {timeout_sec}s"), session_id=options.session_id
+    )
+
+    try:
+        executed = execute_bash_command(
+            ExecuteBashOptions(
+                region=ctx.region,
+                runtime_arn=ctx.runtime_arn,
+                command=command,
+                session_id=options.session_id,
+                timeout=timeout_sec,
+            )
+        )
+
+        # Client-side wall-clock timeout: pull events on a worker thread and race against the deadline,
+        # so the timeout fires even when the stream is blocked with no events.
+        events: queue.Queue[Any] = queue.Queue()
+
+        def pump() -> None:
+            try:
+                for ev in executed.stream:
+                    events.put(ev)
+                events.put(_DONE)
+            except BaseException as exc:  # noqa: BLE001 - forwarded to the consumer
+                events.put(exc)
+
+        threading.Thread(target=pump, name="agentcore-exec-stream", daemon=True).start()
+        deadline = None
+        if timeout_sec is not None:
+            deadline = time.monotonic() + timeout_sec
+
+        while True:
+            if deadline is not None:
+                remaining = deadline - time.monotonic()
+                if remaining <= 0:
+                    return timed_out
+                try:
+                    event = events.get(timeout=remaining)
+                except queue.Empty:
+                    return timed_out
+            else:
+                event = events.get()
+            if event is _DONE:
+                break
+            if isinstance(event, BaseException):
+                raise event
+            kind = event.get("type")
+            if kind == "stdout" and event.get("data"):
+                stdout_buf += event["data"]
+                if not options.json:
+                    _write(sys.stdout, event["data"])
+            elif kind == "stderr" and event.get("data"):
+                stderr_buf += event["data"]
+                if not options.json:
+                    _write(sys.stderr, event["data"])
+            elif kind == "stop":
+                exit_code = event.get("exitCode")
+                # Server-side timeout: status TIMED_OUT, or exit -1 when a timeout was set.
+                if event.get("status") == "TIMED_OUT" or (exit_code == -1 and timeout_sec is not None):
+                    return timed_out
+    except Exception as exc:  # noqa: BLE001
+        return ExecResult(False, error=exc)
+
+    if exit_code is None:
+        return ExecResult(False, error=RuntimeError("Command stream ended without exit code"))
+    if exit_code != 0:
+        return ExecResult(
+            False,
+            error=RuntimeError(f"Command exited with code {exit_code}"),
+            exit_code=exit_code,
+            stdout=stdout_buf,
+            stderr=stderr_buf,
+            session_id=options.session_id,
+        )
+    return ExecResult(True, exit_code=exit_code, stdout=stdout_buf, stderr=stderr_buf, session_id=options.session_id)
+
+
+# ---------------------------------------------------------------------------
+# Interactive PTY session
+# ---------------------------------------------------------------------------
+
+
+class _RawTerminal:
+    """Put stdin into raw mode (keystrokes forwarded byte-for-byte) and restore it afterwards."""
+
+    def __init__(self) -> None:
+        self._saved: Any = None
+        self.fd: int | None = None
+        try:
+            self.fd = sys.stdin.fileno()
+        except (AttributeError, ValueError, OSError):
+            self.fd = None
+
+    def __enter__(self) -> "_RawTerminal":
+        if self.fd is not None and os.isatty(self.fd):
+            import termios
+            import tty
+
+            self._saved = termios.tcgetattr(self.fd)
+            tty.setraw(self.fd)
+        return self
+
+    def __exit__(self, *exc: object) -> None:
+        if self._saved is not None and self.fd is not None:
+            import termios
+
+            termios.tcsetattr(self.fd, termios.TCSADRAIN, self._saved)
+
+
+def _close_code(ws: Any) -> int | None:
+    code = getattr(ws, "close_code", None)
+    if code is None:
+        protocol = getattr(ws, "protocol", None)
+        code = getattr(protocol, "close_code", None)
+    return code
+
+
+def handle_shell_session(ctx: ExecContext, options: ExecOptions) -> ExecResult:
+    """Open an interactive PTY shell against a running runtime container."""
+    session_id = options.session_id or str(uuid.uuid4())
+    _write(sys.stderr, "Connecting to agent VM...\n")
+
+    state = {"reconnect_attempts": 0, "was_kicked": False}
+
+    def on_attempt(attempt: int, reason: str) -> None:
+        state["reconnect_attempts"] = attempt
+        _write(sys.stderr, f"\r\n[disconnected · {reason} · reconnecting ({attempt}/5)...]\r\n")
+
+    def on_kicked() -> None:
+        state["was_kicked"] = True
+        _write(sys.stderr, "\r\n[session attached from another client · not reconnecting]\r\n")
+
+    try:
+        conn = connect_shell(
+            region=ctx.region,
+            runtime_arn=ctx.runtime_arn,
+            session_id=session_id,
+            shell_id=options.shell_id,
+            bearer_token=options.bearer_token,
+            headers={"baggage": options.baggage} if options.baggage else None,
+            reconnect=ShellReconnectOptions(on_attempt=on_attempt, on_kicked=on_kicked),
+        )
+    except Exception as exc:  # noqa: BLE001
+        return ExecResult(False, error=exc)
+
+    framer = ShellFramer()
+    ws, shell_id = conn.ws, conn.shell_id
+    exit_code: int | None = None
+    detached = threading.Event()
+    stop_reading = threading.Event()
+    errored: list[BaseException] = []
+
+    _write(sys.stderr, f"[connected · session {session_id} · Ctrl+D or 'exit' to quit · Ctrl+] to detach]\n")
+
+    def terminate() -> None:
+        try:
+            ws.close(code=4001)
+        except Exception:  # noqa: BLE001, S110
+            pass
+
+    stop_keepalive = start_keepalive(ws, terminate)
+
+    def send_resize(*_: object) -> None:
+        size = shutil.get_terminal_size((80, 24))
+        try:
+            ws.send(framer.encode_resize(size.columns, size.lines))
+        except Exception:  # noqa: BLE001, S110 - socket not open
+            pass
+
+    def stdin_loop(fd: int) -> None:
+        while not stop_reading.is_set():
+            try:
+                ready, _, _ = select.select([fd], [], [], 0.1)
+            except (OSError, ValueError):
+                return
+            if not ready:
+                continue
+            try:
+                buf = os.read(fd, 4096)
+            except OSError:
+                return
+            if not buf:
+                return
+            if buf == b"\x1d":  # Ctrl+] detaches without killing the remote shell
+                detached.set()
+                _write(sys.stderr, "\n[detached]\n")
+                try:
+                    ws.close()
+                except Exception:  # noqa: BLE001, S110
+                    pass
+                return
+            try:
+                ws.send(framer.encode_stdin_raw(buf))
+            except Exception:  # noqa: BLE001
+                return
+
+    previous_winch = None
+    with _RawTerminal() as term:
+        if hasattr(signal, "SIGWINCH") and threading.current_thread() is threading.main_thread():
+            previous_winch = signal.signal(signal.SIGWINCH, send_resize)
+        send_resize()
+        reader = None
+        if term.fd is not None:
+            reader = threading.Thread(target=stdin_loop, args=(term.fd,), name="agentcore-shell-stdin", daemon=True)
+            reader.start()
+        try:
+            while True:
+                try:
+                    data = ws.recv()
+                except Exception as exc:  # noqa: BLE001 - ConnectionClosed ends the loop
+                    if type(exc).__name__ not in ("ConnectionClosedOK", "ConnectionClosedError", "ConnectionClosed"):
+                        errored.append(exc)
+                    break
+                raw = data if isinstance(data, (bytes, bytearray)) else str(data).encode("utf-8")
+                try:
+                    frame = framer.decode(bytes(raw))
+                except ValueError:
+                    continue
+                if frame.channel == ShellChannel.STDOUT:
+                    sys.stdout.buffer.write(frame.payload)
+                    sys.stdout.buffer.flush()
+                elif frame.channel == ShellChannel.STDERR:
+                    sys.stderr.buffer.write(frame.payload)
+                    sys.stderr.buffer.flush()
+                elif frame.channel == ShellChannel.STATUS:
+                    parsed = parse_status_frame(frame)
+                    if parsed["type"] == "termination":
+                        exit_code = parsed["exitCode"]
+                        ws.close()
+                elif frame.channel == ShellChannel.CLOSE:
+                    ws.close()
+        finally:
+            stop_reading.set()
+            if reader is not None:
+                reader.join(timeout=1)
+            stop_keepalive()
+            if previous_winch is not None:
+                signal.signal(signal.SIGWINCH, previous_winch)
+
+    transport_failure = False
+    if errored:
+        _write(sys.stderr, f"\n[shell error: {errored[0]}]\n")
+        code: int | None = exit_code if exit_code is not None else 1
+    elif exit_code is not None:
+        code = exit_code
+    else:
+        close = _close_code(ws)
+        if close == 1000 or (close is None and detached.is_set()):
+            code = 0
+        elif close == 4000:
+            code = None
+        else:
+            code = None
+            transport_failure = True
+
+    is_detached = detached.is_set()
+    if shell_id and (is_detached or code is None):
+        if not is_detached:
+            _write(sys.stderr, "\n[disconnected]\n")
+        _write(
+            sys.stderr,
+            "[to reconnect:]\n"
+            "  agentcore exec --it \\\n"
+            f"    --runtime {ctx.runtime_arn} \\\n"
+            f"    --region {ctx.region} \\\n"
+            f"    --session-id {session_id} \\\n"
+            f"    --shell-id {shell_id}\n",
+        )
+    if code is not None and not is_detached:
+        _write(sys.stderr, f"\n[session closed · exit {code}]\n")
+
+    meta: dict[str, Any] = {
+        "session_id": session_id,
+        "shell_id": shell_id,
+        "exit_code": code,
+        "reconnect_attempts": state["reconnect_attempts"],
+        "was_kicked": state["was_kicked"],
+        "detached": is_detached,
+    }
+    if transport_failure:
+        return ExecResult(
+            False,
+            error=RuntimeError("Shell connection closed unexpectedly before the shell reported an exit status"),
+            **meta,
+        )
+    if code is None or code == 0 or code >= 128:
+        return ExecResult(True, **meta)
+    return ExecResult(False, error=RuntimeError(f"Shell exited with code {code}"), **meta)
+
+
+def run_interactive_shell(options: ExecOptions) -> None:
+    ctx = load_exec_context(options)
+    res = handle_shell_session(ctx, options)
+    if not res.success:
+        raise res.error or RuntimeError("exec failed")

agentcore/cli/commands/exec/command.py

@@ -0,0 +1,206 @@
+"""`agentcore exec` (port of commands/exec/command.tsx)."""
+
+import json
+import sys
+from dataclasses import dataclass, replace
+
+import typer
+
+from agentcore.cli import interactive
+from agentcore.cli.commands.exec.action import (
+    handle_exec_one_shot,
+    handle_shell_session,
+    load_exec_context,
+    run_interactive_shell,
+)
+from agentcore.cli.commands.exec.types import ExecOptions, ExecResult
+from agentcore.cli.commands.invoke.constants import ANSI, EXEC_DESCRIPTION
+from agentcore.cli.commands.invoke.guards import require_project
+from agentcore.cli.errors import get_error_message
+from agentcore.lib.schemas.io.config_io import ConfigIO
+from agentcore.lib.schemas.io.path_resolver import find_config_root
+
+
+def _print_exec_result(res: ExecResult, as_json: bool) -> None:
+    if as_json:
+        payload = {
+            "success": res.success,
+            "exitCode": res.exit_code,
+            "stdout": res.stdout or "",
+            "stderr": res.stderr or "",
+        }
+        typer.echo(
+            json.dumps({k: v for k, v in payload.items() if v is not None}, separators=(",", ":"), ensure_ascii=False)
+        )
+    elif not res.success and res.error is not None:
+        typer.echo(f"Error: {res.error}", err=True)
+
+
+@dataclass
+class PickResult:
+    runtime_arn: str
+    session_id: str | None = None
+    auto_selected: bool = False
+
+
+def pick_agent() -> PickResult | None:
+    """Prompt replacement for the ExecScreen picker. Returns None when the user backs out."""
+    try:
+        config_io = ConfigIO()
+        project = config_io.read_project_spec()
+        deployed_state = config_io.read_deployed_state()
+        target_names = list(deployed_state.targets or {})
+        if not target_names:
+            raise RuntimeError("No deployed targets found. Run `agentcore deploy` first.")
+        target_state = deployed_state.targets[target_names[0]]
+        resources = target_state.resources if target_state else None
+        loaded: list[interactive.Choice] = []
+        for agent in project.runtimes or []:
+            state = ((resources.runtimes if resources else None) or {}).get(agent.name)
+            if state and state.runtime_arn:
+                loaded.append(interactive.Choice(agent.name, state.runtime_arn))
+        # exec targets the harness ARN (not agentRuntimeArn) for harnesses.
+        for harness in project.harnesses or []:
+            state = ((resources.harnesses if resources else None) or {}).get(harness.name)
+            if state and state.harness_arn:
+                loaded.append(interactive.Choice(harness.name, state.harness_arn, "harness"))
+        if not loaded:
+            raise RuntimeError("No deployed agents or harnesses found. Run `agentcore deploy` first.")
+    except Exception as exc:  # noqa: BLE001 - shown as the picker's error state upstream
+        typer.echo(f"{ANSI.red}{get_error_message(exc)}{ANSI.reset}")
+        return None
+
+    if len(loaded) == 1:
+        return PickResult(loaded[0].value, auto_selected=True)
+    try:
+        arn = interactive.select("Select Agent to Shell Into", loaded)
+    except typer.Exit:
+        return None
+    return PickResult(arn)
+
+
+def run_exec_loop(options: ExecOptions | None = None) -> None:
+    """Picker loop: pick agent -> PTY -> back to the picker (or quit)."""
+    options = options or ExecOptions()
+    while True:
+        picked = pick_agent()
+        if picked is None:
+            break
+        shell_options = replace(options, interactive=True, runtime_arn=picked.runtime_arn, session_id=picked.session_id)
+        session_error: BaseException | None = None
+        try:
+            ctx = load_exec_context(shell_options)
+            res = handle_shell_session(ctx, shell_options)
+            if not res.success and res.error is not None:
+                session_error = res.error
+        except Exception as exc:  # noqa: BLE001
+            session_error = exc
+        if picked.auto_selected:
+            if session_error is not None:
+                raise session_error
+            break
+        sys.stdout.write("\x1b[2J\x1b[H")
+        sys.stdout.flush()
+
+
+def exec_command(
+    command_args: list[str] | None = typer.Argument(
+        None, metavar="[COMMAND...]", help="Command to execute (one-shot mode, non-interactive)", show_default=False
+    ),
+    it: bool = typer.Option(False, "--it", help="Open an interactive PTY shell session"),
+    runtime: str | None = typer.Option(
+        None, "--runtime", metavar="NAME|ARN", help="Target agent name or runtime ARN (skips agent picker)"
+    ),
+    harness: str | None = typer.Option(
+        None, "--harness", metavar="NAME|ARN", help="Target harness name or harness ARN (skips agent picker)"
+    ),
+    session_id: str | None = typer.Option(None, "--session-id", help="Pin to a specific runtime session / VM"),
+    shell_id: str | None = typer.Option(None, "--shell-id", help="Reconnect to an existing shell"),
+    region: str | None = typer.Option(None, "--region", help="AWS region"),
+    bearer_token: str | None = typer.Option(
+        None, "--bearer-token", help="Bearer token for CUSTOM_JWT authentication (skips SigV4)"
+    ),
+    target: str | None = typer.Option(None, "--target", help="Deployment target name (from agentcore.json)"),
+    timeout: int | None = typer.Option(None, "--timeout", help="Timeout in seconds for one-shot commands"),
+    as_json: bool = typer.Option(
+        False, "--json", help="Output result as JSON (one-shot mode only, incompatible with --it)"
+    ),
+) -> None:
+    try:
+        # A full ARN needs no project; a name-based --runtime/--harness still does.
+        has_arn_target = bool(runtime and runtime.startswith("arn:")) or bool(harness and harness.startswith("arn:"))
+        if not has_arn_target:
+            if as_json:
+                if not find_config_root():
+                    typer.echo(
+                        json.dumps({"success": False, "error": "No agentcore project found."}, separators=(",", ":"))
+                    )
+                    raise typer.Exit(1)
+            else:
+                require_project()
+
+        if it and as_json:
+            typer.echo("Error: --json cannot be used with --it (PTY sessions are not JSON-serializable)", err=True)
+            raise typer.Exit(1)
+        if it and timeout is not None:
+            typer.echo("Error: --timeout cannot be used with --it (timeouts apply to one-shot commands only)", err=True)
+            raise typer.Exit(1)
+        if not it and bearer_token:
+            typer.echo(
+                "Error: --bearer-token is only supported with --it (bearer token auth is not supported for one-shot "
+                "commands)",
+                err=True,
+            )
+            raise typer.Exit(1)
+        if timeout is not None and timeout < 0:
+            typer.echo("Error: --timeout must be a non-negative integer (seconds)", err=True)
+            raise typer.Exit(1)
+        if session_id is not None and (len(session_id) < 33 or len(session_id) > 256):
+            typer.echo("Error: --session-id must be between 33 and 256 characters", err=True)
+            raise typer.Exit(1)
+
+        options = ExecOptions(
+            runtime_arn=runtime,
+            harness_name=harness,
+            session_id=session_id,
+            shell_id=shell_id,
+            interactive=it or None,
+            command=list(command_args) if command_args else None,
+            region=region,
+            bearer_token=bearer_token,
+            target_name=target,
+            timeout=timeout,
+            json=as_json or None,
+        )
+
+        if not options.interactive:
+            if not options.command:
+                typer.echo(
+                    "Usage:\n  agentcore exec <command>          one-shot\n  agentcore exec --it                 "
+                    "interactive shell",
+                    err=True,
+                )
+                raise typer.Exit(1)
+            ctx = load_exec_context(options)
+            res = handle_exec_one_shot(ctx, options)
+            _print_exec_result(res, as_json)
+            raise typer.Exit(res.exit_code if res.exit_code is not None else (0 if res.success else 1))
+
+        interactive.require_tty()
+        if options.runtime_arn or options.harness_name:
+            run_interactive_shell(options)
+            raise typer.Exit(0)
+        run_exec_loop(options)
+        raise typer.Exit(0)
+    except typer.Exit:
+        raise
+    except Exception as exc:  # noqa: BLE001 - top-level command boundary, as upstream
+        if as_json:
+            typer.echo(json.dumps({"success": False, "error": get_error_message(exc)}, separators=(",", ":")))
+        else:
+            typer.echo(get_error_message(exc), err=True)
+        raise typer.Exit(1) from None
+
+
+def register_exec(app: typer.Typer) -> None:
+    app.command("exec", help=EXEC_DESCRIPTION)(exec_command)

agentcore/cli/commands/exec/types.py

@@ -0,0 +1,35 @@
+"""Port of commands/exec/types.ts."""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class ExecOptions:
+    runtime_arn: str | None = None
+    """--runtime: agent name or full runtime ARN. Skips the agent picker."""
+    harness_name: str | None = None
+    """--harness: harness name or harness ARN. Skips the agent picker."""
+    session_id: str | None = None
+    shell_id: str | None = None
+    interactive: bool | None = None
+    command: list[str] | None = None
+    region: str | None = None
+    bearer_token: str | None = None
+    target_name: str | None = None
+    baggage: str | None = None
+    timeout: int | None = None
+    json: bool | None = None
+
+
+@dataclass
+class ExecResult:
+    success: bool
+    error: Exception | None = None
+    session_id: str | None = None
+    shell_id: str | None = None
+    exit_code: int | None = None
+    reconnect_attempts: int | None = None
+    was_kicked: bool | None = None
+    detached: bool | None = None
+    stdout: str | None = None
+    stderr: str | None = None