agentcore-cli 0.31.1__py3-none-any.whl

agentcore/cli/commands/add/validate.py

@@ -0,0 +1,333 @@
+"""Validation for `agentcore add <kind>` flags (port of src/cli/commands/add/validate.ts).
+
+Ported here: agent, memory, dataset, credential. Gateway, gateway-target and harness validation
+belong to the areas that own those primitives.
+
+``options`` is a dict keyed by the upstream option names; like upstream, validators normalize
+some values in place (enum casing, lifecycle numbers).
+"""
+
+from typing import Any, Final
+
+from agentcore.cli.commands.add._common import ValidationResult, first_issue, js_url_ok, parse_json
+from agentcore.cli.commands.add.auth_options import validate_jwt_authorizer_options
+from agentcore.cli.commands.shared.arn_utils import ARN_VALIDATION_MESSAGE, is_valid_arn
+from agentcore.cli.commands.shared.header_utils import validate_header_allowlist
+from agentcore.cli.commands.shared.indexed_key_parser import MAX_INDEXED_KEYS, parse_indexed_key_arg
+from agentcore.cli.commands.shared.lifecycle_utils import parse_and_validate_lifecycle_options
+from agentcore.cli.commands.shared.vpc_utils import validate_vpc_options
+from agentcore.schema import (
+    BUILD_TYPES,
+    DATASET_SCHEMA_TYPES,
+    MODEL_PROVIDERS,
+    PROTOCOL_MODES,
+    RUNTIME_AUTHORIZER_TYPES,
+    SDK_FRAMEWORKS,
+    TARGET_LANGUAGES,
+    AgentName,
+    DatasetName,
+    SessionStorage,
+    StreamDeliveryResources,
+    get_frameworks_for_language,
+    get_supported_frameworks_for_protocol,
+    get_supported_model_providers,
+    is_framework_supported_for_language,
+    is_valid_kms_key_arn,
+    match_enum_value,
+    match_sdk_framework,
+)
+from agentcore.templates import apply_template_option_defaults, validate_template_options
+
+__all__ = [
+    "DEFAULT_DELIVERY_TYPE",
+    "MEMORY_OPTIONS",
+    "ValidationResult",
+    "apply_lifecycle",
+    "session_storage_mount_path_issue",
+    "validate_add_agent_options",
+    "validate_add_credential_options",
+    "validate_add_dataset_options",
+    "validate_add_memory_options",
+]
+
+MEMORY_OPTIONS: Final = ("none", "shortTerm", "longAndShortTerm")
+VALID_STRATEGIES: Final = ("SEMANTIC", "SUMMARIZATION", "USER_PREFERENCE", "EPISODIC")
+VALID_STREAM_CONTENT_LEVELS: Final = ("FULL_CONTENT", "METADATA_ONLY")
+VALID_DELIVERY_TYPES: Final = ("kinesis",)
+DEFAULT_DELIVERY_TYPE: Final = "kinesis"
+
+
+def _normalize(options: dict[str, Any], key: str, values: Any) -> None:
+    if options.get(key):
+        options[key] = match_enum_value(values, options[key]) or options[key]
+
+
+def session_storage_mount_path_issue(path: str) -> str | None:
+    """``SessionStorageSchema.shape.mountPath.safeParse`` first issue."""
+    issue = first_issue(SessionStorage, {"mountPath": path})
+    return issue
+
+
+def apply_lifecycle(options: dict[str, Any]) -> ValidationResult | None:
+    """Parse/validate idleTimeout/maxLifetime in place; returns a failure result or None."""
+    result = parse_and_validate_lifecycle_options(options)
+    if not result.valid:
+        return ValidationResult(False, result.error)
+    if result.idle_timeout is not None:
+        options["idleTimeout"] = result.idle_timeout
+    if result.max_lifetime is not None:
+        options["maxLifetime"] = result.max_lifetime
+    return None
+
+
+def validate_add_agent_options(options: dict[str, Any]) -> ValidationResult:
+    _normalize(options, "protocol", PROTOCOL_MODES)
+    if options.get("framework"):
+        options["framework"] = match_sdk_framework(options["framework"]) or options["framework"]
+    _normalize(options, "modelProvider", MODEL_PROVIDERS)
+    _normalize(options, "language", TARGET_LANGUAGES)
+    _normalize(options, "build", BUILD_TYPES)
+
+    apply_template_option_defaults(options.get("framework"), options)
+    template_error = validate_template_options(options.get("framework"), options)
+    if template_error:
+        return ValidationResult(False, template_error)
+
+    if options.get("sessionStorageMountPath") and options.get("language") == "TypeScript":
+        return ValidationResult(False, "--session-storage-mount-path is not supported for TypeScript agents")
+
+    if not options.get("name"):
+        return ValidationResult(False, "--name is required")
+    issue = first_issue(AgentName, options["name"])
+    if issue:
+        return ValidationResult(False, issue)
+
+    if options.get("build") and options["build"] not in BUILD_TYPES:
+        return ValidationResult(False, f"Invalid build type: {options['build']}. Use CodeZip or Container")
+
+    protocol = options.get("protocol") or "HTTP"
+    if protocol not in PROTOCOL_MODES:
+        return ValidationResult(False, f"Invalid protocol: {protocol}. Use HTTP, MCP, A2A, or AGUI")
+    options["protocol"] = protocol
+
+    if protocol != "HTTP" and options.get("language") == "TypeScript":
+        return ValidationResult(
+            False, f"{protocol} protocol is not yet supported for TypeScript. Use --protocol HTTP or --language Python."
+        )
+
+    is_byo = options.get("type") == "byo"
+    if options.get("type") == "import":
+        if not options.get("agentId"):
+            return ValidationResult(False, "--agent-id is required for import path")
+        if not options.get("agentAliasId"):
+            return ValidationResult(False, "--agent-alias-id is required for import path")
+        if not options.get("region"):
+            return ValidationResult(False, "--region is required for import path")
+        if not options.get("framework"):
+            return ValidationResult(False, "--framework is required for import path")
+        if options["framework"] not in ("Strands", "LangChain_LangGraph"):
+            return ValidationResult(False, "Import path only supports Strands or LangChain_LangGraph frameworks")
+        if not options.get("memory"):
+            return ValidationResult(False, "--memory is required for import path")
+        if options["memory"] not in MEMORY_OPTIONS:
+            return ValidationResult(
+                False, f"Invalid memory option: {options['memory']}. Use none, shortTerm, or longAndShortTerm"
+            )
+        if failure := apply_lifecycle(options):
+            return failure
+        options["modelProvider"] = "Bedrock"
+        options["language"] = "Python"
+        return ValidationResult(True)
+
+    if protocol == "MCP":
+        if options.get("framework"):
+            return ValidationResult(False, "--framework is not applicable for MCP protocol")
+        if options.get("modelProvider"):
+            return ValidationResult(False, "--model-provider is not applicable for MCP protocol")
+        if options.get("memory") and options["memory"] != "none":
+            return ValidationResult(False, "--memory is not applicable for MCP protocol")
+        if not options.get("language"):
+            return ValidationResult(False, "--language is required")
+        if options["language"] not in TARGET_LANGUAGES:
+            return ValidationResult(False, f"Invalid language: {options['language']}")
+        if is_byo and not options.get("codeLocation"):
+            return ValidationResult(False, "--code-location is required for BYO path")
+        if failure := apply_lifecycle(options):
+            return failure
+        return ValidationResult(True)
+
+    framework = options.get("framework")
+    if not framework:
+        return ValidationResult(False, "--framework is required")
+    if framework not in SDK_FRAMEWORKS:
+        return ValidationResult(False, f"Invalid framework: {framework}")
+    if protocol != "HTTP" and framework not in get_supported_frameworks_for_protocol(protocol):  # type: ignore[arg-type]
+        return ValidationResult(False, f"{framework} does not support {protocol} protocol")
+
+    provider = options.get("modelProvider")
+    if not provider:
+        return ValidationResult(False, "--model-provider is required")
+    if provider not in MODEL_PROVIDERS:
+        return ValidationResult(False, f"Invalid model provider: {provider}")
+    if provider not in get_supported_model_providers(framework):  # type: ignore[arg-type]
+        return ValidationResult(False, f"{framework} does not support {provider}")
+
+    language = options.get("language")
+    if not language:
+        return ValidationResult(False, "--language is required")
+    if language not in TARGET_LANGUAGES:
+        return ValidationResult(False, f"Invalid language: {language}")
+
+    if is_byo:
+        if not options.get("codeLocation"):
+            return ValidationResult(False, "--code-location is required for BYO path")
+    else:
+        if language == "Other":
+            return ValidationResult(False, "Create path only supports Python or TypeScript")
+        if language in ("Python", "TypeScript") and not is_framework_supported_for_language(language, framework):  # type: ignore[arg-type]
+            supported = ", ".join(get_frameworks_for_language(language))  # type: ignore[arg-type]
+            return ValidationResult(
+                False, f"Framework {framework} is not yet available for {language}. Supported: {supported}."
+            )
+        if not options.get("memory"):
+            return ValidationResult(False, "--memory is required for create path")
+        if options["memory"] not in MEMORY_OPTIONS:
+            return ValidationResult(
+                False, f"Invalid memory option: {options['memory']}. Use none, shortTerm, or longAndShortTerm"
+            )
+
+    if options.get("requestHeaderAllowlist"):
+        header_result = validate_header_allowlist(options["requestHeaderAllowlist"])
+        if not header_result.success:
+            return ValidationResult(False, header_result.error)
+
+    if failure := apply_lifecycle(options):
+        return failure
+
+    if options.get("sessionStorageMountPath"):
+        issue = session_storage_mount_path_issue(options["sessionStorageMountPath"])
+        if issue:
+            return ValidationResult(False, f"--session-storage-mount-path: {issue}")
+
+    vpc_result = validate_vpc_options(options, options.get("build"))
+    if not vpc_result.valid:
+        return ValidationResult(False, vpc_result.error)
+
+    if options.get("authorizerType"):
+        if options["authorizerType"] not in RUNTIME_AUTHORIZER_TYPES:
+            return ValidationResult(False, "Invalid authorizer type. Use AWS_IAM or CUSTOM_JWT")
+        if options["authorizerType"] == "CUSTOM_JWT":
+            jwt_result = validate_jwt_authorizer_options(options)
+            if not jwt_result.valid:
+                return jwt_result
+
+    if options.get("clientId") and options.get("authorizerType") != "CUSTOM_JWT":
+        return ValidationResult(False, "OAuth client credentials are only valid with CUSTOM_JWT authorizer")
+
+    return ValidationResult(True)
+
+
+def validate_add_memory_options(options: dict[str, Any]) -> ValidationResult:
+    if not options.get("name"):
+        return ValidationResult(False, "--name is required")
+
+    strategies_raw = options.get("strategies")
+    if strategies_raw:
+        for strategy in (s.strip() for s in strategies_raw.split(",")):
+            if strategy and strategy not in VALID_STRATEGIES:
+                return ValidationResult(
+                    False, f"Invalid strategy: {strategy}. Must be one of: {', '.join(VALID_STRATEGIES)}"
+                )
+
+    indexed = options.get("indexedKey")
+    if indexed:
+        ltm = [s.strip().upper() for s in (strategies_raw or "").split(",") if s.strip()]
+        if not ltm:
+            return ValidationResult(
+                False,
+                "--indexed-key requires at least one long-term memory strategy (--strategies). Indexed keys filter "
+                "long-term memory records on retrieval.",
+            )
+        if len(indexed) > MAX_INDEXED_KEYS:
+            return ValidationResult(False, f"Maximum {MAX_INDEXED_KEYS} indexed keys allowed")
+        seen: set[str] = set()
+        for raw in indexed:
+            parsed = parse_indexed_key_arg(raw)
+            if not parsed.ok:
+                return ValidationResult(False, parsed.error)
+            key = parsed.value["key"]  # type: ignore[index]
+            if key in seen:
+                return ValidationResult(False, f'Duplicate indexed key: "{key}"')
+            seen.add(key)
+
+    data_stream_arn = options.get("dataStreamArn")
+    content_level = options.get("contentLevel")
+    delivery_type = options.get("deliveryType")
+    stream_resources = options.get("streamDeliveryResources")
+
+    if stream_resources and (data_stream_arn or content_level or delivery_type):
+        return ValidationResult(
+            False,
+            "--stream-delivery-resources cannot be combined with --data-stream-arn, --stream-content-level, or "
+            "--delivery-type",
+        )
+    if content_level and not data_stream_arn:
+        return ValidationResult(False, "--data-stream-arn is required when --stream-content-level is set")
+    if delivery_type and not data_stream_arn:
+        return ValidationResult(False, "--data-stream-arn is required when --delivery-type is set")
+    if data_stream_arn and not is_valid_arn(data_stream_arn):
+        return ValidationResult(False, f"--data-stream-arn: {ARN_VALIDATION_MESSAGE}")
+    if delivery_type and delivery_type not in VALID_DELIVERY_TYPES:
+        return ValidationResult(False, f"Invalid delivery type. Must be one of: {', '.join(VALID_DELIVERY_TYPES)}")
+    if content_level and content_level not in VALID_STREAM_CONTENT_LEVELS:
+        return ValidationResult(
+            False, f"Invalid content level. Must be one of: {', '.join(VALID_STREAM_CONTENT_LEVELS)}"
+        )
+    if stream_resources:
+        ok, parsed_json = parse_json(stream_resources)
+        if not ok:
+            return ValidationResult(False, "Invalid JSON in --stream-delivery-resources")
+        if first_issue(StreamDeliveryResources, parsed_json):
+            return ValidationResult(False, "Invalid --stream-delivery-resources: does not match the expected schema")
+
+    return ValidationResult(True)
+
+
+def validate_add_dataset_options(options: dict[str, Any]) -> ValidationResult:
+    if not options.get("name"):
+        return ValidationResult(False, "--name is required")
+    issue = first_issue(DatasetName, options["name"])
+    if issue:
+        return ValidationResult(False, issue)
+    schema_type = options.get("schemaType")
+    if not schema_type:
+        return ValidationResult(False, "--schema-type is required")
+    if schema_type not in DATASET_SCHEMA_TYPES:
+        return ValidationResult(
+            False, f"Invalid schema type: {schema_type}. Valid options: {', '.join(DATASET_SCHEMA_TYPES)}"
+        )
+    if options.get("kmsKeyArn") and not is_valid_kms_key_arn(options["kmsKeyArn"]):
+        return ValidationResult(
+            False,
+            "--kms-key-arn must be a valid KMS key ARN (e.g. "
+            "arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012)",
+        )
+    return ValidationResult(True)
+
+
+def validate_add_credential_options(options: dict[str, Any]) -> ValidationResult:
+    if not options.get("name"):
+        return ValidationResult(False, "--name is required")
+    if (options.get("type") or "api-key") == "oauth":
+        if not options.get("discoveryUrl"):
+            return ValidationResult(False, "--discovery-url is required for OAuth credentials")
+        if not js_url_ok(options["discoveryUrl"]):
+            return ValidationResult(False, "--discovery-url must be a valid URL")
+        if not options.get("clientId"):
+            return ValidationResult(False, "--client-id is required for OAuth credentials")
+        if not options.get("clientSecret"):
+            return ValidationResult(False, "--client-secret is required for OAuth credentials")
+        return ValidationResult(True)
+    if not options.get("apiKey"):
+        return ValidationResult(False, "--api-key is required")
+    return ValidationResult(True)

