agentcore-cli 0.31.1__py3-none-any.whl

agentcore/cli/commands/logs_evals.py

@@ -0,0 +1,42 @@
+"""`agentcore logs evals` (port of the `evals` subcommand in commands/logs/command.tsx).
+
+The `logs` group's default action belongs to the dev/logs area (cli/commands/logs).
+"""
+
+import typer
+
+from agentcore.cli.commands._jobs_common import red, require_project
+from agentcore.cli.errors import get_error_message
+from agentcore.cli.groups import group
+from agentcore.operations.eval.logs_eval import handle_logs_eval
+
+
+@group("logs").command("evals", help="Stream or search online eval logs")
+def logs_evals(
+    runtime: str | None = typer.Option(None, "-r", "--runtime", help="Select specific runtime"),
+    since: str | None = typer.Option(None, "--since", help='Start time (e.g. "1h", "30m", "2d", ISO 8601)'),
+    until: str | None = typer.Option(None, "--until", help='End time (e.g. "now", ISO 8601)'),
+    limit: str | None = typer.Option(None, "-n", "--limit", help="Maximum number of log lines"),
+    follow: bool = typer.Option(
+        False, "-f", "--follow", help="Stream logs in real-time (default when no --since/--until)"
+    ),
+    as_json: bool = typer.Option(False, "--json", help="Output as JSON Lines"),
+) -> None:
+    require_project()
+    try:
+        result = handle_logs_eval(
+            agent=runtime,
+            since=since,
+            until=until,
+            limit=limit,
+            as_json=as_json,
+            follow=True if follow else None,
+        )
+    except typer.Exit:
+        raise
+    except Exception as exc:  # noqa: BLE001 - top-level command boundary, as upstream
+        red(f"Error: {get_error_message(exc)}")
+        raise typer.Exit(1) from None
+    if not result.success:
+        red(str(result.error))
+        raise typer.Exit(1)

agentcore/cli/commands/package.py

