agentcore-cli 0.31.1__py3-none-any.whl

agentcore/primitives/config_bundle.py

@@ -0,0 +1,329 @@
+"""Configuration bundle add/remove (port of src/cli/primitives/ConfigBundlePrimitive.ts).
+
+Bundles are versioned collections of component configurations keyed by component ARN or
+``{{runtime:<name>}}`` / ``{{gateway:<name>}}`` placeholders.
+"""
+
+import json
+import re
+from dataclasses import dataclass
+from typing import Any
+
+import typer
+
+from agentcore.cli import interactive
+from agentcore.cli.commands.add._common import first_issue
+from agentcore.cli.errors import get_error_message
+from agentcore.cli.naming import generate_unique_name
+from agentcore.lib import ResourceNotFoundError, find_config_root, serialize_result
+from agentcore.lib.errors.types import to_error
+from agentcore.lib.result import Err, Ok
+from agentcore.lib.schemas.io.config_io import to_jsonable
+from agentcore.primitives.base import BasePrimitive, RemovableResource, RemovalPreview, SchemaChange, emit_json
+from agentcore.schema import is_valid_kms_key_arn
+from agentcore.schema.schemas.primitives.config_bundle import ConfigBundleName
+
+COMPONENT_KEY_PATTERN = re.compile(r"^[a-zA-Z][a-zA-Z0-9_:/.-]{0,2047}$")
+COMPONENT_KEY_ERROR = "Must be a valid component identifier (an ARN, max 2048 chars)."
+COMPONENT_TYPE_OPTIONS = (
+    ("runtime", "Agent Runtime", "Configure an agent runtime"),
+    ("gateway", "HTTP Gateway", "Configure an HTTP gateway"),
+    ("custom", "Other (ARN)", "Enter any component ARN (gateway target, etc.)"),
+)
+KMS_KEY_ERROR = (
+    "--kms-key must be a valid KMS key ARN "
+    "(e.g. arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012)"
+)
+
+
+@dataclass
+class AddConfigBundleOptions:
+    name: str
+    components: dict[str, Any]
+    description: str | None = None
+    branch_name: str | None = None
+    commit_message: str | None = None
+    kms_key_arn: str | None = None
+
+
+def validate_config_json(value: str) -> str | None:
+    try:
+        parsed = json.loads(value)
+    except ValueError:
+        return "Invalid JSON syntax"
+    if not isinstance(parsed, dict):
+        return "Must be a JSON object with key-value pairs"
+    return None
+
+
+class ConfigBundlePrimitive(BasePrimitive):
+    kind = "config-bundle"
+    label = "Configuration Bundle"
+    article = "a"
+
+    def _project(self) -> dict[str, Any]:
+        return to_jsonable(self.read_project_spec())
+
+    def add(self, options: AddConfigBundleOptions) -> Ok | Err:
+        try:
+            project = self._project()
+            bundles = project.get("configBundles") or []
+            self.check_duplicate([RemovableResource(b["name"]) for b in bundles], options.name)
+            bundle: dict[str, Any] = {"name": options.name, "type": "ConfigurationBundle"}
+            if options.description:
+                bundle["description"] = options.description
+            bundle["components"] = options.components
+            bundle["branchName"] = options.branch_name if options.branch_name is not None else "mainline"
+            if options.commit_message:
+                bundle["commitMessage"] = options.commit_message
+            if options.kms_key_arn:
+                bundle["kmsKeyArn"] = options.kms_key_arn
+            bundles.append(bundle)
+            project["configBundles"] = bundles
+            self.write_project_spec(project)
+            return Ok({"bundleName": options.name})
+        except Exception as exc:  # noqa: BLE001
+            return Err(to_error(exc))
+
+    def remove(self, name: str) -> Ok | Err:
+        try:
+            project = self._project()
+            bundles = project.get("configBundles") or []
+            index = next((i for i, b in enumerate(bundles) if b["name"] == name), -1)
+            if index == -1:
+                return Err(ResourceNotFoundError(f'Configuration bundle "{name}" not found.'))
+            bundles.pop(index)
+            project["configBundles"] = bundles
+            self.write_project_spec(project)
+            return Ok(None)
+        except Exception as exc:  # noqa: BLE001
+            return Err(to_error(exc))
+
+    def preview_remove(self, name: str) -> RemovalPreview:
+        project = self._project()
+        bundles = project.get("configBundles") or []
+        if not any(b["name"] == name for b in bundles):
+            raise Exception(f'Configuration bundle "{name}" not found.')
+        after = {**project, "configBundles": [b for b in bundles if b["name"] != name]}
+        return RemovalPreview(
+            [f"Removing configuration bundle: {name}"], [], [SchemaChange("agentcore/agentcore.json", project, after)]
+        )
+
+    def get_removable(self) -> list[RemovableResource]:
+        try:
+            return [RemovableResource(b["name"]) for b in self._project().get("configBundles") or []]
+        except Exception:  # noqa: BLE001
+            return []
+
+    def get_all_names(self) -> list[str]:
+        return [r.name for r in self.get_removable()]
+
+    def register_commands(self, add_app: typer.Typer, remove_app: typer.Typer) -> None:
+        @add_app.command("config-bundle", help="Add a configuration bundle to the project")
+        def add_config_bundle(
+            name: str | None = typer.Option(None, "--name", help="Bundle name"),
+            description: str | None = typer.Option(None, "--description", help="Bundle description"),
+            components: str | None = typer.Option(
+                None,
+                "--components",
+                help="Components map as inline JSON. Keys are ARNs or placeholders: {{runtime:<name>}}, "
+                "{{gateway:<name>}}. Placeholders resolve to real ARNs at deploy time.",
+            ),
+            components_file: str | None = typer.Option(
+                None, "--components-file", help="Path to components JSON file (same format as --components)"
+            ),
+            branch: str | None = typer.Option(None, "--branch", help="Branch name for versioning"),
+            commit_message: str | None = typer.Option(None, "--commit-message", help="Commit message for this version"),
+            kms_key: str | None = typer.Option(
+                None, "--kms-key", help="KMS key ARN for encrypting the configuration bundle"
+            ),
+            as_json: bool = typer.Option(False, "--json", help="Output as JSON"),
+        ) -> None:
+            if not find_config_root():
+                typer.echo("No agentcore project found. Run `agentcore create` first.", err=True)
+                raise typer.Exit(1)
+
+            def fail(error: str) -> None:
+                if as_json:
+                    emit_json({"success": False, "error": error})
+                else:
+                    typer.echo(error, err=True)
+                raise typer.Exit(1)
+
+            try:
+                if not (name or as_json):
+                    self.add_interactive()
+                    raise typer.Exit(0)
+                if not name:
+                    fail("--name is required in non-interactive mode")
+                if not components and not components_file:
+                    fail("Either --components or --components-file is required")
+                if kms_key and not is_valid_kms_key_arn(kms_key):
+                    fail(KMS_KEY_ERROR)
+                if components_file:
+                    with open(components_file, encoding="utf-8") as fh:
+                        parsed = json.load(fh)
+                else:
+                    parsed = json.loads(components or "")
+                result = self.add(
+                    AddConfigBundleOptions(
+                        name=name or "",
+                        description=description,
+                        components=parsed,
+                        branch_name=branch,
+                        commit_message=commit_message,
+                        kms_key_arn=kms_key,
+                    )
+                )
+                if as_json:
+                    emit_json(serialize_result(result))
+                elif result.success:
+                    typer.echo(f"Added configuration bundle '{result.value['bundleName']}'")
+                else:
+                    typer.echo(get_error_message(result.error), err=True)
+                raise typer.Exit(0 if result.success else 1)
+            except typer.Exit:
+                raise
+            except Exception as exc:  # noqa: BLE001
+                if as_json:
+                    emit_json({"success": False, "error": get_error_message(exc)})
+                else:
+                    typer.echo(get_error_message(exc), err=True)
+                raise typer.Exit(1) from None
+
+        self.register_remove_subcommand(remove_app)
+
+    def _discover_components(self) -> list[dict[str, Any]]:
+        """Deployed runtimes/HTTP gateways, plus undeployed ones from the spec as placeholders."""
+        found: list[dict[str, Any]] = []
+        deployed_names: set[str] = set()
+        try:
+            deployed = to_jsonable(self.config_io.read_deployed_state())
+            for target in (deployed.get("targets") or {}).values():
+                resources = (target or {}).get("resources") or {}
+                for name, state in (resources.get("runtimes") or {}).items():
+                    found.append({"name": name, "arn": state["runtimeArn"], "type": "runtime"})
+                    deployed_names.add(name)
+                for name, state in (resources.get("gateways") or {}).items():
+                    found.append({"name": name, "arn": state["gatewayArn"], "type": "gateway"})
+                    deployed_names.add(name)
+        except Exception:  # noqa: BLE001, S110 - no deployed state yet
+            pass
+        try:
+            project = self._project()
+            for rt in project.get("runtimes") or []:
+                if rt["name"] not in deployed_names:
+                    found.append(
+                        {
+                            "name": rt["name"],
+                            "arn": f"{{{{runtime:{rt['name']}}}}}",
+                            "type": "runtime",
+                            "isPlaceholder": True,
+                        }
+                    )
+            for gw in project.get("agentCoreGateways") or []:
+                if gw.get("protocolType") == "None" and gw["name"] not in deployed_names:
+                    found.append(
+                        {
+                            "name": gw["name"],
+                            "arn": f"{{{{gateway:{gw['name']}}}}}",
+                            "type": "gateway",
+                            "isPlaceholder": True,
+                        }
+                    )
+        except Exception:  # noqa: BLE001, S110
+            pass
+        return found
+
+    def add_interactive(self) -> None:
+        """Prompt flow mirroring tui/screens/config-bundle/AddConfigBundleScreen."""
+        interactive.require_tty()
+        available = self._discover_components()
+        existing = self.get_all_names()
+        choice = interactive.Choice
+
+        def validate_name(value: str) -> str | None:
+            issue = first_issue(ConfigBundleName, value)
+            if issue:
+                return issue
+            return "Bundle name already exists" if value in existing else None
+
+        name = interactive.text(
+            "Bundle name", default=generate_unique_name("MyBundle", existing), validate=validate_name
+        )
+        description = interactive.text("Description (optional, press Enter to skip)")
+        components: dict[str, Any] = {}
+        while True:
+            component_type = interactive.select(
+                "What do you want to configure?", [choice(t, i, d) for i, t, d in COMPONENT_TYPE_OPTIONS]
+            )
+            if component_type == "custom":
+                typer.echo("Enter the component ARN")
+                typer.echo("The resource this configuration applies to (e.g. a gateway target).")
+                arn = interactive.text(
+                    "Component ARN", validate=lambda v: None if COMPONENT_KEY_PATTERN.match(v) else COMPONENT_KEY_ERROR
+                )
+            else:
+                candidates = [c for c in available if c["type"] == component_type and c["arn"] not in components]
+                if not candidates:
+                    typer.echo(f"No deployed {'runtimes' if component_type == 'runtime' else 'gateways'} found.")
+                    typer.echo("Deploy your resources first with `agentcore deploy`, then try again.")
+                    continue
+                arn = interactive.select(
+                    f"Select a deployed {component_type}",
+                    [
+                        choice(c["name"], c["arn"], "(resolved at deploy time)" if c.get("isPlaceholder") else c["arn"])
+                        for c in candidates
+                    ],
+                )
+            typer.echo(f"Component: {arn}")
+            typer.echo("Enter the configuration as a JSON object (key-value pairs).")
+            typer.echo('Example: {"systemPrompt": "You are a helpful assistant", "temperature": 0.7}')
+            config_text = interactive.text("Configuration (JSON)", validate=validate_config_json)
+            components[arn] = {"configuration": json.loads(config_text)}
+            count = len(components)
+            typer.echo(f"{count} component{'' if count == 1 else 's'} configured:")
+            for key in components:
+                typer.echo(f"  • {key}")
+            if not interactive.select("Add another component?", [choice("Yes", True), choice("No", False)]):
+                break
+        branch = interactive.text("Branch name (press Enter for default)")
+        commit = interactive.text("Commit message (press Enter for default)")
+        kms = interactive.text(
+            "KMS key ARN (optional, press Enter to skip)",
+            validate=lambda v: None if v == "" or is_valid_kms_key_arn(v) else "Must be a valid KMS key ARN",
+        )
+        rows = [("Name", name)]
+        if description:
+            rows.append(("Description", description))
+        rows += [
+            ("Components", ", ".join(components)),
+            ("Branch", branch or "mainline"),
+            ("Message", commit or f"Create {name}"),
+        ]
+        if kms:
+            rows.append(("KMS Key", kms))
+        for label, value in rows:
+            typer.echo(f"  {label}: {value}")
+        if not interactive.confirm("Add this configuration bundle?", default=True):
+            typer.echo("Cancelled.")
+            return
+        result = self.add(
+            AddConfigBundleOptions(
+                name=name,
+                description=description or None,
+                components=components,
+                branch_name=branch or "mainline",
+                commit_message=commit or f"Create {name}",
+                kms_key_arn=kms or None,
+            )
+        )
+        if not result.success:
+            typer.echo("Failed to add configuration bundle", err=True)
+            typer.echo(get_error_message(result.error), err=True)
+            raise typer.Exit(1)
+        typer.echo(f"Added configuration bundle: {name}")
+        typer.echo("Bundle added to project in `agentcore/agentcore.json`. Deploy with `agentcore deploy`.")
+
+
+PRIMITIVE = ConfigBundlePrimitive()