agentcore-cli 0.31.1__py3-none-any.whl

agentcore/cli/commands/import_/import_online_eval.py

@@ -0,0 +1,165 @@
+"""`agentcore import online-eval` (port of commands/import/import-online-eval.ts)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import typer
+
+from agentcore.aws import agentcore_control
+from agentcore.aws.partition import arn_prefix
+from agentcore.cli.constants import ANSI
+from agentcore.lib.errors.types import ValidationError
+from agentcore.lib.result import Err, Ok
+
+from .import_runtime import print_failure, print_success
+from .import_utils import ImportedResource, fail_result, find_resource_in_deployed_state, parse_and_validate_arn
+from .resource_import import execute_resource_import
+from .types import BeforeWriteContext, ImportResourceOptions, ImportResourceResult, ResourceImportDescriptor
+
+
+def extract_agent_name(service_names: list[str]) -> str | None:
+    """Agent name from service names of the form ``{agentName}.DEFAULT``."""
+    if not service_names:
+        return None
+    name = service_names[0]
+    dot = name.rfind(".")
+    return name if dot == -1 else name[:dot]
+
+
+def to_online_eval_config_spec(
+    detail: dict[str, Any], local_name: str, agent_name: str, evaluator_arns: list[str]
+) -> Ok[dict[str, Any]] | Err[Exception]:
+    if detail.get("samplingPercentage") is None:
+        return Err(
+            ValidationError(
+                f'Online eval config "{detail.get("configName")}" has no sampling configuration. Cannot import.'
+            )
+        )
+    config: dict[str, Any] = {
+        "name": local_name,
+        "agent": agent_name,
+        "evaluators": evaluator_arns,
+        "samplingRate": detail["samplingPercentage"],
+    }
+    if detail.get("description"):
+        config["description"] = detail["description"]
+    if detail.get("executionStatus") == "ENABLED":
+        config["enableOnCreate"] = True
+    return Ok({"config": config})
+
+
+def build_evaluator_arns(evaluator_ids: list[str], region: str, account: str) -> list[str]:
+    return [f"{arn_prefix(region)}:bedrock-agentcore:{region}:{account}:evaluator/{i}" for i in evaluator_ids]
+
+
+def create_online_eval_descriptor() -> ResourceImportDescriptor[Any, Any]:
+    state: dict[str, Any] = {"agent": "", "evaluators": []}
+
+    def add(detail: Any, local_name: str, spec: dict[str, Any]) -> ImportResourceResult:
+        result = to_online_eval_config_spec(detail, local_name, state["agent"], state["evaluators"])
+        if not result.success:
+            return ImportResourceResult(
+                success=False, error=result.error, resource_type="online-eval", resource_name=local_name
+            )
+        spec.setdefault("onlineEvalConfigs", []).append(result.value["config"])
+        return ImportResourceResult(success=True, resource_type="online-eval", resource_name=local_name)
+
+    def before_write(c: BeforeWriteContext[Any]) -> ImportResourceResult | None:
+        c.logger.start_step("Resolve references")
+        aws_agent = extract_agent_name(c.detail.get("serviceNames") or [])
+        if not aws_agent:
+            return fail_result(
+                c.logger,
+                "Could not determine agent name from online eval config. The config has no data source service names.",
+                "online-eval",
+                c.local_name,
+            )
+        names = {r["name"] for r in c.project_spec.get("runtimes") or []}
+        agent: str | None = None
+        if aws_agent in names:
+            agent = aws_agent
+        else:
+            prefix = f"{c.ctx.project_name}_"
+            if aws_agent.startswith(prefix) and aws_agent[len(prefix) :] in names:
+                agent = aws_agent[len(prefix) :]
+
+        if not agent:
+            c.on_progress(f'Agent "{aws_agent}" not found by name, checking deployed state...')
+            runtimes = agentcore_control.list_all_agent_runtimes(region=c.target["region"])
+            match = next((r for r in runtimes if r["agentRuntimeName"] == aws_agent), None)
+            if match:
+                local = find_resource_in_deployed_state(
+                    c.ctx.config_io, c.target.get("name") or "default", "runtime", match["agentRuntimeId"]
+                )
+                if local and local in names:
+                    agent = local
+                    c.on_progress(f'Resolved AWS runtime "{aws_agent}" to local name "{agent}"')
+
+        if not agent:
+            return fail_result(
+                c.logger,
+                f'Online eval config references agent "{aws_agent}" which is not in this project. Import or add the '
+                "agent first with `agentcore import runtime` or `agentcore add agent`.",
+                "online-eval",
+                c.local_name,
+            )
+
+        evaluator_ids = c.detail.get("evaluatorIds") or []
+        if not evaluator_ids:
+            return fail_result(
+                c.logger, "Online eval config has no evaluators configured. Cannot import.", "online-eval", c.local_name
+            )
+        state["evaluators"] = build_evaluator_arns(evaluator_ids, c.target["region"], c.target["account"])
+        state["agent"] = agent
+        c.on_progress(f"Agent: {agent}, Evaluators: {', '.join(state['evaluators'])}")
+        c.logger.end_step("success")
+        return None
+
+    return ResourceImportDescriptor(
+        resource_type="online-eval",
+        display_name="online eval config",
+        log_command="import-online-eval",
+        list_resources=lambda region: agentcore_control.list_all_online_evaluation_configs(region=region),
+        get_detail=lambda region, cid: agentcore_control.get_online_evaluation_config(region=region, config_id=cid),
+        parse_resource_id=lambda arn, target: parse_and_validate_arn(arn, "online-eval", target).resource_id,
+        extract_summary_id=lambda s: s["onlineEvaluationConfigId"],
+        format_list_item=lambda s, i: (
+            f"  {ANSI.dim}[{i + 1}]{ANSI.reset} {s['onlineEvaluationConfigName']} — {s['status']} "
+            f"({s['executionStatus']})\n       {ANSI.dim}{s['onlineEvaluationConfigArn']}{ANSI.reset}"
+        ),
+        format_auto_select_message=lambda s: (
+            f"Found 1 config: {s['onlineEvaluationConfigName']} ({s['onlineEvaluationConfigId']}). Auto-selecting."
+        ),
+        extract_detail_name=lambda d: d["configName"],
+        extract_detail_arn=lambda d: d["configArn"],
+        ready_status="ACTIVE",
+        extract_detail_status=lambda d: d["status"],
+        get_existing_names=lambda spec: [c["name"] for c in spec.get("onlineEvalConfigs") or []],
+        add_to_project_spec=add,
+        cfn_resource_type="AWS::BedrockAgentCore::OnlineEvaluationConfig",
+        cfn_name_property="OnlineEvaluationConfigName",
+        cfn_identifier_key="OnlineEvaluationConfigId",
+        build_deployed_state_entry=lambda name, cid, d: ImportedResource("online-eval", name, cid, d["configArn"]),
+        before_config_write=before_write,
+    )
+
+
+def handle_import_online_eval(options: ImportResourceOptions) -> ImportResourceResult:
+    return execute_resource_import(create_online_eval_descriptor(), options)
+
+
+def register_import_online_eval(import_app: typer.Typer) -> None:
+    @import_app.command(
+        "online-eval", help="Import an existing AgentCore Online Evaluation Config from your AWS account"
+    )
+    def import_online_eval(
+        arn: str | None = typer.Option(None, "--arn", help="Online evaluation config ARN to import"),
+        name: str | None = typer.Option(None, "--name", help="Local name for the imported online eval config"),
+        yes: bool = typer.Option(False, "-y", "--yes", help="Auto-confirm prompts"),
+    ) -> None:
+        result = handle_import_online_eval(ImportResourceOptions(arn=arn, name=name, yes=yes or None))
+        if result.success:
+            print_success("Online eval config", result, [])
+        else:
+            print_failure(result)

agentcore/cli/commands/import_/import_pipeline.py

@@ -0,0 +1,145 @@
+"""Shared CDK import pipeline (port of commands/import/import-pipeline.ts).
+
+build -> synth -> bootstrap -> publish assets -> phase 1 -> phase 2 -> update deployed state.
+
+The CDK build/synth/bootstrap steps belong to the deploy area; they are reached through the small
+:class:`CdkDriver` interface (default: :class:`DeployCdkDriver`, backed by
+``agentcore.operations.deploy.preflight``) so tests and future refactors can swap it.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any, Protocol
+
+from . import phase1_update, phase2_import
+from .import_utils import ImportedResource, update_deployed_state
+from .template_utils import CfnTemplate
+from .types import ResourceToImport
+
+
+class CdkSynthSession(Protocol):
+    assembly_directory: str
+
+    def bootstrap_if_needed(self, target: dict[str, Any], on_progress: Callable[[str], None]) -> None: ...
+
+    def dispose(self) -> None: ...
+
+
+class CdkDriver(Protocol):
+    def build_and_synth(self, project_root: str) -> CdkSynthSession: ...
+
+
+class _DeploySynthSession:
+    def __init__(self, wrapper: Any, assembly_directory: str) -> None:
+        self._wrapper = wrapper
+        self.assembly_directory = assembly_directory
+
+    def bootstrap_if_needed(self, target: dict[str, Any], on_progress: Callable[[str], None]) -> None:
+        from types import SimpleNamespace
+
+        from agentcore.operations.deploy.preflight import bootstrap_environment, check_bootstrap_needed
+
+        ns = SimpleNamespace(**target)
+        if check_bootstrap_needed([ns]).needs_bootstrap:
+            on_progress("Bootstrapping AWS environment...")
+            bootstrap_environment(self._wrapper, ns)
+            on_progress("CDK bootstrap complete")
+
+    def dispose(self) -> None:
+        self._wrapper.dispose()
+
+
+class DeployCdkDriver:
+    """Default driver backed by the deploy area's preflight helpers.
+
+    Calls buildCdkProject / synthesizeCdk / checkBootstrapNeeded / bootstrapEnvironment from
+    operations/deploy through this adapter so tests can swap in a fake.
+    """
+
+    def build_and_synth(self, project_root: str) -> CdkSynthSession:
+        from agentcore.cdk.local_cdk_project import LocalCdkProject
+        from agentcore.cdk.toolkit import silent_io_host
+        from agentcore.operations.deploy.preflight import build_cdk_project, synthesize_cdk
+
+        project = LocalCdkProject(project_root)
+        build_cdk_project(project)
+        synth = synthesize_cdk(project, io_host=silent_io_host)
+        info = synth.toolkit_wrapper.synth()
+        return _DeploySynthSession(synth.toolkit_wrapper, info.assembly_directory)
+
+
+# Module-level so tests can replace it.
+cdk_driver: CdkDriver = DeployCdkDriver()
+
+
+@dataclass
+class CdkImportPipelineResult:
+    success: bool
+    error: str | None = None
+    no_resources: bool = False
+    """True when build_resources_to_import returned nothing; callers decide whether that is an error."""
+
+
+def execute_cdk_import_pipeline(
+    project_root: str,
+    stack_name: str,
+    target: dict[str, Any],
+    config_io: Any,
+    target_name: str,
+    on_progress: Callable[[str], None],
+    build_resources_to_import: Callable[[CfnTemplate, CfnTemplate], list[ResourceToImport]],
+    deployed_state_entries: list[ImportedResource],
+) -> CdkImportPipelineResult:
+    on_progress("Building CDK project...")
+    on_progress("Synthesizing CloudFormation template...")
+    session = cdk_driver.build_and_synth(project_root)
+    assembly = session.assembly_directory
+
+    synth_path = os.path.join(assembly, f"{stack_name}.template.json")
+    try:
+        with open(synth_path, encoding="utf-8") as fh:
+            synth_template: CfnTemplate = json.load(fh)
+    except (OSError, ValueError):
+        files = [f for f in os.listdir(assembly) if f.endswith(".template.json")]
+        if not files:
+            session.dispose()
+            return CdkImportPipelineResult(False, "No CloudFormation template found in CDK assembly")
+        with open(os.path.join(assembly, files[0]), encoding="utf-8") as fh:
+            synth_template = json.load(fh)
+
+    on_progress("Checking CDK bootstrap status...")
+    session.bootstrap_if_needed(target, on_progress)
+    session.dispose()
+
+    on_progress("Publishing CDK assets to S3...")
+    phase2_import.publish_cdk_assets(assembly, target["region"], on_progress)
+
+    on_progress("Phase 1: Deploying companion resources (IAM roles, policies)...")
+    phase1 = phase1_update.execute_phase1(target["region"], stack_name, synth_template, on_progress)
+    if not phase1.success:
+        return CdkImportPipelineResult(False, f"Phase 1 failed: {phase1.error}")
+
+    on_progress("Reading deployed template...")
+    deployed_template = phase1_update.get_deployed_template(target["region"], stack_name)
+    if not deployed_template:
+        return CdkImportPipelineResult(False, "Could not read deployed template after Phase 1")
+
+    resources = build_resources_to_import(synth_template, deployed_template)
+    if not resources:
+        return CdkImportPipelineResult(True, no_resources=True)
+
+    on_progress(f"Phase 2: Importing {len(resources)} resource(s) via CloudFormation IMPORT...")
+    phase2 = phase2_import.execute_phase2(
+        target["region"], stack_name, deployed_template, synth_template, resources, assembly, on_progress
+    )
+    if not phase2.success:
+        return CdkImportPipelineResult(False, f"Phase 2 failed: {phase2.error}")
+
+    on_progress("Updating deployed state...")
+    update_deployed_state(config_io, target_name, stack_name, deployed_state_entries)
+    on_progress("Deployed state updated")
+    return CdkImportPipelineResult(True)

