agentcore-cli 0.31.1__py3-none-any.whl

agentcore/cli/commands/export/harness_resolver.py

@@ -0,0 +1,95 @@
+"""Read and validate all on-disk inputs for a harness export (port of harness-resolver.ts)."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from typing import Any
+
+from agentcore.cli.commands.export.constants import DEFAULT_SYSTEM_PROMPT
+from agentcore.cli.commands.export.types import ResolvedHarnessContext
+from agentcore.lib.errors.types import ValidationError
+from agentcore.lib.schemas.io.config_io import ConfigIO, to_jsonable
+from agentcore.lib.schemas.io.path_resolver import require_config_root
+
+
+@dataclass
+class PrefetchedHarness:
+    """A harness spec + system prompt fetched out-of-band (the ``--arn`` path)."""
+
+    spec: dict[str, Any]
+    system_prompt: str | None = None
+
+
+def resolve_harness_context(
+    harness_name: str,
+    target_agent_name: str,
+    config_base_dir: str | None = None,
+    prefetched: PrefetchedHarness | None = None,
+) -> ResolvedHarnessContext:
+    base_dir = config_base_dir or require_config_root()
+    config_io = ConfigIO(base_dir=base_dir)
+    project_root = os.path.normpath(os.path.join(base_dir, ".."))
+
+    project = to_jsonable(config_io.read_project_spec())
+    if prefetched is None:
+        harnesses = project.get("harnesses") or []
+        if not any(h["name"] == harness_name for h in harnesses):
+            available = ", ".join(h["name"] for h in harnesses) or "none"
+            raise ValidationError(
+                f'Harness "{harness_name}" not found in agentcore.json. Available harnesses: {available}'
+            )
+
+    if any(r["name"] == target_agent_name for r in project.get("runtimes") or []):
+        raise ValidationError(
+            f'A runtime agent named "{target_agent_name}" already exists. Choose a different --target-agent-name.'
+        )
+
+    if os.path.exists(os.path.join(project_root, "app", target_agent_name)):
+        raise ValidationError(
+            f'The directory "app/{target_agent_name}/" already exists. Remove it or choose a different '
+            "--target-agent-name."
+        )
+
+    if prefetched is not None:
+        spec = prefetched.spec
+        trimmed = (prefetched.system_prompt or "").strip()
+        system_prompt = trimmed or spec.get("systemPrompt") or DEFAULT_SYSTEM_PROMPT
+    else:
+        spec = to_jsonable(config_io.read_harness_spec(harness_name))
+        prompt_path = os.path.join(project_root, "app", harness_name, "system-prompt.md")
+        if os.path.exists(prompt_path):
+            with open(prompt_path, encoding="utf-8") as fh:
+                system_prompt = fh.read().strip()
+        else:
+            system_prompt = spec.get("systemPrompt") or DEFAULT_SYSTEM_PROMPT
+
+    deployed_resources: dict[str, Any] | None = None
+    try:
+        state = to_jsonable(config_io.read_deployed_state())
+        first = next(iter((state.get("targets") or {}).values()), None)
+        deployed_resources = (first or {}).get("resources") or None
+    except Exception:  # noqa: BLE001 - absent before first deploy
+        pass
+
+    region: str | None = None
+    try:
+        targets = to_jsonable(config_io.read_aws_deployment_targets())
+        region = targets[0].get("region") if targets else None
+    except Exception:  # noqa: BLE001
+        pass
+
+    return ResolvedHarnessContext(
+        harness_name=harness_name,
+        target_agent_name=target_agent_name,
+        spec=spec,
+        system_prompt=system_prompt,
+        project_spec=project,
+        deployed_resources=deployed_resources,
+        config_base_dir=base_dir,
+        project_root=project_root,
+        region=region,
+    )
+
+
+__all__ = ["PrefetchedHarness", "resolve_harness_context"]

agentcore/cli/commands/export/types.py

@@ -0,0 +1,90 @@
+"""Export types (port of src/cli/commands/export/types.ts).
+
+Specs are carried in their camelCase JSON form (``dict``), as read through ``to_jsonable``.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Literal
+
+from agentcore.templates.types import AgentRenderConfig
+
+
+@dataclass
+class ExportHarnessOptions:
+    name: str | None = None
+    arn: str | None = None
+    target_agent_name: str | None = None
+    build: str | None = None
+    json: bool | None = None
+
+
+@dataclass
+class ExportNote:
+    category: str
+    message: str
+
+
+@dataclass
+class ExportNoteLine:
+    text: str
+    tone: Literal["warn", "dim"]
+
+
+@dataclass
+class ResolvedHarnessContext:
+    harness_name: str
+    target_agent_name: str
+    spec: dict[str, Any]
+    system_prompt: str
+    project_spec: dict[str, Any]
+    deployed_resources: dict[str, Any] | None
+    config_base_dir: str
+    project_root: str
+    export_notes: list[ExportNote] = field(default_factory=list)
+    region: str | None = None
+    local_env_vars: dict[str, str] = field(default_factory=dict)
+    generated_policy_files: dict[str, Any] = field(default_factory=dict)
+    additional_policies: list[str] = field(default_factory=list)
+
+
+@dataclass
+class McpCredentialEntry:
+    credential: dict[str, Any]
+    env_var_name: str
+    value: str
+
+
+@dataclass
+class HarnessMappingResult:
+    render_config: AgentRenderConfig
+    agent_env_spec: dict[str, Any]
+    credential_entry: dict[str, Any] | None
+    mcp_credential_entries: list[McpCredentialEntry]
+    git_credential_entries: list[dict[str, Any]]
+
+
+def format_export_notes(notes: list[ExportNote], notes_file_hint: str) -> list[ExportNoteLine]:
+    """Styled lines for the export success path (shared wording for CLI + interactive)."""
+    if not notes:
+        return [ExportNoteLine(f"No manual follow-up required. (Details: {notes_file_hint})", "dim")]
+    label = "note" if len(notes) == 1 else "notes"
+    lines = [ExportNoteLine(f"⚠ {len(notes)} export {label} requiring manual follow-up:", "warn")]
+    for note in notes:
+        lines.append(ExportNoteLine(f"  • {note.category}", "warn"))
+        for message_line in note.message.split("\n"):
+            lines.append(ExportNoteLine(f"    {message_line}", "dim"))
+    lines.append(ExportNoteLine(f"These notes are also saved to {notes_file_hint}", "dim"))
+    return lines
+
+
+__all__ = [
+    "ExportHarnessOptions",
+    "ExportNote",
+    "ExportNoteLine",
+    "HarnessMappingResult",
+    "McpCredentialEntry",
+    "ResolvedHarnessContext",
+    "format_export_notes",
+]

