agentcore-cli 0.31.1__py3-none-any.whl

agentcore/cli/commands/import_/import_utils.py

@@ -0,0 +1,410 @@
+"""Shared import helpers (port of commands/import/import-utils.ts).
+
+Project specs and targets are handled as camelCase JSON dicts, as upstream treats them as plain objects.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import shutil
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+
+from agentcore.aws import account as aws_account
+from agentcore.cli.constants import ANSI
+from agentcore.lib.constants import APP_DIR
+from agentcore.lib.errors.types import NoProjectError, ValidationError
+from agentcore.lib.schemas.io.config_io import ConfigIO, to_jsonable
+from agentcore.lib.schemas.io.path_resolver import find_config_root
+from agentcore.logging.exec_logger import ExecLogger
+
+from .types import ImportableResourceType, ImportResourceOptions, ImportResourceResult
+
+
+def strip_reserved_tags(tags: dict[str, str] | None) -> dict[str, str] | None:
+    """Drop AWS-reserved ``aws:*`` tags; None when nothing user-owned remains."""
+    if not tags:
+        return None
+    user_tags = {k: v for k, v in tags.items() if not k.startswith("aws:")}
+    return user_tags or None
+
+
+# ============================================================================
+# Project context / import context
+# ============================================================================
+
+
+@dataclass
+class ProjectContext:
+    project_root: str
+    config_root: str
+    config_io: ConfigIO
+    project_name: str
+
+
+@dataclass
+class ImportContext:
+    ctx: ProjectContext
+    target: dict[str, Any]
+    logger: ExecLogger
+    on_progress: Callable[[str], None]
+
+
+def default_on_progress(message: str) -> None:
+    print(f"{ANSI.green}[done]{ANSI.reset}  {message}", flush=True)
+
+
+def resolve_project_context() -> ProjectContext:
+    config_root = find_config_root(os.getcwd())
+    if not config_root:
+        raise NoProjectError(
+            "No agentcore project found in the current directory.\n"
+            "Run `agentcore create <name>` first, then run import from inside the project."
+        )
+    config_io = ConfigIO(base_dir=config_root)
+    spec = config_io.read_project_spec()
+    return ProjectContext(os.path.dirname(config_root), config_root, config_io, spec.name)
+
+
+def resolve_import_context(options: ImportResourceOptions, command: str) -> ImportContext:
+    logger = ExecLogger(command)
+    on_progress = options.on_progress or default_on_progress
+
+    logger.start_step("Validate project context")
+    ctx = resolve_project_context()
+    logger.end_step("success")
+
+    logger.start_step("Resolve deployment target")
+    target = resolve_import_target(ctx.config_io, options.target, options.arn, on_progress)
+    logger.end_step("success")
+    return ImportContext(ctx, target, logger, on_progress)
+
+
+def fail_result(
+    logger: ExecLogger, error: str, resource_type: ImportableResourceType, resource_name: str
+) -> ImportResourceResult:
+    logger.end_step("error", error)
+    logger.finalize(False)
+    return ImportResourceResult(
+        success=False,
+        error=ValidationError(error),
+        resource_type=resource_type,
+        resource_name=resource_name,
+        log_path=logger.get_relative_log_path(),
+    )
+
+
+# ============================================================================
+# Target resolution
+# ============================================================================
+
+_ANY_ARN = re.compile(
+    r"^arn:[^:]+:bedrock-agentcore:([^:]+):([^:]+):(runtime|memory|evaluator|online-evaluation-config|gateway)/(.+)$"
+)
+_ARN_REGION_ACCOUNT = re.compile(r"^arn:[^:]+:bedrock-agentcore:([^:]+):([^:]+):")
+
+
+def _targets_as_dicts(config_io: ConfigIO) -> list[dict[str, Any]]:
+    return [to_jsonable(t) for t in config_io.read_aws_deployment_targets()]
+
+
+def resolve_import_target(
+    config_io: ConfigIO,
+    target_name: str | None = None,
+    arn: str | None = None,
+    on_progress: Callable[[str], None] | None = None,
+) -> dict[str, Any]:
+    """Resolve the deployment target (account + region) and validate AWS credentials against it."""
+    if arn and not _ANY_ARN.match(arn):
+        raise ValidationError(
+            f'Not a valid ARN: "{arn}".\nExpected format: arn:<partition>:bedrock-agentcore:<region>:<account>:'
+            "<runtime|memory|evaluator|online-evaluation-config|gateway>/<id>"
+        )
+
+    if arn:
+        m = _ARN_REGION_ACCOUNT.match(arn)
+        arn_region = m.group(1) if m else None
+        env_region = os.environ.get("AWS_REGION") or os.environ.get("AWS_DEFAULT_REGION")
+        if arn_region and env_region and env_region != arn_region:
+            raise ValidationError(
+                f'Region mismatch: AWS_REGION is "{env_region}" but the ARN is in "{arn_region}". '
+                f"Either re-run with AWS_REGION={arn_region} or pass an ARN from {env_region}."
+            )
+
+    targets = _targets_as_dicts(config_io)
+    if not targets:
+        if not arn:
+            raise ValidationError(
+                "No deployment targets found in project.\nRun `agentcore deploy` first to set up a target, or use "
+                "--arn so a target can be created automatically."
+            )
+        m = _ARN_REGION_ACCOUNT.match(arn)
+        if not m:
+            raise ValidationError(
+                "No deployment targets found in project and could not parse region/account from ARN.\n"
+                "Run `agentcore deploy` first to set up a target, then re-run import."
+            )
+        arn_region, arn_account = m.group(1), m.group(2)
+        new_target = {
+            "name": "default",
+            "description": f"Default target ({arn_region})",
+            "account": arn_account,
+            "region": arn_region,
+        }
+        if on_progress:
+            on_progress(
+                f"No deployment targets found. Creating default target from ARN ({arn_region}, {arn_account})..."
+            )
+        config_io.write_aws_deployment_targets([new_target])
+        targets = [new_target]
+
+    def listing() -> str:
+        return "\n".join(f"  - {t['name']} ({t['region']}, {t['account']})" for t in targets)
+
+    if target_name:
+        target = next((t for t in targets if t["name"] == target_name), None)
+        if target is None:
+            raise ValidationError(f'Target "{target_name}" not found. Available targets:\n{listing()}')
+    elif len(targets) == 1:
+        target = targets[0]
+    else:
+        raise ValidationError(f"Multiple deployment targets found. Specify one with --target:\n{listing()}")
+
+    if on_progress:
+        on_progress(f"Using target: {target['name']} ({target['region']}, {target['account']})")
+        on_progress("Validating AWS credentials...")
+    aws_account.validate_aws_credentials()
+
+    caller = aws_account.detect_account()
+    if caller and target.get("account") and caller != target["account"]:
+        raise ValidationError(
+            f'Your AWS credentials are for account {caller}, but the target "{target["name"]}" is configured for '
+            f"account {target['account']}.\nEnsure your credentials match the deployment target."
+        )
+    return target
+
+
+# ============================================================================
+# ARN validation
+# ============================================================================
+
+
+@dataclass
+class ParsedArn:
+    region: str
+    account: str
+    resource_type: str
+    resource_id: str
+
+
+# Unified config for each importable resource type: ARN type and deployed-state location.
+RESOURCE_TYPE_CONFIG: dict[str, dict[str, str]] = {
+    "runtime": {"arnType": "runtime", "collectionKey": "runtimes", "idField": "runtimeId"},
+    "memory": {"arnType": "memory", "collectionKey": "memories", "idField": "memoryId"},
+    "evaluator": {"arnType": "evaluator", "collectionKey": "evaluators", "idField": "evaluatorId"},
+    "online-eval": {
+        "arnType": "online-evaluation-config",
+        "collectionKey": "onlineEvalConfigs",
+        "idField": "onlineEvaluationConfigId",
+    },
+    "gateway": {"arnType": "gateway", "collectionKey": "mcp.gateways", "idField": "gatewayId"},
+}
+
+
+def parse_and_validate_arn(arn: str, expected_resource_type: str, target: dict[str, Any]) -> ParsedArn:
+    match = _ANY_ARN.match(arn)
+    expected = RESOURCE_TYPE_CONFIG[expected_resource_type]["arnType"]
+    if not match:
+        raise ValidationError(
+            f'Invalid ARN format: "{arn}". Expected format: arn:<partition>:bedrock-agentcore:<region>:<account>:'
+            f"{expected}/<id>"
+        )
+    region, account, resource_type, resource_id = match.groups()
+    if resource_type != expected:
+        raise ValidationError(f'ARN resource type "{resource_type}" does not match expected type "{expected}".')
+    if region != target["region"]:
+        raise ValidationError(
+            f'ARN region "{region}" does not match target region "{target["region"]}". Use --target to select a '
+            "different deployment target."
+        )
+    if account != target["account"]:
+        raise ValidationError(
+            f'ARN account "{account}" does not match target account "{target["account"]}". Ensure the ARN belongs '
+            "to the correct account."
+        )
+    return ParsedArn(region, account, resource_type, resource_id)
+
+
+# ============================================================================
+# Stack name / deployed state
+# ============================================================================
+
+
+def to_stack_name(project_name: str, target_name: str) -> str:
+    return f"AgentCore-{project_name.replace('_', '-')}-{target_name.replace('_', '-')}"
+
+
+def _read_state_dict(config_io: ConfigIO) -> dict[str, Any]:
+    try:
+        return to_jsonable(config_io.read_deployed_state())
+    except Exception:  # noqa: BLE001 - readDeployedState().catch(() => ({ targets: {} }))
+        return {"targets": {}}
+
+
+def find_resource_in_deployed_state(
+    config_io: ConfigIO, target_name: str, resource_type: str, resource_id: str
+) -> str | None:
+    """The name a resource ID is tracked under in deployed-state.json for ``target_name``, if any."""
+    state = _read_state_dict(config_io)
+    target_state = (state.get("targets") or {}).get(target_name) or {}
+    collection: Any = target_state.get("resources")
+    if not collection:
+        return None
+    cfg = RESOURCE_TYPE_CONFIG[resource_type]
+    for key in cfg["collectionKey"].split("."):
+        collection = collection.get(key) if isinstance(collection, dict) else None
+    if not collection:
+        return None
+    for name, entry in collection.items():
+        if isinstance(entry, dict) and entry.get(cfg["idField"]) == resource_id:
+            return name
+    return None
+
+
+@dataclass
+class ImportedResource:
+    type: str
+    name: str
+    id: str
+    arn: str
+
+
+def update_deployed_state(
+    config_io: ConfigIO, target_name: str, stack_name: str, resources: list[ImportedResource]
+) -> None:
+    state = _read_state_dict(config_io)
+    state.setdefault("targets", {})
+    target_state = state["targets"].get(target_name) or {"resources": {}}
+    res = target_state.setdefault("resources", {})
+    res["stackName"] = stack_name
+    for r in resources:
+        if r.type == "runtime":
+            res.setdefault("runtimes", {})[r.name] = {"runtimeId": r.id, "runtimeArn": r.arn, "roleArn": "imported"}
+        elif r.type == "memory":
+            res.setdefault("memories", {})[r.name] = {"memoryId": r.id, "memoryArn": r.arn}
+        elif r.type == "evaluator":
+            res.setdefault("evaluators", {})[r.name] = {"evaluatorId": r.id, "evaluatorArn": r.arn}
+        elif r.type == "online-eval":
+            res.setdefault("onlineEvalConfigs", {})[r.name] = {
+                "onlineEvaluationConfigId": r.id,
+                "onlineEvaluationConfigArn": r.arn,
+            }
+        elif r.type == "gateway":
+            res.setdefault("mcp", {}).setdefault("gateways", {})[r.name] = {"gatewayId": r.id, "gatewayArn": r.arn}
+    state["targets"][target_name] = target_state
+    config_io.write_deployed_state(state)
+
+
+# ============================================================================
+# Source code copy
+# ============================================================================
+
+COPY_EXCLUDE_DIRS = frozenset(
+    {
+        ".venv",
+        ".git",
+        "__pycache__",
+        "node_modules",
+        ".pytest_cache",
+        ".bedrock_agentcore",
+        ".mypy_cache",
+        ".ruff_cache",
+    }
+)
+
+
+def copy_dir_recursive(src: str, dest: str) -> None:
+    """Copy directory contents, skipping excluded directories and symlinks."""
+    for entry in os.scandir(src):
+        if entry.is_symlink():
+            continue
+        dest_path = os.path.join(dest, entry.name)
+        if entry.is_dir():
+            if entry.name in COPY_EXCLUDE_DIRS:
+                continue
+            os.makedirs(dest_path, exist_ok=True)
+            copy_dir_recursive(entry.path, dest_path)
+        else:
+            shutil.copyfile(entry.path, dest_path)
+
+
+def fix_pyproject_for_setuptools(pyproject_path: str) -> None:
+    if not os.path.exists(pyproject_path):
+        return
+    with open(pyproject_path, encoding="utf-8") as fh:
+        content = fh.read()
+    if "[tool.setuptools]" in content:
+        return
+    with open(pyproject_path, "w", encoding="utf-8") as fh:
+        fh.write(content.rstrip() + "\n\n[tool.setuptools]\npy-modules = []\n")
+
+
+def copy_agent_source(
+    source_path: str,
+    agent_name: str,
+    project_root: str,
+    build: str,
+    entrypoint: str | None = None,
+    on_progress: Callable[[str], None] | None = None,
+) -> None:
+    """Copy agent source into ``app/<name>/``; generate a Dockerfile / set up the Python env as needed."""
+    progress = on_progress or (lambda _m: None)
+    app_dir = os.path.join(project_root, APP_DIR, agent_name)
+    os.makedirs(app_dir, exist_ok=True)
+
+    if not os.path.exists(source_path):
+        raise ValidationError(f"Source path does not exist: {source_path}")
+
+    progress(f"Copying agent source from {source_path} to ./{APP_DIR}/{agent_name}")
+    copy_dir_recursive(source_path, app_dir)
+
+    parent_pyproject = os.path.join(os.path.dirname(source_path), "pyproject.toml")
+    dest_pyproject = os.path.join(app_dir, "pyproject.toml")
+    if os.path.exists(parent_pyproject) and not os.path.exists(dest_pyproject):
+        shutil.copyfile(parent_pyproject, dest_pyproject)
+
+    if build == "Container":
+        dest_dockerfile = os.path.join(app_dir, "Dockerfile")
+        if not os.path.exists(dest_dockerfile):
+            is_python = entrypoint.endswith(".py") if entrypoint is not None else True
+            if is_python:
+                from agentcore.templates.template_root import get_template_path
+
+                progress("Generating Dockerfile for Container build")
+                entry_module = os.path.basename(entrypoint or "main.py")
+                if entry_module.endswith(".py"):
+                    entry_module = entry_module[:-3]
+                template = get_template_path("container", "python", "Dockerfile").read_text(encoding="utf-8")
+                with open(dest_dockerfile, "w", encoding="utf-8") as fh:
+                    fh.write(template.replace("{{entrypoint}}", entry_module, 1))
+            else:
+                progress(
+                    "No Dockerfile found. Please add a Dockerfile to the source directory for non-Python container "
+                    "builds."
+                )
+
+    # Container agents install dependencies inside the Docker image.
+    if build != "Container":
+        from agentcore.operations.python.setup import setup_python_project
+
+        fix_pyproject_for_setuptools(dest_pyproject)
+        progress(f"Setting up Python environment for {agent_name}...")
+        result = setup_python_project(app_dir)
+        if result.status == "success":
+            progress(f"Python environment ready for {agent_name}")
+        elif result.status == "uv_not_found":
+            progress(f'Warning: uv not found — run "uv sync" manually in {APP_DIR}/{agent_name}')
+        else:
+            progress(f"Warning: Python setup failed for {agent_name}: {result.error or result.status}")

agentcore/cli/commands/import_/phase1_update.py

@@ -0,0 +1,110 @@
+"""Phase 1 of a CloudFormation import: deploy companion resources (port of commands/import/phase1-update.ts).
+
+Creates the IAM roles/policies the imported primary resources reference by deploying a filtered
+template that contains no ``AWS::BedrockAgentCore::*`` resources.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+
+from agentcore.aws._aws_errors import get_error_message
+from agentcore.aws.account import create_aws_client
+
+from .template_utils import CfnTemplate, filter_companion_only_template
+
+_WAITER_CONFIG = {"Delay": 5, "MaxAttempts": 120}  # ~600s max wait, as upstream's maxWaitTime
+
+
+@dataclass
+class Phase1Result:
+    success: bool
+    stack_exists: bool
+    error: str | None = None
+
+
+def _cfn(region: str) -> Any:
+    return create_aws_client("cloudformation", region)
+
+
+def _does_stack_exist(cfn: Any, stack_name: str) -> bool:
+    try:
+        stacks = cfn.describe_stacks(StackName=stack_name).get("Stacks") or []
+        return bool(stacks) and stacks[0].get("StackStatus") != "DELETE_COMPLETE"
+    except Exception:  # noqa: BLE001
+        return False
+
+
+def get_deployed_template(region: str, stack_name: str) -> CfnTemplate | None:
+    try:
+        response = _cfn(region).get_template(StackName=stack_name, TemplateStage="Original")
+    except Exception:  # noqa: BLE001
+        return None
+    body = response.get("TemplateBody")
+    if not body:
+        return None
+    # boto3 decodes JSON template bodies into dicts.
+    return body if isinstance(body, dict) else json.loads(body)
+
+
+def execute_phase1(
+    region: str, stack_name: str, synth_template: CfnTemplate, on_progress: Callable[[str], None] | None = None
+) -> Phase1Result:
+    progress = on_progress or (lambda _m: None)
+    cfn = _cfn(region)
+    companion = filter_companion_only_template(synth_template)
+
+    if not companion["Resources"]:
+        progress("No companion resources needed, skipping Phase 1")
+        return Phase1Result(True, _does_stack_exist(cfn, stack_name))
+
+    template_body = json.dumps(companion)
+    stack_exists = _does_stack_exist(cfn, stack_name)
+
+    if stack_exists:
+        # Keep previously imported primary resources, or CloudFormation would delete them.
+        deployed = get_deployed_template(region, stack_name)
+        if deployed:
+            for logical_id, resource in deployed.get("Resources", {}).items():
+                if logical_id not in companion["Resources"]:
+                    companion["Resources"][logical_id] = resource
+        progress(f"Updating stack {stack_name} with companion resources...")
+        try:
+            cfn.update_stack(
+                StackName=stack_name,
+                TemplateBody=json.dumps(companion),
+                Capabilities=["CAPABILITY_IAM", "CAPABILITY_NAMED_IAM"],
+            )
+            progress("Waiting for stack update to complete...")
+            cfn.get_waiter("stack_update_complete").wait(StackName=stack_name, WaiterConfig=_WAITER_CONFIG)
+            progress("Phase 1 UPDATE complete")
+        except Exception as exc:  # noqa: BLE001
+            message = get_error_message(exc)
+            if "No updates are to be performed" in message:
+                progress("Stack already has companion resources, no update needed")
+                return Phase1Result(True, True)
+            return Phase1Result(False, True, message)
+    else:
+        progress(f"Creating stack {stack_name} with companion resources...")
+        try:
+            project = re.sub(r"-[^-]+$", "", re.sub(r"^AgentCore-", "", stack_name))
+            cfn.create_stack(
+                StackName=stack_name,
+                TemplateBody=template_body,
+                Capabilities=["CAPABILITY_IAM", "CAPABILITY_NAMED_IAM"],
+                Tags=[
+                    {"Key": "agentcore:project-name", "Value": project},
+                    {"Key": "agentcore:target-name", "Value": "default"},
+                ],
+            )
+            progress("Waiting for stack creation to complete...")
+            cfn.get_waiter("stack_create_complete").wait(StackName=stack_name, WaiterConfig=_WAITER_CONFIG)
+            progress("Phase 1 CREATE complete")
+        except Exception as exc:  # noqa: BLE001
+            return Phase1Result(False, False, get_error_message(exc))
+
+    return Phase1Result(True, stack_exists)