@@ -0,0 +1,118 @@
+"""`agentcore package` (port of src/cli/commands/package)."""
+
+from __future__ import annotations
+
+import os
+import sys
+from dataclasses import dataclass, field
+from typing import Any
+
+import typer
+
+from agentcore.cli.constants import ANSI, COMMAND_DESCRIPTIONS
+from agentcore.cli.errors import get_error_message
+from agentcore.lib.constants import CONFIG_DIR
+from agentcore.lib.packaging import (
+    PackageOptions,
+    pack_code_zip_sync,
+    pack_runtime,
+    resolve_code_location,
+    validate_agent_exists,
+)
+from agentcore.lib.schemas.io.config_io import ConfigIO
+
+
+@dataclass
+class PackageContext:
+    project: Any
+    config_base_dir: str
+    project_root: str | None = None
+    target_agent: str | None = None
+
+
+@dataclass(frozen=True)
+class PackageAgentResult:
+    agent_name: str
+    artifact_path: str
+    size_mb: str
+
+
+@dataclass
+class PackageResult:
+    success: bool
+    results: list[PackageAgentResult] = field(default_factory=list)
+    skipped: list[str] = field(default_factory=list)
+    error: str | None = None
+
+
+def load_package_config(directory: str | None = None, runtime: str | None = None) -> PackageContext:
+    project_root = os.path.abspath(directory) if directory else None
+    config_io = ConfigIO(base_dir=os.path.join(project_root, CONFIG_DIR)) if project_root else ConfigIO()
+    return PackageContext(
+        project=config_io.read_project_spec(),
+        config_base_dir=config_io.get_path_resolver().get_base_dir(),
+        project_root=project_root,
+        target_agent=runtime,
+    )
+
+
+def _size_mb(size_bytes: int) -> str:
+    return f"{size_bytes / (1024 * 1024):.2f}"
+
+
+def handle_package(context: PackageContext) -> PackageResult:
+    project, base_dir, target = context.project, context.config_base_dir, context.target_agent
+    if target:
+        validate_agent_exists(project, target)
+    agents = [a for a in project.runtimes if a.name == target] if target else list(project.runtimes)
+
+    result = PackageResult(success=True)
+    for agent in agents:
+        if agent.build == "CodeZip":
+            code_location = resolve_code_location(agent.code_location, base_dir)
+            artifact = pack_code_zip_sync(
+                agent, PackageOptions(project_root=code_location, agent_name=agent.name, artifact_dir=base_dir)
+            )
+            result.results.append(PackageAgentResult(agent.name, artifact.artifact_path, _size_mb(artifact.size_bytes)))
+        elif agent.build == "Container":
+            artifact = pack_runtime(agent, PackageOptions(agent_name=agent.name, artifact_dir=base_dir))
+            if not artifact.artifact_path:
+                print(
+                    "No container runtime found. Skipping local build validation. Deploy will use CodeBuild.",
+                    file=sys.stderr,
+                )
+                result.skipped.append(agent.name)
+            else:
+                result.results.append(
+                    PackageAgentResult(agent.name, artifact.artifact_path, _size_mb(artifact.size_bytes))
+                )
+    return result
+
+
+def package_command(
+    directory: str | None = typer.Option(
+        None, "-d", "--directory", help="Project directory containing agentcore config"
+    ),
+    runtime: str | None = typer.Option(None, "-r", "--runtime", help="Package only the specified runtime"),
+) -> None:
+    try:
+        result = handle_package(load_package_config(directory, runtime))
+        for name in result.skipped:
+            typer.echo(f"{ANSI.yellow}Skipping {name}: ContainerImage artifacts not supported{ANSI.reset}")
+        if not result.results:
+            typer.echo(f"{ANSI.yellow}No agents to package{ANSI.reset}")
+            return
+        for r in result.results:
+            typer.echo(f"{ANSI.green}✓ {r.agent_name}: {r.artifact_path} ({r.size_mb} MB){ANSI.reset}")
+    except Exception as exc:  # noqa: BLE001
+        typer.echo(f"{ANSI.red}Error: {get_error_message(exc)}{ANSI.reset}")
+        raise typer.Exit(1) from None
+
+
+def register(app: typer.Typer) -> None:
+    description = COMMAND_DESCRIPTIONS["package"]
+    app.command("package", help=description)(package_command)
+    app.command("pkg", help=description, hidden=True)(package_command)
+
+
+__all__ = ["PackageAgentResult", "PackageContext", "PackageResult", "handle_package", "load_package_config", "register"]

agentcore/cli/commands/remove/__init__.py