agentcore/cli/commands/capacity_provider/__init__.py

@@ -0,0 +1,86 @@
+"""`agentcore capacity-provider delete-session` (port of src/cli/commands/capacity-provider)."""
+
+import json
+import sys
+
+import typer
+
+from agentcore.cli.commands.capacity_provider.action import (
+    execute_delete_capacity_provider_session,
+    resolve_delete_target,
+)
+from agentcore.cli.commands.capacity_provider.constants import (
+    CAPACITY_PROVIDER_SESSION_ID_MAX_LENGTH,
+    is_valid_capacity_provider_session_id,
+)
+from agentcore.cli.errors import get_error_message
+from agentcore.cli.groups import group
+
+
+def confirm_destructive_delete(display_name: str, session_id: str) -> bool:
+    """y/N prompt; False on bare Enter or non-TTY stdin so the delete never proceeds implicitly."""
+    if not sys.stdin.isatty():
+        return False
+    sys.stdout.write(
+        f'\n⚠  Deleting session "{session_id}" on capacity provider "{display_name}" will deprovision its '
+        "EC2 instance and permanently delete any persistent EBS volumes on the session. This cannot be undone.\n"
+    )
+    sys.stdout.flush()
+    try:
+        answer = input("Continue? [y/N] ").strip().lower()
+    except EOFError:
+        return False
+    return answer in ("y", "yes")
+
+
+def delete_session(
+    capacity_provider: str = typer.Option(
+        ...,
+        "--capacity-provider",
+        metavar="NAME-ID-OR-ARN",
+        help="Capacity provider: an in-project name, a capacity provider id, or an ARN. The data-plane API is "
+        "keyed on the id; a name is resolved to its id via deployed state.",
+    ),
+    session_id: str = typer.Option(..., "--session-id", metavar="ID", help="Session id to delete"),
+    region: str | None = typer.Option(
+        None, "--region", help="AWS region (auto-detected from the ARN / project otherwise)"
+    ),
+    yes: bool = typer.Option(False, "--yes", help="Skip the destructive confirmation prompt"),
+    as_json: bool = typer.Option(False, "--json", help="Output as JSON"),
+) -> None:
+    try:
+        if not is_valid_capacity_provider_session_id(session_id):
+            raise ValueError(
+                f'Invalid --session-id "{session_id}". Must be 1-{CAPACITY_PROVIDER_SESSION_ID_MAX_LENGTH} '
+                "characters, start with an alphanumeric, and contain only letters, digits, hyphens, and underscores."
+            )
+        target = resolve_delete_target(capacity_provider=capacity_provider, session_id=session_id, region=region)
+        if not yes and not confirm_destructive_delete(target.display_name, session_id):
+            raise RuntimeError(
+                "Aborted — session was not deleted."
+                if sys.stdin.isatty()
+                else "Refusing to delete a capacity provider session without confirmation. "
+                "Re-run with --yes to skip the prompt."
+            )
+        result = execute_delete_capacity_provider_session(target, session_id)
+        if as_json:
+            typer.echo(json.dumps({"success": True, **result}, separators=(",", ":")))
+        else:
+            typer.echo(f'Deprovisioning session "{result.get("sessionId") or session_id}" (asynchronous)…')
+            typer.echo(f"  Status:            {result.get('status') or 'Deprovisioning'}")
+            cp = result.get("capacityProviderArn") or target.capacity_provider_arn or target.display_name
+            typer.echo(f"  Capacity provider: {cp}")
+    except Exception as exc:  # noqa: BLE001 - runCliCommand 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(app: typer.Typer) -> None:
+    group("capacity-provider").command(
+        "delete-session",
+        help="Delete (deprovision) a live capacity provider session. Terminates its EC2 instance and deletes any "
+        "persistent EBS volumes.",
+    )(delete_session)