agentcore/cli/commands/export/wizard.py

@@ -0,0 +1,97 @@
+"""Interactive `export harness` (port of tui/screens/export: ExportHarnessFlow + ExportHarnessScreen)."""
+
+from __future__ import annotations
+
+import typer
+
+from agentcore.cli import interactive
+from agentcore.cli.errors import get_error_message
+from agentcore.lib.schemas.io.config_io import ConfigIO, to_jsonable
+
+C = interactive.Choice
+TITLE = "Export Harness to Python Strands Agent"
+
+
+def run_export_harness_wizard() -> None:
+    from agentcore.cli.commands.add._common import first_issue
+    from agentcore.cli.commands.export.harness_action import handle_export_harness
+    from agentcore.cli.commands.export.types import ExportHarnessOptions, format_export_notes
+    from agentcore.schema import AgentName
+
+    io = ConfigIO()
+    project = to_jsonable(io.read_project_spec())
+    harness_names = [h["name"] for h in project.get("harnesses") or []]
+    existing_agents = [r["name"] for r in project.get("runtimes") or []]
+    if not harness_names:
+        typer.echo("No harnesses found", err=True)
+        typer.echo("Add a harness first with `agentcore add harness` before exporting.", err=True)
+        raise typer.Exit(1)
+    container_only: set[str] = set()
+    for name in harness_names:
+        try:
+            spec = to_jsonable(io.read_harness_spec(name))
+        except Exception:  # noqa: BLE001
+            continue
+        if spec.get("containerUri") or spec.get("dockerfile"):
+            container_only.add(name)
+
+    typer.echo(TITLE)
+    harness = (
+        harness_names[0]
+        if len(harness_names) <= 1
+        else interactive.select(
+            "Select harness to export (Choose the harness configuration to generate a runtime agent from)",
+            [C(n, n) for n in harness_names],
+        )
+    )
+
+    def validate(value: str) -> str | None:
+        trimmed = value.strip()
+        if not trimmed:
+            return "Name is required"
+        issue = first_issue(AgentName, trimmed)
+        if issue:
+            return issue
+        return f'Agent "{trimmed}" already exists' if trimmed in existing_agents else None
+
+    target = interactive.text("Runtime agent name", default=f"{harness}Agent", validate=validate).strip()
+    builds = [
+        C("CodeZip", "CodeZip", "Package Python source as a zip artifact (default)"),
+        C("Container", "Container", "Build a Docker container image via ECR and CodeBuild"),
+    ]
+    if harness in container_only:
+        builds = [b for b in builds if b.value == "Container"]
+        description = "This harness uses a custom container — only Container builds are supported"
+    else:
+        description = "How the agent will be packaged and deployed"
+    build = interactive.select(f"Build type ({description})", builds)
+
+    typer.echo("Export configuration")
+    typer.echo(f"  Harness: {harness}")
+    typer.echo(f"  Runtime agent: {target}")
+    typer.echo(f"  Build type: {build}")
+    if not interactive.confirm("Export?", default=True):
+        typer.echo("Cancelled.")
+        return
+
+    try:
+        result = handle_export_harness(
+            ExportHarnessOptions(name=harness, target_agent_name=target, build=build),
+            lambda message: typer.echo(f"  ✓ {message}"),
+        )
+    except Exception as exc:  # noqa: BLE001
+        typer.echo("Export failed", err=True)
+        typer.echo(get_error_message(exc), err=True)
+        raise typer.Exit(1) from None
+    if not result.success:
+        typer.echo("Export failed", err=True)
+        typer.echo(get_error_message(result.error), err=True)
+        raise typer.Exit(1)
+    agent = result.value["agentName"]
+    typer.echo(f"✓ Exported harness → runtime agent {agent}")
+    typer.echo(f"Generated: app/{agent}/ · agentcore/agentcore.json updated")
+    for line in format_export_notes(result.value["notes"], result.value["notesPath"]):
+        typer.echo(line.text)
+
+
+__all__ = ["run_export_harness_wizard"]