@@ -0,0 +1,172 @@
+"""`agentcore remove` shell and `remove all` (port of src/cli/commands/remove/command.tsx)."""
+
+import json
+from typing import Any
+
+import typer
+
+from agentcore.cli import interactive
+from agentcore.cli.errors import get_error_message
+from agentcore.cli.run_command import run_cli_command
+from agentcore.cli.tree import RESOURCE_KINDS
+from agentcore.lib import ConfigIO, find_config_root, remove_env_vars, 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.credential_utils import (
+    compute_payment_credential_env_var_names,
+    compute_stripe_privy_credential_env_var_names,
+)
+
+REMOVE_ALL_NOTE = "Your source code has not been modified. Run `agentcore deploy` to apply changes to AWS."
+
+
+def _empty_spec(project_name: str) -> dict[str, Any]:
+    return {
+        "$schema": "https://schema.agentcore.aws.dev/v1/agentcore.json",
+        "name": project_name,
+        "version": 1,
+        "managedBy": "CDK",
+        "tags": {"agentcore:created-by": "agentcore-cli", "agentcore:project-name": project_name},
+        "runtimes": [],
+        "memories": [],
+        "knowledgeBases": [],
+        "credentials": [],
+        "evaluators": [],
+        "onlineEvalConfigs": [],
+        "agentCoreGateways": [],
+        "policyEngines": [],
+        "configBundles": [],
+        "abTests": [],
+        "harnesses": [],
+        "datasets": [],
+        "payments": [],
+        "capacityProviders": [],
+    }
+
+
+def handle_remove_all(dry_run: bool = False, config_io: ConfigIO | None = None) -> Ok[dict[str, Any]] | Err[Exception]:
+    try:
+        io = config_io or ConfigIO()
+        if dry_run:
+            current = to_jsonable(io.read_project_spec())
+            items: list[str] = []
+            for key, label in (
+                ("runtimes", "runtime"),
+                ("memories", "memory"),
+                ("credentials", "credential"),
+                ("payments", "payment-manager"),
+                ("evaluators", "evaluator"),
+                ("agentCoreGateways", "gateway"),
+                ("policyEngines", "policy-engine"),
+                ("capacityProviders", "capacity-provider"),
+            ):
+                items.extend(f"{label}: {r['name']}" for r in current.get(key) or [])
+            return Ok({"message": f"Would remove: {', '.join(items)}" if items else "Nothing to remove"})
+
+        project_name = "Project"
+        current: dict[str, Any] | None = None
+        try:
+            current = to_jsonable(io.read_project_spec())
+            project_name = current["name"]
+        except Exception:  # noqa: BLE001 - keep the default name, as upstream
+            pass
+
+        # Clean up payment credential env vars before resetting (best-effort).
+        try:
+            root = io.get_config_root()
+            for payment in (current or {}).get("payments") or []:
+                for connector in payment.get("connectors") or []:
+                    if connector.get("provisionMode") == "QUICK_CREATE":
+                        continue
+                    if (connector.get("provider") or "CoinbaseCDP") == "StripePrivy":
+                        v = compute_stripe_privy_credential_env_var_names(connector["credentialName"])
+                        remove_env_vars([v.app_id, v.app_secret, v.authorization_private_key, v.authorization_id], root)
+                    else:
+                        p = compute_payment_credential_env_var_names(connector["credentialName"])
+                        remove_env_vars([p.api_key_id, p.api_key_secret, p.wallet_secret], root)
+        except Exception:  # noqa: BLE001
+            pass
+
+        # aws-targets.json and deployed-state.json are kept so `agentcore deploy` can tear stacks down.
+        io.write_project_spec(_empty_spec(project_name))
+        return Ok({"message": "All schemas reset to empty state", "note": REMOVE_ALL_NOTE})
+    except Exception as exc:  # noqa: BLE001
+        return Err(to_error(exc))
+
+
+def _remove_all_cli(dry_run: bool, as_json: bool) -> None:
+    def run() -> None:
+        result = handle_remove_all(dry_run)
+        if not result.success:
+            raise result.error
+        if as_json:
+            typer.echo(json.dumps(serialize_result(result), separators=(",", ":")))
+        else:
+            typer.echo(result.value.get("message") or "All schemas reset to empty state")
+            if result.value.get("note"):
+                typer.echo(result.value["note"])
+
+    run_cli_command(as_json, run)
+
+
+def _remove_all_interactive() -> None:
+    """Port of tui/screens/remove/RemoveAllScreen: preview, confirm, reset."""
+    preview = handle_remove_all(dry_run=True)
+    if preview.success:
+        typer.echo(preview.value["message"])
+    if not interactive.confirm("Reset all agentcore schemas to empty state?", default=False):
+        typer.echo("Cancelled.")
+        return
+    result = handle_remove_all()
+    if not result.success:
+        typer.echo(f"Error: {get_error_message(result.error)}", err=True)
+        raise typer.Exit(1)
+    typer.echo(result.value["message"])
+    typer.echo(result.value["note"])
+
+
+def install_remove_shell(remove_app: typer.Typer) -> None:
+    remove_app.info.no_args_is_help = False
+
+    @remove_app.callback(invoke_without_command=True)
+    def remove_root(ctx: typer.Context) -> None:
+        if ctx.invoked_subcommand is not None:
+            return
+        if not find_config_root():
+            typer.echo("No agentcore project found. Run `agentcore create` first.", err=True)
+            raise typer.Exit(1)
+        interactive.require_tty()
+        from agentcore.primitives.registry import all_primitives
+
+        primitives = {p.kind: p for p in all_primitives()}
+        choices = [interactive.Choice(RESOURCE_KINDS.get(k, k).capitalize(), k) for k in primitives]
+        choices.append(interactive.Choice("All", "all", "Reset all agentcore schemas to empty state"))
+        kind = interactive.select("What would you like to remove?", choices)
+        if kind == "all":
+            _remove_all_interactive()
+        else:
+            primitives[kind].remove_interactive()
+
+    @remove_app.command("all", help="Reset all agentcore schemas to empty state")
+    def remove_all(
+        yes: bool = typer.Option(False, "-y", "--yes", help="Skip confirmation prompts [non-interactive]"),
+        dry_run: bool = typer.Option(
+            False, "--dry-run", help="Show what would be reset without actually resetting [non-interactive]"
+        ),
+        as_json: bool = typer.Option(False, "--json", help="Output as JSON [non-interactive]"),
+    ) -> None:
+        try:
+            if yes or dry_run or as_json:
+                _remove_all_cli(dry_run, as_json)
+            else:
+                interactive.require_tty()
+                _remove_all_interactive()
+        except typer.Exit:
+            raise
+        except Exception as exc:  # noqa: BLE001
+            if as_json:
+                typer.echo(json.dumps({"success": False, "error": get_error_message(exc)}, separators=(",", ":")))
+            else:
+                typer.echo(f"Error: {get_error_message(exc)}", err=True)
+            raise typer.Exit(1) from None