agentcore/cli/commands/import_/import_runtime.py

@@ -0,0 +1,214 @@
+"""`agentcore import runtime` (port of commands/import/import-runtime.ts)."""
+
+from __future__ import annotations
+
+import os
+import re
+import shutil
+import sys
+from typing import Any
+
+import typer
+
+from agentcore.aws import agentcore_control
+from agentcore.cli.constants import ANSI
+
+from .import_utils import copy_agent_source, fail_result, parse_and_validate_arn, strip_reserved_tags
+from .resource_import import execute_resource_import
+from .types import BeforeWriteContext, ImportResourceResult, ResourceImportDescriptor, RuntimeImportOptions
+
+_SOURCE_FILE = re.compile(r"\.(py|ts|js)$")
+
+
+def extract_entrypoint(entry_point: list[str] | None) -> str | None:
+    """First entry that looks like a source file (skips wrappers like ``opentelemetry-instrument``)."""
+    if not entry_point:
+        return None
+    return next((e for e in entry_point if _SOURCE_FILE.search(e)), None)
+
+
+def to_agent_env_spec(runtime: dict[str, Any], local_name: str, code_location: str, entrypoint: str) -> dict[str, Any]:
+    runtime_version = (
+        runtime.get("runtimeVersion")
+        if runtime["build"] == "Container"
+        else (runtime.get("runtimeVersion") or "PYTHON_3_12")
+    )
+    spec: dict[str, Any] = {"name": local_name}
+    if runtime.get("description"):
+        spec["description"] = runtime["description"]
+    spec.update(
+        {
+            "build": runtime["build"],
+            "entrypoint": entrypoint,
+            "codeLocation": code_location,
+            "runtimeVersion": runtime_version,
+            "protocol": runtime.get("protocol"),
+            "networkMode": runtime.get("networkMode"),
+            "instrumentation": {"enableOtel": True},
+        }
+    )
+    spec = {k: v for k, v in spec.items() if v is not None}
+    if runtime.get("networkMode") == "VPC" and runtime.get("networkConfig"):
+        spec["networkConfig"] = runtime["networkConfig"]
+    if runtime.get("roleArn") and runtime["roleArn"] != "imported":
+        spec["executionRoleArn"] = runtime["roleArn"]
+    if runtime.get("authorizerType"):
+        spec["authorizerType"] = runtime["authorizerType"]
+    if runtime.get("authorizerConfiguration"):
+        spec["authorizerConfiguration"] = runtime["authorizerConfiguration"]
+    if runtime.get("environmentVariables"):
+        spec["envVars"] = [{"name": k, "value": v} for k, v in runtime["environmentVariables"].items()]
+    tags = strip_reserved_tags(runtime.get("tags"))
+    if tags:
+        spec["tags"] = tags
+    if runtime.get("lifecycleConfiguration"):
+        spec["lifecycleConfiguration"] = runtime["lifecycleConfiguration"]
+    if runtime.get("requestHeaderAllowlist"):
+        spec["requestHeaderAllowlist"] = runtime["requestHeaderAllowlist"]
+    return spec
+
+
+def create_runtime_descriptor(options: RuntimeImportOptions) -> ResourceImportDescriptor[Any, Any]:
+    state: dict[str, Any] = {"entrypoint": "", "code_location": "", "copied_app_dir": None}
+
+    def before_write(c: BeforeWriteContext[Any]) -> ImportResourceResult | None:
+        c.logger.start_step("Resolve entrypoint")
+        entrypoint = options.entrypoint or extract_entrypoint(c.detail.get("entryPoint"))
+        if not entrypoint:
+            return fail_result(
+                c.logger,
+                "Could not determine entrypoint from runtime configuration.\n  Please re-run with --entrypoint "
+                "<file> to specify it manually.",
+                "runtime",
+                c.local_name,
+            )
+        c.on_progress(f"Entrypoint: {entrypoint}")
+        c.logger.end_step("success")
+
+        c.logger.start_step("Validate source path")
+        if not options.code:
+            return fail_result(
+                c.logger,
+                "Source path is required for runtime import. Use --code <path> to specify the agent source code "
+                "directory.",
+                "runtime",
+                c.local_name,
+            )
+        source_path = os.path.abspath(options.code)
+        if not os.path.exists(source_path):
+            return fail_result(c.logger, f"Source path does not exist: {source_path}", "runtime", c.local_name)
+        if not os.path.exists(os.path.join(source_path, entrypoint)):
+            return fail_result(
+                c.logger,
+                f"Entrypoint file '{entrypoint}' not found in {source_path}. Ensure --code points to the directory "
+                "containing your entrypoint file.",
+                "runtime",
+                c.local_name,
+            )
+        c.logger.end_step("success")
+
+        c.logger.start_step("Copy agent source")
+        state["code_location"] = f"app/{c.local_name}/"
+        state["entrypoint"] = entrypoint
+        state["copied_app_dir"] = os.path.join(c.ctx.project_root, "app", c.local_name)
+        copy_agent_source(source_path, c.local_name, c.ctx.project_root, c.detail["build"], entrypoint, c.on_progress)
+        c.logger.end_step("success")
+        return None
+
+    def add_to_spec(detail: Any, local_name: str, spec: dict[str, Any]) -> ImportResourceResult:
+        spec.setdefault("runtimes", []).append(
+            to_agent_env_spec(detail, local_name, state["code_location"], state["entrypoint"])
+        )
+        return ImportResourceResult(success=True, resource_type="runtime", resource_name=local_name)
+
+    def rollback_extra() -> None:
+        path = state["copied_app_dir"]
+        if path and os.path.exists(path):
+            try:
+                shutil.rmtree(path)
+            except OSError as exc:
+                print(f"Warning: Could not clean up {path}: {exc}", file=sys.stderr)
+
+    from .import_utils import ImportedResource
+
+    return ResourceImportDescriptor(
+        resource_type="runtime",
+        display_name="runtime",
+        log_command="import-runtime",
+        list_resources=lambda region: agentcore_control.list_all_agent_runtimes(region=region),
+        get_detail=lambda region, rid: agentcore_control.get_agent_runtime_detail(region=region, runtime_id=rid),
+        parse_resource_id=lambda arn, target: parse_and_validate_arn(arn, "runtime", target).resource_id,
+        extract_summary_id=lambda s: s["agentRuntimeId"],
+        format_list_item=lambda s, i: (
+            f"  {ANSI.dim}[{i + 1}]{ANSI.reset} {s['agentRuntimeName']} — {s['status']}\n"
+            f"       {ANSI.dim}{s['agentRuntimeArn']}{ANSI.reset}"
+        ),
+        format_auto_select_message=lambda s: (
+            f"Found 1 runtime: {s['agentRuntimeName']} ({s['agentRuntimeId']}). Auto-selecting."
+        ),
+        extract_detail_name=lambda d: d["agentRuntimeName"],
+        extract_detail_arn=lambda d: d["agentRuntimeArn"],
+        ready_status="READY",
+        extract_detail_status=lambda d: d["status"],
+        get_existing_names=lambda spec: [r["name"] for r in spec.get("runtimes", [])],
+        add_to_project_spec=add_to_spec,
+        cfn_resource_type="AWS::BedrockAgentCore::Runtime",
+        cfn_name_property="AgentRuntimeName",
+        cfn_identifier_key="AgentRuntimeId",
+        build_deployed_state_entry=lambda name, rid, d: ImportedResource("runtime", name, rid, d["agentRuntimeArn"]),
+        before_config_write=before_write,
+        rollback_extra=rollback_extra,
+    )
+
+
+def handle_import_runtime(options: RuntimeImportOptions) -> ImportResourceResult:
+    return execute_resource_import(create_runtime_descriptor(options), options)
+
+
+def print_success(label: str, result: ImportResourceResult, next_steps: list[tuple[str, str]]) -> None:
+    typer.echo("")
+    typer.echo(f"{ANSI.green}{label} imported successfully!{ANSI.reset}")
+    typer.echo(f"  Name: {result.resource_name}")
+    typer.echo(f"  ID: {result.resource_id}")
+    typer.echo("")
+    if next_steps:
+        typer.echo(f"{ANSI.dim}Next steps:{ANSI.reset}")
+        for cmd, desc in next_steps:
+            typer.echo(f"  {cmd}{ANSI.dim}{desc}{ANSI.reset}")
+        typer.echo("")
+
+
+def print_failure(result: ImportResourceResult) -> None:
+    typer.echo(f"\n{ANSI.red}[error]{ANSI.reset} {result.error}", err=True)
+    if result.log_path:
+        typer.echo(f"Log: {result.log_path}", err=True)
+    raise typer.Exit(1)
+
+
+RUNTIME_NEXT_STEPS = [
+    ("agentcore deploy     ", "Deploy the imported stack"),
+    ("agentcore status     ", "Verify resource status"),
+    ("agentcore invoke     ", "Test your agent"),
+]
+
+
+def register_import_runtime(import_app: typer.Typer) -> None:
+    @import_app.command("runtime", help="Import an existing AgentCore Runtime from your AWS account")
+    def import_runtime(
+        arn: str | None = typer.Option(None, "--arn", help="Runtime ARN to import"),
+        code: str | None = typer.Option(
+            None, "--code", help="Path to the directory containing the entrypoint file (e.g., the folder with main.py)"
+        ),
+        entrypoint: str | None = typer.Option(
+            None, "--entrypoint", help="Entrypoint file (auto-detected from runtime, e.g. main.py)"
+        ),
+        name: str | None = typer.Option(None, "--name", help="Local name for the imported runtime"),
+        yes: bool = typer.Option(False, "-y", "--yes", help="Auto-confirm prompts"),
+    ) -> None:
+        result = handle_import_runtime(
+            RuntimeImportOptions(arn=arn, code=code, entrypoint=entrypoint, name=name, yes=yes or None)
+        )
+        if result.success:
+            print_success("Runtime", result, RUNTIME_NEXT_STEPS)
+        else:
+            print_failure(result)