agentcore/cli/commands/feedback/__init__.py

@@ -0,0 +1,69 @@
+"""`agentcore feedback` (port of src/cli/commands/feedback)."""
+
+from __future__ import annotations
+
+import json
+
+import typer
+
+from agentcore.cli.commands.feedback.action import handle_feedback
+from agentcore.cli.constants import ANSI
+from agentcore.cli.run_command import run_cli_command
+
+HELP = "Send feedback about the AgentCore CLI to the team."
+
+
+def feedback(
+    message: str | None = typer.Argument(None, help="Feedback message [non-interactive]"),
+    screenshot: str | None = typer.Option(
+        None, "--screenshot", help="Path to a PNG or JPG screenshot (max 100MB) [non-interactive]"
+    ),
+    as_json: bool = typer.Option(False, "--json", help="Output result as JSON [non-interactive]"),
+) -> None:
+    if message is None:
+        if as_json:
+            typer.echo("Error: --json requires a feedback message argument.", err=True)
+            raise typer.Exit(1)
+        from agentcore.cli import interactive
+        from agentcore.cli.commands.feedback.wizard import run_feedback_wizard
+
+        interactive.require_tty()
+        run_feedback_wizard(screenshot)
+        raise typer.Exit(0)
+
+    def action() -> None:
+        outcome = handle_feedback(message, screenshot)
+        if outcome.kind == "no-tty":
+            raise Exception("Feedback consent must be confirmed interactively. Re-run agentcore feedback in a TTY.")
+        if outcome.kind == "error":
+            raise outcome.error  # type: ignore[misc]
+        if outcome.kind == "declined":
+            if as_json:
+                typer.echo(json.dumps({"success": False, "error": "Feedback cancelled."}, separators=(",", ":")))
+            else:
+                typer.echo("Feedback cancelled. Nothing was submitted.")
+            return
+        result = outcome.result or {}
+        if as_json:
+            typer.echo(
+                json.dumps(
+                    {
+                        "success": True,
+                        "id": result.get("id"),
+                        "timestamp": result.get("timestamp"),
+                        "reference": result.get("reference"),
+                    },
+                    separators=(",", ":"),
+                )
+            )
+        else:
+            typer.echo(f"{ANSI.green}Thank you. Your feedback has been submitted (id: {result.get('id')}).{ANSI.reset}")
+
+    run_cli_command(as_json, action)
+
+
+def register(app: typer.Typer) -> None:
+    app.command("feedback", help=HELP)(feedback)
+
+
+__all__ = ["feedback", "register"]