agentcore/cli/commands/remove/skill_command.py

@@ -0,0 +1,131 @@
+"""`agentcore remove skill` (port of src/cli/commands/remove/skill-command.ts)."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from typing import Any
+
+import typer
+
+from agentcore.cli.commands.add._commander import (
+    optional_value,
+    optional_value_command,
+    require_options,
+    require_project,
+)
+from agentcore.cli.errors import get_error_message
+from agentcore.lib.errors.types import ValidationError
+from agentcore.lib.result import Err, Ok
+from agentcore.lib.schemas.io.config_io import ConfigIO, to_jsonable
+from agentcore.operations.harness.skill_utils import build_git_skill_key, get_skill_key
+
+
+@dataclass
+class RemoveSkillOptions:
+    harness: str
+    path: str | None = None
+    s3: str | None = None
+    git: str | None = None
+    git_path: str | None = None
+    aws_skills: str | bool | None = None
+
+
+def handle_remove_skill(
+    options: RemoveSkillOptions, config_io: ConfigIO | None = None
+) -> Ok[dict[str, Any]] | Err[Exception]:
+    harness = options.harness
+    if sum(1 for s in (options.path, options.s3, options.git, options.aws_skills) if s) != 1:
+        return Err(
+            ValidationError("Exactly one of --path, --s3, --git, or --aws-skills is required to identify the skill")
+        )
+
+    io = config_io or ConfigIO()
+    try:
+        spec = to_jsonable(io.read_harness_spec(harness))
+    except Exception:  # noqa: BLE001
+        return Err(ValidationError(f"Harness '{harness}' not found."))
+
+    if options.path:
+        target, source = f"path:{options.path}", options.path
+    elif options.s3:
+        target, source = f"s3:{options.s3}", options.s3
+    elif options.git:
+        target = build_git_skill_key(options.git, options.git_path)
+        source = f"{options.git} (path: {options.git_path})" if options.git_path else options.git
+    else:
+        aws_paths = (
+            "*"
+            if options.aws_skills is True
+            else ",".join(sorted(s.strip() for s in str(options.aws_skills).split(",") if s.strip()))
+        )
+        target = f"awsSkills:{aws_paths}"
+        source = "aws-skills (all)" if aws_paths == "*" else f"aws-skills ({aws_paths})"
+
+    skills = spec.get("skills") or []
+    index = next((i for i, s in enumerate(skills) if get_skill_key(s) == target), -1)
+    if index == -1:
+        hint = " If the skill has a sub-path, specify --git-path." if options.git and not options.git_path else ""
+        return Err(ValidationError(f"Skill '{source}' not found in harness '{harness}'.{hint}"))
+
+    skills.pop(index)
+    spec["skills"] = skills
+    io.write_harness_spec(harness, spec)
+    return Ok({"harnessName": harness, "skillSource": source})
+
+
+def register_remove_skill(remove_app: typer.Typer) -> None:
+    @remove_app.command("skill", help="Remove a skill from a harness", cls=optional_value_command("--aws-skills"))
+    def remove_skill(
+        harness: str | None = typer.Option(None, "--harness", help="Target harness name"),
+        path: str | None = typer.Option(None, "--path", help="Path to an installed skill in the environment"),
+        s3: str | None = typer.Option(None, "--s3", help="S3 URI of skill to remove"),
+        git: str | None = typer.Option(None, "--git", help="Git URL of skill to remove"),
+        git_path: str | None = typer.Option(None, "--git-path", help="Subdirectory within the git repo (for --git)"),
+        aws_skills: str | None = typer.Option(
+            None,
+            "--aws-skills",
+            metavar="[PATHS]",
+            help="AWS skill paths to remove (comma-separated, or omit for wildcard)",
+        ),
+        as_json: bool = typer.Option(False, "--json", help="Output as JSON"),
+    ) -> None:
+        require_options(("--harness <name>", harness))
+        require_project()
+        try:
+            result = handle_remove_skill(
+                RemoveSkillOptions(
+                    harness=harness or "",
+                    path=path,
+                    s3=s3,
+                    git=git,
+                    git_path=git_path,
+                    aws_skills=optional_value(aws_skills),
+                )
+            )
+            if not result.success:
+                if as_json:
+                    typer.echo(
+                        json.dumps({"success": False, "error": get_error_message(result.error)}, separators=(",", ":"))
+                    )
+                else:
+                    typer.echo(get_error_message(result.error), err=True)
+                raise typer.Exit(1)
+            if as_json:
+                typer.echo(json.dumps({"success": True, **result.value}, separators=(",", ":")))
+            else:
+                typer.echo(
+                    f"Removed skill '{result.value['skillSource']}' from harness '{result.value['harnessName']}'."
+                )
+                typer.echo("Run 'agentcore deploy' to apply changes.")
+        except typer.Exit:
+            raise
+        except Exception as exc:  # noqa: BLE001
+            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
+
+
+__all__ = ["RemoveSkillOptions", "handle_remove_skill", "register_remove_skill"]

agentcore/cli/commands/remove/tool_command.py

@@ -0,0 +1,59 @@
+"""`agentcore remove tool` (port of src/cli/commands/remove/tool-command.ts)."""
+
+from __future__ import annotations
+
+import json
+
+import typer
+
+from agentcore.cli.commands.add._commander import require_options, require_project
+from agentcore.cli.errors import get_error_message
+from agentcore.lib.schemas.io.config_io import ConfigIO, to_jsonable
+
+
+def _dump(payload: dict) -> str:
+    return json.dumps(payload, separators=(",", ":"))
+
+
+def _fail(error: str, as_json: bool) -> None:
+    if as_json:
+        typer.echo(_dump({"success": False, "error": error}))
+    else:
+        typer.echo(error, err=True)
+    raise typer.Exit(1)
+
+
+def register_remove_tool(remove_app: typer.Typer) -> None:
+    @remove_app.command("tool", help="Remove a tool from a harness")
+    def remove_tool(
+        harness: str | None = typer.Option(None, "--harness", help="Target harness name"),
+        name: str | None = typer.Option(None, "--name", help="Tool name to remove"),
+        as_json: bool = typer.Option(False, "--json", help="Output as JSON"),
+    ) -> None:
+        require_options(("--harness <name>", harness), ("--name <name>", name))
+        require_project()
+        try:
+            io = ConfigIO()
+            try:
+                spec = to_jsonable(io.read_harness_spec(harness or ""))
+            except Exception:  # noqa: BLE001
+                _fail(f"Harness '{harness}' not found.", as_json)
+            tools = spec.get("tools") or []
+            index = next((i for i, t in enumerate(tools) if t.get("name") == name), -1)
+            if index == -1:
+                _fail(f"Tool '{name}' not found in harness '{harness}'", as_json)
+            tools.pop(index)
+            spec["tools"] = tools
+            io.write_harness_spec(harness or "", spec)
+            if as_json:
+                typer.echo(_dump({"success": True, "harnessName": harness, "toolName": name}))
+            else:
+                typer.echo(f"Removed tool '{name}' from harness '{harness}'.")
+                typer.echo("Run 'agentcore deploy' to apply changes.")
+        except typer.Exit:
+            raise
+        except Exception as exc:  # noqa: BLE001
+            _fail(get_error_message(exc), as_json)
+
+
+__all__ = ["register_remove_tool"]