agentcore/cli/commands/capacity_provider/action.py

@@ -0,0 +1,114 @@
+"""Port of src/cli/commands/capacity-provider/action.ts."""
+
+from dataclasses import dataclass
+
+from agentcore.aws import agentcore as agentcore_api
+from agentcore.aws import region as region_mod
+from agentcore.aws.arn import region_from_arn
+from agentcore.cli.commands.capacity_provider.constants import is_capacity_provider_id
+from agentcore.lib.schemas.io.config_io import ConfigIO
+from agentcore.lib.schemas.io.path_resolver import find_config_root
+from agentcore.schema.schemas.primitives.capacity_provider import is_capacity_provider_arn
+
+
+@dataclass
+class ResolvedDeleteTarget:
+    capacity_provider_id: str
+    region: str
+    target_by_arn: bool
+    """True when targeted by raw ARN (no project needed)."""
+    display_name: str
+    capacity_provider_arn: str | None = None
+
+
+def _capacity_provider_id_from_arn(arn: str) -> str:
+    return arn.split("/")[-1] or arn
+
+
+def _detect_region() -> str:
+    return region_mod.detect_region().region
+
+
+def resolve_delete_target(
+    *, capacity_provider: str, session_id: str, region: str | None = None
+) -> ResolvedDeleteTarget:
+    """Resolve id + region from an ARN, a literal id, or an in-project name (via deployed state)."""
+    # (1) External CP by ARN.
+    if is_capacity_provider_arn(capacity_provider):
+        arn = capacity_provider
+        return ResolvedDeleteTarget(
+            capacity_provider_id=_capacity_provider_id_from_arn(arn),
+            capacity_provider_arn=arn,
+            region=region or region_from_arn(arn) or _detect_region(),
+            target_by_arn=True,
+            display_name=arn,
+        )
+
+    # (2) A literal capacity provider id.
+    if is_capacity_provider_id(capacity_provider):
+        return ResolvedDeleteTarget(
+            capacity_provider_id=capacity_provider,
+            region=region or _detect_region(),
+            target_by_arn=False,
+            display_name=capacity_provider,
+        )
+
+    # (3) An in-project name.
+    name = capacity_provider
+    config_root = find_config_root()
+    if not config_root:
+        raise RuntimeError(
+            f'No AgentCore project found. Run inside a project to reference "{name}" by name, '
+            "or pass the capacity provider id or ARN."
+        )
+    deployed = ConfigIO(base_dir=config_root).read_deployed_state()
+
+    matches = []
+    for target in (deployed.targets or {}).values():
+        resources = target.resources
+        record = ((resources.capacity_providers if resources else None) or {}).get(name)
+        if record:
+            matches.append((record, region_from_arn(record.capacity_provider_arn)))
+
+    if not matches:
+        raise RuntimeError(
+            f'Capacity provider "{name}" is not deployed in this project. Deploy it first, '
+            "or pass its id or ARN with --capacity-provider."
+        )
+
+    deployed_regions = ", ".join(dict.fromkeys(r for _, r in matches if r))
+    if region:
+        in_region = [m for m in matches if m[1] == region]
+        if not in_region:
+            found = f" (found in: {deployed_regions})" if deployed_regions else ""
+            raise RuntimeError(
+                f'Capacity provider "{name}" is not deployed in region {region}{found}. Pass a matching --region, '
+                "or the capacity provider id or ARN with --capacity-provider."
+            )
+        if len(in_region) > 1:
+            raise RuntimeError(
+                f'Capacity provider "{name}" resolves to multiple deployments in region {region}. '
+                "Pass the capacity provider id or ARN with --capacity-provider to disambiguate."
+            )
+        record, record_region = in_region[0]
+    elif len(matches) > 1:
+        raise RuntimeError(
+            f'Capacity provider "{name}" is deployed in multiple regions ({deployed_regions}). '
+            "Pass --region to select one, or the capacity provider id or ARN with --capacity-provider."
+        )
+    else:
+        record, record_region = matches[0]
+
+    return ResolvedDeleteTarget(
+        capacity_provider_id=record.capacity_provider_id,
+        capacity_provider_arn=record.capacity_provider_arn,
+        region=region or record_region or _detect_region(),
+        target_by_arn=False,
+        display_name=name,
+    )
+
+
+def execute_delete_capacity_provider_session(target: ResolvedDeleteTarget, session_id: str):
+    return agentcore_api.delete_capacity_provider_session(
+        region=target.region, capacity_provider_id=target.capacity_provider_id, session_id=session_id
+    )

