agentcore-cli 0.31.1__py3-none-any.whl

agentcore/cli/commands/config_bundle.py

@@ -0,0 +1,251 @@
+"""`agentcore config-bundle versions|diff|create-branch` (port of commands/config-bundle/command.tsx).
+
+Also registers the upstream `cb` alias.
+"""
+
+import json
+from datetime import UTC, datetime
+from typing import Any
+
+import typer
+from rich.console import Console
+from rich.text import Text
+
+from agentcore.aws import agentcore_config_bundles as api
+from agentcore.cli.commands._jobs_common import print_json, red, require_project
+from agentcore.cli.errors import get_error_message
+from agentcore.cli.groups import group
+from agentcore.lib import ConfigIO
+from agentcore.operations.config_bundle.diff_versions import deep_diff
+from agentcore.operations.config_bundle.resolve_bundle import resolve_bundle_by_name
+from agentcore.operations.jobs.shared.format import parse_js_date
+
+cb_app = group("config-bundle")
+cb_app.info.help = "Manage configuration bundles (use bundle name from agentcore.json, not the ID)"
+
+_NAME_HELP = 'Bundle name as defined in agentcore.json (e.g. "MyBundle")'
+_console = Console(highlight=False, soft_wrap=True)
+
+
+def _js_number(value: Any) -> float | None:
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def format_timestamp(ts: Any) -> str:
+    """Epoch seconds/ms -> ``YYYY-MM-DD HH:MM:SSZ``; non-numeric values are shown verbatim."""
+    num = _js_number(ts)
+    if num is None:
+        return str(ts)
+    ms = num * 1000 if num < 1e12 else num
+    return datetime.fromtimestamp(ms / 1000, tz=UTC).strftime("%Y-%m-%d %H:%M:%SZ")
+
+
+def _js_json(value: Any, indent: int | None = None) -> str:
+    if indent is None:
+        return json.dumps(value, separators=(",", ":"), ensure_ascii=False)
+    return json.dumps(value, indent=indent, ensure_ascii=False)
+
+
+def _resolve_region() -> str:
+    targets = ConfigIO().resolve_aws_deployment_targets()
+    if not targets:
+        raise Exception("No AWS deployment targets configured. Run `agentcore deploy` first.")
+    first = targets[0]
+    return first.get("region") if isinstance(first, dict) else first.region
+
+
+def handle_versions(
+    name: str, branch: str | None, latest_per_branch: bool, created_by: str | None, region: str | None
+) -> dict[str, Any]:
+    region = region or _resolve_region()
+    resolved = resolve_bundle_by_name(name, region)
+    flt: dict[str, Any] = {}
+    if branch:
+        flt["branchName"] = branch
+    if latest_per_branch:
+        flt["latestPerBranch"] = True
+    if created_by:
+        flt["createdByName"] = created_by
+    versions: list[dict[str, Any]] = []
+    next_token = None
+    while True:
+        page = api.list_configuration_bundle_versions(
+            region=region, bundle_id=resolved.bundle_id, max_results=50, next_token=next_token, filter=flt or None
+        )
+        versions.extend(page["versions"])
+        next_token = page.get("nextToken")
+        if not next_token:
+            break
+    versions.sort(key=lambda v: _js_number(v.get("versionCreatedAt")) or 0, reverse=True)
+    return {"versions": versions, "bundleName": name, "bundleId": resolved.bundle_id}
+
+
+def handle_diff(name: str, from_id: str, to_id: str, region: str | None) -> dict[str, Any]:
+    region = region or _resolve_region()
+    resolved = resolve_bundle_by_name(name, region)
+    from_version = api.get_configuration_bundle_version(region=region, bundle_id=resolved.bundle_id, version_id=from_id)
+    to_version = api.get_configuration_bundle_version(region=region, bundle_id=resolved.bundle_id, version_id=to_id)
+    diffs = deep_diff(from_version.get("components"), to_version.get("components"))
+    return {"fromVersion": from_version, "toVersion": to_version, "diffs": diffs}
+
+
+@cb_app.command("versions", help="List version history for a configuration bundle")
+def versions(
+    name: str = typer.Option(..., "--name", help=_NAME_HELP),
+    branch: str | None = typer.Option(None, "--branch", help="Filter by branch name"),
+    latest_per_branch: bool = typer.Option(
+        False, "--latest-per-branch", help="Show only the latest version per branch"
+    ),
+    created_by: str | None = typer.Option(
+        None, "--created-by", help='Filter by creator name (e.g. "user", "recommendation")'
+    ),
+    region: str | None = typer.Option(None, "--region", help="AWS region override"),
+    as_json: bool = typer.Option(False, "--json", help="Output as JSON"),
+) -> None:
+    require_project()
+    try:
+        result = handle_versions(name, branch, latest_per_branch, created_by, region)
+    except Exception as exc:  # noqa: BLE001
+        red(f"Error: {get_error_message(exc)}")
+        raise typer.Exit(1) from None
+    if as_json:
+        typer.echo(_js_json(result, 2))
+        return
+    if not result["versions"]:
+        typer.secho(f'No versions found for bundle "{name}".', fg=typer.colors.YELLOW)
+        return
+    by_branch: dict[str, list[dict[str, Any]]] = {}
+    for v in result["versions"]:
+        by_branch.setdefault((v.get("lineageMetadata") or {}).get("branchName") or "unknown", []).append(v)
+    _console.print(Text(f"{result['bundleName']} — {len(result['versions'])} version(s)", style="bold"))
+    _console.print(" ")
+    for branch_name, entries in by_branch.items():
+        _console.print(Text(f"Branch: {branch_name}", style="bold cyan"))
+        for i, v in enumerate(entries):
+            meta = v.get("lineageMetadata") or {}
+            last = i == len(entries) - 1
+            line = Text(f"{'└' if last else '├'} ")
+            line.append(v["versionId"], style="green")
+            line.append(" ")
+            line.append(format_timestamp(v.get("versionCreatedAt")), style="dim")
+            line.append(" ")
+            if meta.get("commitMessage"):
+                line.append(f'"{meta["commitMessage"]}"')
+            _console.print(line)
+            second = Text(f"{' ' if last else '│'} ")
+            second.append(f"by: {(meta.get('createdBy') or {}).get('name') or 'unknown'}", style="dim")
+            if meta.get("parentVersionIds"):
+                second.append(f" (parent: {', '.join(meta['parentVersionIds'])})", style="dim")
+            _console.print(second)
+        _console.print("")
+    _console.print(Text("Use --json for complete output", style="dim"))
+
+
+@cb_app.command("diff", help="Diff two versions of a configuration bundle (get version IDs from `cb versions`)")
+def diff(
+    name: str = typer.Option(..., "--name", help=_NAME_HELP),
+    from_id: str = typer.Option(..., "--from", help="Source version ID (from `config-bundle versions --json`)"),
+    to_id: str = typer.Option(..., "--to", help="Target version ID (from `config-bundle versions --json`)"),
+    region: str | None = typer.Option(None, "--region", help="AWS region override"),
+    as_json: bool = typer.Option(False, "--json", help="Output as JSON"),
+) -> None:
+    require_project()
+    try:
+        result = handle_diff(name, from_id, to_id, region)
+    except Exception as exc:  # noqa: BLE001
+        red(f"Error: {get_error_message(exc)}")
+        raise typer.Exit(1) from None
+    if as_json:
+        typer.echo(_js_json(result, 2))
+        return
+    fv, tv = result["fromVersion"], result["toVersion"]
+    from_meta, to_meta = fv.get("lineageMetadata") or {}, tv.get("lineageMetadata") or {}
+    _console.print(Text(f"Diff: {fv.get('versionId')} → {tv.get('versionId')}", style="bold"))
+    _console.print(
+        Text(
+            f"From: {from_meta.get('commitMessage') or '(no message)'} ({format_timestamp(fv.get('versionCreatedAt'))})",
+            style="dim",
+        )
+    )
+    _console.print(
+        Text(
+            f"To: {to_meta.get('commitMessage') or '(no message)'} ({format_timestamp(tv.get('versionCreatedAt'))})",
+            style="dim",
+        )
+    )
+    _console.print(" ")
+    if not result["diffs"]:
+        _console.print(Text("No differences found.", style="green"))
+        return
+    _console.print(f"{len(result['diffs'])} change(s):")
+    _console.print(" ")
+    for d in result["diffs"]:
+        _console.print(Text(d["path"], style="bold"))
+        if d["type"] in ("removed", "changed"):
+            _console.print(Text(f"- {_js_json(d.get('oldValue'))}", style="red"))
+        if d["type"] in ("added", "changed"):
+            _console.print(Text(f"+ {_js_json(d.get('newValue'))}", style="green"))
+        _console.print("")
+
+
+def _created_at_ms(version: dict[str, Any]) -> float:
+    parsed = parse_js_date(version.get("versionCreatedAt"))
+    return parsed.timestamp() if parsed else float("-inf")
+
+
+@cb_app.command("create-branch", help="Create a new branch on an existing configuration bundle")
+def create_branch(
+    name: str = typer.Option(..., "--name", help=_NAME_HELP),
+    branch: str = typer.Option(..., "--branch", help="Name for the new branch"),
+    from_id: str | None = typer.Option(
+        None, "--from", help="Parent version ID to branch from (defaults to latest version)"
+    ),
+    commit_message: str | None = typer.Option(None, "--commit-message", help="Commit message for the branch point"),
+    region: str | None = typer.Option(None, "--region", help="AWS region override"),
+    as_json: bool = typer.Option(False, "--json", help="Output as JSON"),
+) -> None:
+    require_project()
+    try:
+        resolved_region = region or _resolve_region()
+        resolved = resolve_bundle_by_name(name, resolved_region)
+        parent = from_id
+        if not parent:
+            listed = api.list_configuration_bundle_versions(
+                region=resolved_region, bundle_id=resolved.bundle_id, max_results=50
+            )
+            if not listed["versions"]:
+                raise Exception(f'No versions found for bundle "{name}".')
+            parent = max(listed["versions"], key=_created_at_ms)["versionId"]
+        parent_version = api.get_configuration_bundle_version(
+            region=resolved_region, bundle_id=resolved.bundle_id, version_id=parent
+        )
+        result = api.update_configuration_bundle(
+            region=resolved_region,
+            bundle_id=resolved.bundle_id,
+            components=parent_version.get("components"),
+            parent_version_ids=[parent],
+            branch_name=branch,
+            commit_message=commit_message or f"Create branch {branch}",
+            created_by={"name": "user"},
+        )
+    except Exception as exc:  # noqa: BLE001
+        if as_json:
+            print_json({"success": False, "error": get_error_message(exc)})
+        else:
+            red(f"Error: {get_error_message(exc)}")
+        raise typer.Exit(1) from None
+    if as_json:
+        typer.echo(_js_json(result, 2))
+        return
+    _console.print(Text(f'Branch "{branch}" created on bundle "{name}"', style="bold green"))
+    line = Text("Version: ")
+    line.append(str(result.get("versionId")), style="green")
+    _console.print(line)
+    _console.print(Text(f"Parent: {parent}", style="dim"))
+
+
+def register(app: typer.Typer) -> None:
+    app.add_typer(cb_app, name="cb", hidden=True)