agentcore/cli/commands/feedback/action.py

@@ -0,0 +1,30 @@
+"""Port of commands/feedback/action.ts."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Literal
+
+from agentcore.cli.commands.feedback.consent_prompt import prompt_for_consent
+from agentcore.lib.errors.types import to_error
+from agentcore.operations.feedback import submit_feedback
+
+
+@dataclass
+class FeedbackOutcome:
+    kind: Literal["submitted", "declined", "no-tty", "error"]
+    result: dict[str, Any] | None = None
+    error: BaseException | None = None
+
+
+def handle_feedback(message: str, screenshot: str | None = None) -> FeedbackOutcome:
+    consent = prompt_for_consent()
+    if not consent.accepted:
+        return FeedbackOutcome("no-tty" if consent.reason == "no-tty" else "declined")
+    try:
+        return FeedbackOutcome("submitted", result=submit_feedback(message, screenshot=screenshot, mode="cli"))
+    except Exception as exc:  # noqa: BLE001
+        return FeedbackOutcome("error", error=to_error(exc))
+
+
+__all__ = ["FeedbackOutcome", "handle_feedback"]

agentcore/cli/commands/feedback/consent_prompt.py

@@ -0,0 +1,35 @@
+"""AWS Customer Agreement consent prompt (port of commands/feedback/consent-prompt.ts)."""
+
+from __future__ import annotations
+
+import sys
+from dataclasses import dataclass
+from typing import Literal, TextIO
+
+from agentcore.operations.feedback.constants import CONSENT_TEXT
+
+PROMPT_LINE = "Submit feedback? [y/N] "
+
+
+@dataclass
+class ConsentPromptResult:
+    accepted: bool
+    reason: Literal["declined", "no-tty"] | None = None
+
+
+def prompt_for_consent(stdin: TextIO | None = None, stdout: TextIO | None = None) -> ConsentPromptResult:
+    """Show the consent text and read y/N; bare Enter means no, and non-TTY stdin is refused."""
+    stdin = stdin or sys.stdin
+    stdout = stdout or sys.stdout
+    if not stdin.isatty():
+        return ConsentPromptResult(False, "no-tty")
+    stdout.write(f"\n{CONSENT_TEXT}\n\n")
+    stdout.write(PROMPT_LINE)
+    stdout.flush()
+    line = stdin.readline()
+    answer = line.strip().lower()
+    accepted = answer in ("y", "yes")
+    return ConsentPromptResult(accepted, None if accepted else "declined")
+
+
+__all__ = ["PROMPT_LINE", "ConsentPromptResult", "prompt_for_consent"]

agentcore/cli/commands/feedback/wizard.py

@@ -0,0 +1,49 @@
+"""Interactive feedback (port of tui/screens/feedback: message -> screenshot -> consent -> submit)."""
+
+from __future__ import annotations
+
+import typer
+
+from agentcore.cli import interactive
+from agentcore.cli.errors import get_error_message
+from agentcore.operations.feedback import (
+    CONSENT_TEXT,
+    submit_feedback,
+    validate_feedback_message,
+    validate_screenshot_path,
+)
+
+
+def run_feedback_wizard(initial_screenshot: str | None = None) -> None:
+    typer.echo("Tell us what's on your mind")
+    message = interactive.text("Feedback", validate=validate_feedback_message)
+
+    def validate_path(value: str) -> str | None:
+        return validate_screenshot_path(value.strip()) if value.strip() else None
+
+    screenshot = interactive.text(
+        "Attach a screenshot (optional, PNG/JPG, max 100MB) — path, or press Enter to skip",
+        default=initial_screenshot or "",
+        validate=validate_path,
+    ).strip()
+
+    typer.echo("")
+    typer.echo("AWS Customer Agreement")
+    typer.echo(CONSENT_TEXT)
+    if screenshot:
+        typer.echo(f"Screenshot: {screenshot}")
+    if not interactive.confirm("Submit feedback?", default=False):
+        typer.echo("Feedback cancelled. Nothing was submitted.")
+        return
+
+    typer.echo("Submitting feedback…")
+    try:
+        submit_feedback(message, screenshot=screenshot or None, mode="tui")
+    except Exception as exc:  # noqa: BLE001
+        typer.echo("Failed to submit feedback.", err=True)
+        typer.echo(get_error_message(exc), err=True)
+        raise typer.Exit(1) from None
+    typer.echo("Thank you. Your feedback has been submitted.")
+
+
+__all__ = ["run_feedback_wizard"]

agentcore/cli/commands/fetch/__init__.py

@@ -0,0 +1,69 @@
+"""`agentcore fetch access` (port of src/cli/commands/fetch)."""
+
+import json
+
+import typer
+
+from agentcore.cli.commands.fetch.action import FetchAccessOptions, handle_fetch_access
+from agentcore.cli.commands.logs.guards import require_project
+from agentcore.cli.errors import get_error_message
+from agentcore.cli.groups import group
+
+
+def fetch_access_command(
+    name: str | None = typer.Option(None, "--name", help="Gateway, agent, or harness name [non-interactive]"),
+    resource_type: str = typer.Option(
+        "gateway", "--type", help="Resource type: gateway (default), agent, or harness [non-interactive]"
+    ),
+    target: str | None = typer.Option(None, "--target", help="Deployment target [non-interactive]"),
+    identity_name: str | None = typer.Option(
+        None, "--identity-name", help="Identity credential name for token fetch [non-interactive]"
+    ),
+    as_json: bool = typer.Option(False, "--json", help="Output as JSON [non-interactive]"),
+) -> None:
+    require_project()
+    options = FetchAccessOptions(
+        name=name, type=resource_type, target=target, identity_name=identity_name, json=as_json
+    )
+    try:
+        result = handle_fetch_access(options)
+    except Exception as exc:  # noqa: BLE001 - top-level command boundary, as upstream
+        if as_json:
+            typer.echo(json.dumps({"success": False, "error": get_error_message(exc)}, separators=(",", ":")))
+        else:
+            typer.secho(f"Error: {get_error_message(exc)}", fg=typer.colors.RED)
+        raise typer.Exit(1) from None
+
+    if not result.success:
+        if as_json:
+            payload = {"success": False, "error": result.error}
+            if result.available_gateways:
+                payload["availableGateways"] = result.available_gateways
+            typer.echo(json.dumps(payload, separators=(",", ":"), ensure_ascii=False))
+        else:
+            typer.secho(result.error or "", fg=typer.colors.RED)
+            if result.available_gateways:
+                typer.echo("Available gateways:")
+                for gw in result.available_gateways:
+                    typer.echo(f"  {gw['name']} [{gw['authType']}]")
+        raise typer.Exit(1)
+
+    r = result.result or {}
+    if as_json:
+        typer.echo(json.dumps({"success": True, **r}, indent=2, ensure_ascii=False))
+        return
+    typer.echo(typer.style("URL:", bold=True) + typer.style(f" {r.get('url', '')}", fg=typer.colors.GREEN))
+    typer.echo(typer.style("Auth:", bold=True) + f" {r.get('authType')}")
+    if r.get("message"):
+        typer.echo(r["message"])
+    if r.get("token"):
+        typer.echo(typer.style("Token:", bold=True) + f" {r['token']}")
+    if r.get("expiresIn") is not None:
+        typer.echo(typer.style("Expires in:", bold=True) + f" {r['expiresIn']}s")
+
+
+def register(app: typer.Typer) -> None:
+    group("fetch").command(
+        "access",
+        help="Fetch access info (URL, token, auth guidance) for a deployed gateway, agent, or harness.",
+    )(fetch_access_command)

agentcore/cli/commands/fetch/action.py

@@ -0,0 +1,62 @@
+"""Port of src/cli/commands/fetch/action.ts."""
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+
+from agentcore.operations import fetch_access
+from agentcore.operations.fetch_access import OAuthTokenResult, TokenFetchResult
+
+
+@dataclass
+class FetchAccessOptions:
+    name: str | None = None
+    type: str | None = None
+    target: str | None = None
+    identity_name: str | None = None
+    json: bool = False
+
+
+@dataclass
+class FetchAccessResult:
+    success: bool
+    result: TokenFetchResult | None = None
+    available_gateways: list[dict[str, Any]] | None = None
+    error: str | None = None
+
+
+def handle_fetch_access(options: FetchAccessOptions) -> FetchAccessResult:
+    resource_type = options.type or "gateway"
+    if resource_type == "agent":
+        return _fetch_token_access(options, "agent", fetch_access.fetch_runtime_token)
+    if resource_type == "harness":
+        return _fetch_token_access(options, "harness", fetch_access.fetch_harness_token)
+    return _handle_fetch_gateway_access(options)
+
+
+def _handle_fetch_gateway_access(options: FetchAccessOptions) -> FetchAccessResult:
+    if not options.name:
+        gateways = fetch_access.list_gateways(deploy_target=options.target)
+        if not gateways:
+            return FetchAccessResult(False, error="No deployed gateways found. Run `agentcore deploy` first.")
+        return FetchAccessResult(False, error="Missing required option: --name", available_gateways=list(gateways))
+    result = fetch_access.fetch_gateway_token(
+        options.name, deploy_target=options.target, identity_name=options.identity_name
+    )
+    return FetchAccessResult(True, result=result)
+
+
+def _fetch_token_access(
+    options: FetchAccessOptions, label: str, fetch_token: Callable[..., OAuthTokenResult]
+) -> FetchAccessResult:
+    """Shared CUSTOM_JWT flow for agent runtimes and harnesses (no invoke URL)."""
+    if not options.name:
+        return FetchAccessResult(False, error=f"Missing required option: --name <{label}>")
+    try:
+        token = fetch_token(options.name, deploy_target=options.target, identity_name=options.identity_name)
+    except Exception as exc:  # noqa: BLE001 - surfaced as a failed result, as upstream
+        return FetchAccessResult(False, error=str(exc))
+    result: TokenFetchResult = {"url": "", "authType": "CUSTOM_JWT", "token": token.token}
+    if token.expires_in is not None:
+        result["expiresIn"] = token.expires_in
+    return FetchAccessResult(True, result=result)

agentcore/cli/commands/help.py

@@ -0,0 +1,65 @@
+"""`agentcore help` / `agentcore help modes` (port of src/cli/commands/help/command.tsx)."""
+
+from __future__ import annotations
+
+import typer
+
+from agentcore.cli.groups import group
+
+MODES_HELP = """
+INTERACTIVE MODE (TUI)
+  Run any command without flags to launch the interactive terminal UI.
+  
+  Features:
+    • Guided prompts walk you through options
+    • Real-time streaming for invoke and dev
+    • Visual feedback and progress indicators
+  
+  Examples:
+    agentcore                    # Launch main menu
+    agentcore create             # Guided project creation
+    agentcore add                # Add resources interactively
+    agentcore invoke             # Chat with deployed agent
+
+NON-INTERACTIVE MODE (CLI)
+  Pass any flag marked [non-interactive] to run in CLI mode.
+  
+  Features:
+    • Scriptable for CI/CD pipelines
+    • JSON output with --json flag
+    • No prompts - fails fast on missing required options
+  
+  Examples:
+    agentcore create --name MyProject --defaults --json
+    agentcore deploy --target prod --yes
+    agentcore invoke "Hello" --stream
+    agentcore remove agent --name OldAgent --yes
+
+FLAGS THAT TRIGGER CLI MODE
+  Most flags trigger non-interactive mode, including:
+    --name, --json, --yes, --target, --stream, etc.
+  
+  Some flags work in both modes:
+    --session-id (invoke), --port (dev), --runtime (dev)
+"""
+
+
+def register(app: typer.Typer) -> None:
+    help_group = group("help")
+    help_group.info.no_args_is_help = False
+    help_group.info.help = "Display help topics"
+
+    @help_group.callback(invoke_without_command=True)
+    def help_root(ctx: typer.Context) -> None:
+        """Display help topics"""
+        if ctx.invoked_subcommand is not None:
+            return
+        typer.echo("Available help topics: modes")
+        typer.echo("Run `agentcore help <topic>` for details.")
+
+    @help_group.command("modes", help="Explain interactive vs non-interactive modes")
+    def modes() -> None:
+        typer.echo(MODES_HELP)
+
+
+__all__ = ["MODES_HELP", "register"]