agentcore/cli/commands/capacity_provider/constants.py

@@ -0,0 +1,22 @@
+"""Port of src/cli/commands/capacity-provider/constants.ts."""
+
+import re
+
+# Matches the service `SessionId` shape: length 1-100, ^[a-zA-Z0-9][a-zA-Z0-9-_]*$.
+CAPACITY_PROVIDER_SESSION_ID_PATTERN = re.compile(r"^[a-zA-Z0-9][a-zA-Z0-9\-_]*$")
+CAPACITY_PROVIDER_SESSION_ID_MAX_LENGTH = 100
+
+
+def is_valid_capacity_provider_session_id(value: str) -> bool:
+    return (
+        1 <= len(value) <= CAPACITY_PROVIDER_SESSION_ID_MAX_LENGTH
+        and CAPACITY_PROVIDER_SESSION_ID_PATTERN.match(value) is not None
+    )
+
+
+# Capacity provider id shape (`{name}-{10 alnum}`); distinguishes an id from a bare project name.
+CAPACITY_PROVIDER_ID_PATTERN = re.compile(r"^[a-zA-Z][a-zA-Z0-9_]{0,47}-[a-zA-Z0-9]{10}$")
+
+
+def is_capacity_provider_id(value: str) -> bool:
+    return CAPACITY_PROVIDER_ID_PATTERN.match(value) is not None

