agentcore-cli 0.31.1__py3-none-any.whl

agentcore/cli/commands/status/action.py

@@ -0,0 +1,741 @@
+"""`agentcore status` logic (port of ``commands/status/action.ts``).
+
+Resource entries are plain dicts keyed like upstream's ``ResourceStatusEntry`` (camelCase). Keys
+are inserted in upstream's object order, and ``None`` stands for ``undefined`` (dropped on output),
+so ``--json`` matches upstream key for key.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable, Mapping
+from dataclasses import dataclass, field
+from datetime import UTC, datetime
+from typing import Any
+
+from agentcore.aws import agentcore_control, agentcore_payments, bedrock_agent
+from agentcore.aws._aws_errors import get_error_message
+from agentcore.cli.commands.status.constants import build_runtime_invocation_url
+from agentcore.cli.commands.status.format_knowledge_base import (
+    KbDataSourceDetail,
+    KbIngestionDetail,
+    KbStatusDetail,
+    format_knowledge_base_detail,
+    format_knowledge_base_summary_line,
+)
+from agentcore.lib.errors.types import BaseError, ResourceNotFoundError
+from agentcore.lib.schemas.io.config_io import ConfigIO, to_jsonable
+from agentcore.logging.exec_logger import ExecLogger
+
+ResourceStatusEntry = dict[str, Any]
+
+
+@dataclass
+class StatusContext:
+    project: Any
+    deployed_state: Any
+    aws_targets: list[Any]
+
+
+def load_status_config(config_io: ConfigIO | None = None) -> StatusContext:
+    """Project, targets and deployed state (missing deployed-state means no targets)."""
+    io = config_io or ConfigIO()
+    project = io.read_project_spec()
+    aws_targets = io.read_aws_deployment_targets()
+    deployed_state = io.read_deployed_state() if io.config_exists("state") else {"targets": {}}
+    return StatusContext(project=project, deployed_state=to_jsonable(deployed_state), aws_targets=aws_targets)
+
+
+def _entry(resource_type: str, name: str, state: str, identifier: Any, detail: Any, parent: Any) -> ResourceStatusEntry:
+    return {
+        "resourceType": resource_type,
+        "name": name,
+        "deploymentState": state,
+        "identifier": identifier,
+        "detail": detail,
+        "parentName": parent,
+    }
+
+
+def _diff_resource_set(
+    resource_type: str,
+    local_items: Iterable[Any],
+    deployed_record: Mapping[str, Mapping[str, Any]],
+    get_identifier: Callable[[Mapping[str, Any]], Any],
+    get_local_detail: Callable[[Any], Any] | None = None,
+    get_deployed_key: Callable[[Any], str] | None = None,
+    get_parent_name: Callable[[Any], Any] | None = None,
+) -> list[ResourceStatusEntry]:
+    items = list(local_items)
+
+    def name_of(item: Any) -> str:
+        return item["name"] if isinstance(item, Mapping) else item.name
+
+    def key_of(item: Any) -> str:
+        return get_deployed_key(item) if get_deployed_key else name_of(item)
+
+    local_keys = {key_of(i) for i in items}
+    entries = []
+    for item in items:
+        deployed = deployed_record.get(key_of(item))
+        entries.append(
+            _entry(
+                resource_type,
+                name_of(item),
+                "deployed" if deployed else "local-only",
+                get_identifier(deployed) if deployed else None,
+                get_local_detail(item) if get_local_detail else None,
+                get_parent_name(item) if get_parent_name else None,
+            )
+        )
+    for name, deployed in deployed_record.items():
+        if name not in local_keys:
+            slash = name.find("/")
+            parent = name[:slash] if get_parent_name and slash > 0 else None
+            entries.append(_entry(resource_type, name, "pending-removal", get_identifier(deployed), None, parent))
+    return entries
+
+
+def _plural(count: int, singular: str, plural: str | None = None) -> str:
+    return singular if count == 1 else (plural or f"{singular}s")
+
+
+def _kb_wiring(project: Any) -> dict[str, list[str]]:
+    """KB reference -> gateways whose connector targets reference it (Retrieve + AgenticRetrieveStream)."""
+    wiring: dict[str, list[str]] = {}
+
+    def record(ref: str, gateway: str) -> None:
+        names = wiring.setdefault(ref, [])
+        if gateway not in names:
+            names.append(gateway)
+
+    for gw in project.agent_core_gateways or []:
+        for t in gw.targets or []:
+            if t.target_type != "connector":
+                continue
+            for cfg in t.configurations or []:
+                pv = cfg.parameter_values or {}
+                if cfg.name == "Retrieve" and pv.get("knowledgeBaseId"):
+                    record(pv["knowledgeBaseId"], gw.name)
+                if cfg.name == "AgenticRetrieveStream":
+                    for r in pv.get("retrievers") or []:
+                        ref = (((r or {}).get("configuration") or {}).get("knowledgeBase") or {}).get("knowledgeBaseId")
+                        if ref:
+                            record(ref, gw.name)
+    return wiring
+
+
+def _gateway_detail(item: Any) -> str | None:
+    targets = item.targets or []
+    if not targets:
+        return None
+    retrieve = sum(1 for t in targets if t.target_type == "connector" and t.connector_id == "bedrock-knowledge-bases")
+    web_search = sum(1 for t in targets if t.target_type == "connector" and t.connector_id == "web-search")
+    base = f"{len(targets)} target{'s' if len(targets) != 1 else ''}"
+    parts = []
+    if retrieve:
+        parts.append(f"{retrieve} retrieve")
+    fan_out = 0
+    for t in targets:
+        if t.target_type != "connector" or t.connector_id != "bedrock-knowledge-bases":
+            continue
+        agentic = next((c for c in t.configurations or [] if c.name == "AgenticRetrieveStream"), None)
+        if agentic:
+            fan_out += len((agentic.parameter_values or {}).get("retrievers") or [])
+    if fan_out:
+        parts.append(f"agentic ×{fan_out}")
+    if web_search:
+        parts.append(f"{web_search} web-search")
+    return f"{base} ({', '.join(parts)})" if parts else base
+
+
+def _strip_suffix(value: str | None, suffix: str) -> str | None:
+    return value.replace(suffix, "", 1) if value else value
+
+
+def compute_resource_statuses(project: Any, resources: Mapping[str, Any] | None) -> list[ResourceStatusEntry]:
+    """Diff local resources against the deployed-state resources (camelCase JSON) for one target."""
+    res = resources or {}
+
+    agents = _diff_resource_set("agent", project.runtimes or [], res.get("runtimes") or {}, lambda d: d["runtimeArn"])
+    credentials = _diff_resource_set(
+        "credential",
+        project.credentials or [],
+        res.get("credentials") or {},
+        lambda d: d["credentialProviderArn"],
+        lambda item: _strip_suffix(item.authorizer_type, "CredentialProvider"),
+    )
+    memories = _diff_resource_set(
+        "memory",
+        project.memories or [],
+        res.get("memories") or {},
+        lambda d: d["memoryArn"],
+        lambda item: ", ".join(s.type for s in item.strategies) if item.strategies else None,
+    )
+    gateways = _diff_resource_set(
+        "gateway",
+        project.agent_core_gateways or [],
+        {**((res.get("mcp") or {}).get("gateways") or {}), **(res.get("gateways") or {})},
+        lambda d: d["gatewayId"],
+        _gateway_detail,
+    )
+    evaluators = _diff_resource_set(
+        "evaluator",
+        project.evaluators or [],
+        res.get("evaluators") or {},
+        lambda d: d["evaluatorArn"],
+        lambda item: f"{item.level} — {'Code-based' if item.config.code_based else 'LLM-as-a-Judge'}",
+    )
+    online_evals = _diff_resource_set(
+        "online-eval",
+        project.online_eval_configs or [],
+        res.get("onlineEvalConfigs") or {},
+        lambda d: d["onlineEvaluationConfigArn"],
+        lambda item: (
+            f"{len(item.evaluators or [])} evaluator{'s' if len(item.evaluators or []) != 1 else ''}, "
+            f"{_js_number(item.sampling_rate)}% sampling"
+        ),
+    )
+    policy_engines = _diff_resource_set(
+        "policy-engine",
+        project.policy_engines or [],
+        res.get("policyEngines") or {},
+        lambda d: d["policyEngineArn"],
+        lambda item: (
+            f"{len(item.policies)} polic{'ies' if len(item.policies) != 1 else 'y'}" if item.policies else None
+        ),
+    )
+    local_policies = [
+        {"name": p.name, "engineName": engine.name} for engine in project.policy_engines or [] for p in engine.policies
+    ]
+    policies = _diff_resource_set(
+        "policy",
+        local_policies,
+        res.get("policies") or {},
+        lambda d: d["policyArn"],
+        lambda item: item["engineName"],
+        lambda item: f"{item['engineName']}/{item['name']}",
+    )
+    config_bundles = _diff_resource_set(
+        "config-bundle",
+        project.config_bundles or [],
+        res.get("configBundles") or {},
+        lambda d: d["bundleArn"],
+        lambda item: item.description,
+    )
+    datasets = _diff_resource_set(
+        "dataset", project.datasets or [], res.get("datasets") or {}, lambda d: d["datasetArn"], lambda i: i.schema_type
+    )
+
+    wiring = _kb_wiring(project)
+
+    def kb_detail(item: Any) -> str:
+        count = len(item.data_sources)
+        ds_part = f"{count} data source{'' if count == 1 else 's'}"
+        wired = list(wiring.get(item.name, []))
+        if item.gateway and item.gateway not in wired:
+            wired.append(item.gateway)
+        return f"{ds_part} → gw:{','.join(wired)}" if wired else ds_part
+
+    knowledge_bases = _diff_resource_set(
+        "knowledge-base",
+        project.knowledge_bases or [],
+        res.get("knowledgeBases") or {},
+        lambda d: d["knowledgeBaseArn"],
+        kb_detail,
+    )
+
+    local_endpoints = [
+        {"name": ep_name, "agentName": r.name, "version": ep.version, "description": ep.description}
+        for r in project.runtimes or []
+        for ep_name, ep in (r.endpoints or {}).items()
+    ]
+    runtime_endpoints = _diff_resource_set(
+        "runtime-endpoint",
+        local_endpoints,
+        res.get("runtimeEndpoints") or {},
+        lambda d: d["endpointArn"],
+        lambda item: f"v{item['version']}{' — ' + item['description'] if item['description'] else ''}",
+        lambda item: f"{item['agentName']}/{item['name']}",
+        lambda item: item["agentName"],
+    )
+
+    harness_records = res.get("harnesses") or {}
+    harnesses = _diff_resource_set(
+        "harness", project.harnesses or [], harness_records, lambda d: d["harnessArn"], lambda _item: None
+    )
+    for entry in harnesses:
+        version = (harness_records.get(entry["name"]) or {}).get("harnessVersion")
+        if version is not None:
+            entry["detail"] = f"{entry['detail']} v{version}" if entry["detail"] else f"v{version}"
+
+    payments = _diff_resource_set(
+        "payment",
+        project.payments or [],
+        res.get("payments") or {},
+        lambda d: d["managerArn"],
+        lambda item: (
+            f"{item.authorizer_type} — auto-pay {'on' if item.auto_payment else 'off'} "
+            f"({len(item.connectors)} connector(s))"
+        ),
+    )
+    capacity_providers = _diff_resource_set(
+        "capacity-provider",
+        project.capacity_providers or [],
+        res.get("capacityProviders") or {},
+        lambda d: d["capacityProviderArn"],
+        lambda item: (
+            item.compute_configuration.ec2_configuration.launch_template_source.launch_parameters.operating_system
+        ),
+    )
+
+    return [
+        *agents,
+        *runtime_endpoints,
+        *credentials,
+        *memories,
+        *gateways,
+        *evaluators,
+        *online_evals,
+        *policy_engines,
+        *policies,
+        *datasets,
+        *knowledge_bases,
+        *config_bundles,
+        *harnesses,
+        *payments,
+        *capacity_providers,
+    ]
+
+
+def _js_number(value: Any) -> str:
+    """JS number-to-string (``10.0`` -> ``"10"``)."""
+    if isinstance(value, float) and value.is_integer():
+        return str(int(value))
+    return str(value)
+
+
+def _iso(value: Any) -> str | None:
+    if not isinstance(value, datetime):
+        return None
+    dt = value if value.tzinfo else value.replace(tzinfo=UTC)
+    dt = dt.astimezone(UTC)
+    return dt.strftime("%Y-%m-%dT%H:%M:%S.") + f"{dt.microsecond // 1000:03d}Z"
+
+
+@dataclass
+class ProjectStatusResult:
+    success: bool
+    error: BaseException | None = None
+    project_name: str | None = None
+    target_name: str | None = None
+    target_region: str | None = None
+    resources: list[ResourceStatusEntry] = field(default_factory=list)
+    deployed_state: Any = None
+    log_path: str | None = None
+
+    def to_json(self, resources: list[ResourceStatusEntry] | None = None) -> dict[str, Any]:
+        entries = [_drop_none(e) for e in (self.resources if resources is None else resources)]
+        if self.success:
+            data = {
+                "success": True,
+                "projectName": self.project_name,
+                "targetName": self.target_name,
+                "targetRegion": self.target_region,
+                "resources": entries,
+                "deployedState": self.deployed_state,
+                "logPath": self.log_path,
+            }
+        else:
+            data = {
+                "success": False,
+                "projectName": self.project_name,
+                "targetName": self.target_name,
+                "resources": entries,
+                "logPath": self.log_path,
+                "error": str(self.error),
+            }
+            data.update(_error_extras(self.error))
+        return _drop_none(data)
+
+
+@dataclass
+class RuntimeLookupResult:
+    success: bool
+    error: BaseException | None = None
+    target_name: str | None = None
+    runtime_id: str | None = None
+    runtime_status: str | None = None
+    log_path: str | None = None
+
+    def to_json(self) -> dict[str, Any]:
+        if self.success:
+            data = {
+                "success": True,
+                "targetName": self.target_name,
+                "runtimeId": self.runtime_id,
+                "runtimeStatus": self.runtime_status,
+                "logPath": self.log_path,
+            }
+        else:
+            data = {"success": False, "logPath": self.log_path, "error": str(self.error), **_error_extras(self.error)}
+        return _drop_none(data)
+
+
+def _error_extras(error: BaseException | None) -> dict[str, Any]:
+    if isinstance(error, BaseError):
+        return {"errorName": error.name, "errorSource": error.error_source}
+    return {}
+
+
+def _drop_none(data: Mapping[str, Any]) -> dict[str, Any]:
+    return {k: v for k, v in data.items() if v is not None}
+
+
+def handle_project_status(
+    context: StatusContext, *, target_name: str | None = None, knowledge_base_name: str | None = None
+) -> ProjectStatusResult:
+    logger = ExecLogger(command="status")
+    project, aws_targets = context.project, context.aws_targets
+    deployed_state = to_jsonable(context.deployed_state)
+    state_targets: dict[str, Any] = deployed_state.get("targets") or {}
+
+    logger.start_step("Resolve target")
+    deployed_names = list(state_targets.keys())
+    target_names = deployed_names if deployed_names else [t.name for t in aws_targets]
+    selected = target_name or (target_names[0] if target_names else None)
+
+    logger.log(f"Project: {project.name}")
+    logger.log(f"Available targets: {', '.join(target_names) if target_names else '(none)'}")
+    logger.log(f"Selected target: {selected or '(none)'}")
+
+    if target_name and target_name not in target_names:
+        error = (
+            f"Target '{target_name}' not found. Available: {', '.join(target_names)}"
+            if target_names
+            else f"Target '{target_name}' not found. No targets configured."
+        )
+        logger.end_step("error", error)
+        logger.finalize(False)
+        return ProjectStatusResult(
+            success=False,
+            error=Exception(error),
+            project_name=project.name,
+            target_name=target_name,
+            resources=[],
+            log_path=logger.get_relative_log_path(),
+        )
+    logger.end_step("success")
+
+    logger.start_step("Compute resource statuses")
+    target_config = next((t for t in aws_targets if t.name == selected), None) if selected else None
+    target_resources = ((state_targets.get(selected) or {}).get("resources") or {}) if selected else {}
+    resources = compute_resource_statuses(project, target_resources)
+
+    def count(state: str) -> int:
+        return sum(1 for r in resources if r["deploymentState"] == state)
+
+    logger.log(
+        f"Resources: {len(resources)} total ({count('deployed')} deployed, {count('local-only')} local-only, "
+        f"{count('pending-removal')} pending-removal)"
+    )
+    for entry in resources:
+        ident = f" [{entry['identifier']}]" if entry["identifier"] else ""
+        logger.log(f"  {entry['resourceType']}/{entry['name']}: {entry['deploymentState']}{ident}")
+    logger.end_step("success")
+
+    if target_config is not None:
+        region = target_config.region
+
+        def deployed_of(kind: str, states: Mapping[str, Any]) -> list[tuple[int, ResourceStatusEntry, Any]]:
+            return [
+                (i, e, states[e["name"]])
+                for i, e in enumerate(resources)
+                if e["resourceType"] == kind and e["deploymentState"] == "deployed" and states.get(e["name"])
+            ]
+
+        # Runtimes
+        agent_targets = deployed_of("agent", target_resources.get("runtimes") or {})
+        if agent_targets:
+            n = len(agent_targets)
+            logger.start_step(f"Fetch runtime status ({n} agent{'s' if n != 1 else ''})")
+            for i, entry, state in agent_targets:
+                url = build_runtime_invocation_url(region, entry["identifier"]) if entry["identifier"] else None
+                try:
+                    status = agentcore_control.get_agent_runtime_status(region=region, runtime_id=state["runtimeId"])
+                    resources[i] = {**entry, "detail": status["status"], "invocationUrl": url}
+                    logger.log(f"  {entry['name']}: {status['status']} ({state['runtimeId']})")
+                except Exception as exc:  # noqa: BLE001
+                    msg = get_error_message(exc)
+                    resources[i] = {**entry, "error": msg, "invocationUrl": url}
+                    logger.log(f"  {entry['name']}: ERROR - {msg}", "error")
+            logger.end_step("error" if any(r.get("error") for r in resources) else "success")
+
+        # Evaluators
+        eval_targets = deployed_of("evaluator", target_resources.get("evaluators") or {})
+        if eval_targets:
+            n = len(eval_targets)
+            logger.start_step(f"Fetch evaluator status ({n} evaluator{'s' if n != 1 else ''})")
+            for i, entry, state in eval_targets:
+                try:
+                    ev = agentcore_control.get_evaluator(region=region, evaluator_id=state["evaluatorId"])
+                    resources[i] = {**entry, "detail": f"{_js_str(entry['detail'])} — {ev['status']}"}
+                    logger.log(f"  {entry['name']}: {ev['status']} ({state['evaluatorId']})")
+                except Exception as exc:  # noqa: BLE001
+                    msg = get_error_message(exc)
+                    resources[i] = {**entry, "error": msg}
+                    logger.log(f"  {entry['name']}: ERROR - {msg}", "error")
+            logger.end_step(
+                "error" if any(r["resourceType"] == "evaluator" and r.get("error") for r in resources) else "success"
+            )
+
+        # Online eval configs
+        oe_targets = deployed_of("online-eval", target_resources.get("onlineEvalConfigs") or {})
+        if oe_targets:
+            n = len(oe_targets)
+            logger.start_step(f"Fetch online eval status ({n} config{'s' if n != 1 else ''})")
+            for i, entry, state in oe_targets:
+                try:
+                    cfg = agentcore_control.get_online_evaluation_config(
+                        region=region, config_id=state["onlineEvaluationConfigId"]
+                    )
+                    label = f"{cfg['status']} ({cfg['executionStatus']})"
+                    resources[i] = {**entry, "detail": f"{entry['detail']} — {label}" if entry["detail"] else label}
+                    logger.log(f"  {entry['name']}: {label} ({state['onlineEvaluationConfigId']})")
+                except Exception as exc:  # noqa: BLE001
+                    msg = get_error_message(exc)
+                    resources[i] = {**entry, "error": msg}
+                    logger.log(f"  {entry['name']}: ERROR - {msg}", "error")
+            logger.end_step(
+                "error" if any(r["resourceType"] == "online-eval" and r.get("error") for r in resources) else "success"
+            )
+
+        # Knowledge bases
+        kb_targets = deployed_of("knowledge-base", target_resources.get("knowledgeBases") or {})
+        if kb_targets:
+            n = len(kb_targets)
+            logger.start_step(f"Fetch knowledge base status ({n} KB{'s' if n != 1 else ''})")
+            wiring = _kb_wiring(project)
+            for i, entry, state in kb_targets:
+                try:
+                    live = bedrock_agent.get_knowledge_base(region=region, knowledge_base_id=state["knowledgeBaseId"])
+                    if not live:
+                        out_of_sync = "out of sync (KB deleted out of band)"
+                        detail = f"{entry['detail']} — {out_of_sync}" if entry["detail"] else out_of_sync
+                        resources[i] = {**entry, "detail": detail}
+                        logger.log(f"  {entry['name']}: KB {state['knowledgeBaseId']} not found", "error")
+                        continue
+                    data_sources = []
+                    for ds in state.get("dataSources") or []:
+                        job = bedrock_agent.get_latest_ingestion_job(
+                            region=region, knowledge_base_id=state["knowledgeBaseId"], data_source_id=ds["dataSourceId"]
+                        )
+                        if not job:
+                            data_sources.append(KbDataSourceDetail(ds["uri"], ds["dataSourceId"]))
+                            continue
+                        stats = job.get("statistics") or {}
+                        succeeded = job.get("status") == "COMPLETE"
+                        data_sources.append(
+                            KbDataSourceDetail(
+                                ds["uri"],
+                                ds["dataSourceId"],
+                                KbIngestionDetail(
+                                    status=job.get("status"),
+                                    started_at=_iso(job.get("startedAt")),
+                                    updated_at=_iso(job.get("updatedAt")),
+                                    completed_at=_iso(job.get("updatedAt")) if succeeded else None,
+                                    scanned=stats.get("numberOfDocumentsScanned"),
+                                    indexed=stats.get("numberOfNewDocumentsIndexed"),
+                                    modified=stats.get("numberOfModifiedDocumentsIndexed"),
+                                    failed=stats.get("numberOfDocumentsFailed"),
+                                    deleted=stats.get("numberOfDocumentsDeleted"),
+                                ),
+                            )
+                        )
+                    kb = KbStatusDetail(
+                        name=entry["name"],
+                        knowledge_base_id=state["knowledgeBaseId"],
+                        status=live.get("status"),
+                        gateway_names=list(wiring.get(entry["name"], [])),
+                        data_sources=data_sources,
+                    )
+                    if knowledge_base_name:
+                        if entry["name"] == knowledge_base_name:
+                            for line in format_knowledge_base_detail(kb):
+                                logger.log(line)
+                    else:
+                        logger.log(format_knowledge_base_summary_line(kb))
+                    first = next((d for d in data_sources if d.ingestion), None)
+                    summary = (
+                        f"Ingestion: {first.ingestion.status}"
+                        if first and first.ingestion and first.ingestion.status
+                        else "Ingestion: never run"
+                    )
+                    enriched = f"Status: {live.get('status') or 'UNKNOWN'} — {summary}"
+                    resources[i] = {
+                        **entry,
+                        "detail": f"{entry['detail']} — {enriched}" if entry["detail"] else enriched,
+                    }
+                except Exception as exc:  # noqa: BLE001
+                    msg = get_error_message(exc)
+                    resources[i] = {**entry, "error": msg}
+                    logger.log(f"  {entry['name']}: ERROR - {msg}", "error")
+            logger.end_step(
+                "error"
+                if any(r["resourceType"] == "knowledge-base" and r.get("error") for r in resources)
+                else "success"
+            )
+
+        # Payments
+        pay_targets = deployed_of("payment", target_resources.get("payments") or {})
+        if pay_targets:
+            n = len(pay_targets)
+            logger.start_step(f"Fetch payment status ({n} manager{'s' if n != 1 else ''})")
+            for i, entry, state in pay_targets:
+                connectors = state.get("connectors") or {}
+                connector_count = len(connectors)
+                try:
+                    manager = agentcore_payments.get_payment_manager(
+                        region=region, payment_manager_id=state["managerId"]
+                    )
+                    status = (manager or {}).get("status") or "unknown"
+                    resources[i] = {**entry, "detail": f"{status} — {connector_count} connector(s)"}
+                    logger.log(f"  {entry['name']}: {status} ({state['managerId']})")
+                except Exception as exc:  # noqa: BLE001
+                    msg = get_error_message(exc)
+                    resources[i] = {**entry, "detail": f"unknown — {connector_count} connector(s)", "error": msg}
+                    logger.log(f"  {entry['name']}: unknown (fetch failed) - {msg}", "error")
+
+                statuses = []
+                for connector_name, connector_state in connectors.items():
+                    connector_id = connector_state["connectorId"]
+                    try:
+                        detail = agentcore_payments.get_payment_connector(
+                            region=region, payment_manager_id=state["managerId"], payment_connector_id=connector_id
+                        )
+                        if not detail:
+                            statuses.append(
+                                {
+                                    "name": connector_name,
+                                    "connectorId": connector_id,
+                                    "status": "NOT_FOUND",
+                                    "error": "Connector was not found by the Payments service",
+                                }
+                            )
+                            continue
+                        arn = next(
+                            (
+                                (c.get("coinbaseCDP") or {}).get("credentialProviderArn")
+                                or (c.get("stripePrivy") or {}).get("credentialProviderArn")
+                                for c in detail.get("credentialProviderConfigurations") or []
+                                if (c.get("coinbaseCDP") or {}).get("credentialProviderArn")
+                                or (c.get("stripePrivy") or {}).get("credentialProviderArn")
+                            ),
+                            None,
+                        )
+                        record: dict[str, Any] = {
+                            "name": connector_name,
+                            "connectorId": connector_id,
+                            "status": detail.get("status"),
+                        }
+                        if detail.get("status") == "PENDING_AUTHENTICATION" and detail.get("authorizationUrl"):
+                            record["authorizationUrl"] = detail["authorizationUrl"]
+                        if arn:
+                            record["credentialProviderArn"] = arn
+                        statuses.append(record)
+                    except Exception as exc:  # noqa: BLE001
+                        statuses.append(
+                            {
+                                "name": connector_name,
+                                "connectorId": connector_id,
+                                "status": "UNKNOWN",
+                                "error": get_error_message(exc),
+                            }
+                        )
+                resources[i] = {**resources[i], "paymentConnectors": statuses}
+                for c in statuses:
+                    suffix = f" - {c['error']}" if c.get("error") else ""
+                    logger.log(
+                        f"    {c['name']}: {c['status']} ({c['connectorId']}){suffix}",
+                        "error" if c.get("error") else None,
+                    )
+            logger.end_step(
+                "error" if any(r["resourceType"] == "payment" and r.get("error") for r in resources) else "success"
+            )
+
+    logger.finalize(True)
+    return ProjectStatusResult(
+        success=True,
+        project_name=project.name,
+        target_name=selected or "",
+        target_region=target_config.region if target_config is not None else None,
+        resources=resources,
+        deployed_state=deployed_state,
+        log_path=logger.get_relative_log_path(),
+    )
+
+
+def _js_str(value: Any) -> str:
+    """Template-literal stringification (``undefined`` -> ``"undefined"``)."""
+    return "undefined" if value is None else str(value)
+
+
+def handle_runtime_lookup(
+    context: StatusContext, *, agent_runtime_id: str, target_name: str | None = None
+) -> RuntimeLookupResult:
+    logger = ExecLogger(command="status")
+    aws_targets = context.aws_targets
+
+    logger.start_step("Resolve target")
+    names = [t.name for t in aws_targets]
+    if not names:
+        error = "No deployment targets found. Run `agentcore create` first."
+        logger.end_step("error", error)
+        logger.finalize(False)
+        return RuntimeLookupResult(False, ResourceNotFoundError(error), log_path=logger.get_relative_log_path())
+
+    selected = target_name or names[0]
+    if target_name and target_name not in names:
+        error = f"Target '{target_name}' not found. Available: {', '.join(names)}"
+        logger.end_step("error", error)
+        logger.finalize(False)
+        return RuntimeLookupResult(False, ResourceNotFoundError(error), log_path=logger.get_relative_log_path())
+
+    target_config = next((t for t in aws_targets if t.name == selected), None)
+    if target_config is None:  # pragma: no cover - unreachable given the checks above
+        error = f"Target config '{selected}' not found in aws-targets"
+        logger.end_step("error", error)
+        logger.finalize(False)
+        return RuntimeLookupResult(False, ResourceNotFoundError(error), log_path=logger.get_relative_log_path())
+
+    logger.log(f"Target: {selected} ({target_config.region})")
+    logger.end_step("success")
+
+    logger.start_step(f"Lookup runtime {agent_runtime_id}")
+    try:
+        status = agentcore_control.get_agent_runtime_status(region=target_config.region, runtime_id=agent_runtime_id)
+        logger.log(f"Runtime: {status['runtimeId']} — {status['status']}")
+        logger.end_step("success")
+        logger.finalize(True)
+        return RuntimeLookupResult(
+            True,
+            target_name=selected,
+            runtime_id=status["runtimeId"],
+            runtime_status=status["status"],
+            log_path=logger.get_relative_log_path(),
+        )
+    except Exception as exc:  # noqa: BLE001
+        logger.end_step("error", get_error_message(exc))
+        logger.finalize(False)
+        return RuntimeLookupResult(False, exc, log_path=logger.get_relative_log_path())
+
+
+__all__ = [
+    "ProjectStatusResult",
+    "ResourceStatusEntry",
+    "RuntimeLookupResult",
+    "StatusContext",
+    "compute_resource_statuses",
+    "handle_project_status",
+    "handle_runtime_lookup",
+    "load_status_config",
+]