agentcore/cli/commands/config.py

@@ -0,0 +1,91 @@
+"""`agentcore config [key] [value]` (port of src/cli/commands/config)."""
+
+import json
+from typing import Any
+
+import typer
+
+from agentcore.lib.errors.types import ValidationError
+from agentcore.lib.result import Err, Ok
+from agentcore.lib.schemas.io.global_config import (
+    get_global_config_file,
+    read_global_config,
+    update_global_config,
+    validate_global_config,
+)
+from agentcore.lib.utils.json_format import to_json_string
+
+DESCRIPTION = "Adjust global configuration settings such as telemetry opt-out status"
+
+
+def handle_config_list() -> Ok[str] | Err[Exception]:
+    read = read_global_config()
+    if not read.success:
+        return Err(Exception(f"Error: Unable to parse config file at {get_global_config_file()}"))
+    return Ok(to_json_string(read.value, 2))
+
+
+def handle_config_get(key: str) -> Ok[str] | Err[Exception]:
+    read = read_global_config()
+    if not read.success:
+        return Err(Exception(f"Error: Unable to parse config file at {get_global_config_file()}"))
+    value = _get_by_path(read.value, key)
+    if value is None:
+        return Err(Exception(f'Key "{key}" is not set.'))
+    return Ok(to_json_string(value, 2))
+
+
+def handle_config_set(key: str, raw: str) -> Ok[str] | Err[Exception]:
+    partial = _build_nested_object(key, _parse_value(raw))
+    if not validate_global_config(partial).success:
+        return Err(ValidationError(f'Invalid value "{raw}" for key "{key}".'))
+    if not update_global_config(partial):
+        return Err(Exception(f"Error: Unable to write config file at {get_global_config_file()}"))
+    return Ok(f"Set {key} = {raw}")
+
+
+def _parse_value(raw: str) -> Any:
+    try:
+        return json.loads(raw)
+    except ValueError:
+        return raw
+
+
+def _get_by_path(obj: Any, path: str) -> Any:
+    current = obj
+    for part in path.split("."):
+        if not isinstance(current, dict):
+            return None
+        current = current.get(part)
+    return current
+
+
+def _build_nested_object(path: str, value: Any) -> dict[str, Any]:
+    *parents, leaf = path.split(".")
+    result: dict[str, Any] = {}
+    inner = result
+    for part in parents:
+        inner[part] = {}
+        inner = inner[part]
+    inner[leaf] = value
+    return result
+
+
+def register(app: typer.Typer) -> None:
+    @app.command("config", help=DESCRIPTION)
+    def config(
+        key: str | None = typer.Argument(None, help="Config key in dot notation (e.g. telemetry.enabled)"),
+        value: str | None = typer.Argument(None, help="Value to set"),
+    ) -> None:
+        if key is None:
+            result = handle_config_list()
+        elif value is None:
+            result = handle_config_get(key)
+        else:
+            result = handle_config_set(key, value)
+
+        if result.success:
+            typer.echo(result.value)
+        else:
+            typer.echo(str(result.error), err=True)
+            raise typer.Exit(1)