agentcore-cli 0.31.1__py3-none-any.whl

agentcore/cli/commands/deploy/command.py

@@ -0,0 +1,349 @@
+"""`agentcore deploy` registration and output (port of ``commands/deploy/command.tsx``).
+
+Any of ``--json``/``--target``/``--dry-run``/``--yes``/``--verbose`` selects non-interactive CLI
+mode. Otherwise upstream renders the Ink deploy screen; here the same decisions (target, credential
+source, teardown and bootstrap confirmation, token-expired retry) are asked as prompts.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from typing import Any
+
+import typer
+
+from agentcore.cli import interactive
+from agentcore.cli.commands.deploy._guards import require_project
+from agentcore.cli.commands.deploy.actions import ValidatedDeployOptions, handle_deploy
+from agentcore.cli.commands.deploy.progress import SPINNER_FRAMES, create_spinner_progress
+from agentcore.cli.commands.deploy.types import DeployOptions, DeployResult
+from agentcore.cli.commands.deploy.validate import validate_deploy_options
+from agentcore.cli.constants import ANSI, COMMAND_DESCRIPTIONS
+from agentcore.cli.errors import get_error_message, is_expired_token_error, is_no_credentials_error
+from agentcore.lib.utils.credentials import SecureCredentials
+
+__all__ = ["SPINNER_FRAMES", "execute_deploy", "handle_deploy_cli", "print_deploy_result", "register_deploy"]
+
+
+def _emit_json(payload: dict[str, Any]) -> None:
+    typer.echo(json.dumps(payload, separators=(",", ":"), ensure_ascii=False))
+
+
+def handle_deploy_cli(options: DeployOptions) -> None:
+    validation = validate_deploy_options(options)
+    if not validation.valid:
+        if options.json:
+            _emit_json({"success": False, "error": validation.error})
+        else:
+            typer.echo(validation.error, err=True)
+        raise typer.Exit(1)
+
+    try:
+        result = execute_deploy(options)
+    except Exception as exc:  # noqa: BLE001
+        result = DeployResult(success=False, error=exc)
+
+    if not result.success:
+        if options.json:
+            _emit_json(result.to_json())
+        else:
+            # Sync warnings may explain the failure; the notice was already printed live.
+            for warning in result.dependency_sync_result.warnings if result.dependency_sync_result else []:
+                typer.echo(f"⚠ {warning}", err=True)
+            typer.echo(str(result.error), err=True)
+            if result.log_path:
+                typer.echo(f"Log: {result.log_path}", err=True)
+        raise typer.Exit(1)
+
+    print_deploy_result(result, options)
+    raise typer.Exit(2 if result.post_deploy_warnings else 0)
+
+
+def execute_deploy(options: DeployOptions) -> DeployResult:
+    spinner = create_spinner_progress() if options.progress else None
+
+    def on_resource_event(message: str) -> None:
+        typer.echo(message)
+
+    def on_notice(message: str) -> None:
+        if spinner:
+            spinner.cleanup()
+        typer.echo(f"\n{message}\n")
+
+    try:
+        return handle_deploy(
+            ValidatedDeployOptions(
+                target=options.target or "default",
+                auto_confirm=options.yes,
+                verbose=options.verbose or options.diff,
+                plan=options.plan,
+                diff=options.diff,
+                on_progress=spinner.on_progress if spinner else None,
+                on_resource_event=on_resource_event if options.verbose else None,
+                # Never under --json: stdout must stay pure JSON.
+                on_notice=None if options.json else on_notice,
+            )
+        )
+    finally:
+        if spinner:
+            spinner.cleanup()
+
+
+def print_deploy_result(result: DeployResult, options: DeployOptions) -> None:
+    if options.json:
+        _emit_json(result.to_json())
+        return
+
+    # Informational only: never flips the exit code.
+    for warning in result.dependency_sync_result.warnings if result.dependency_sync_result else []:
+        typer.echo(f"⚠ {warning}", err=True)
+
+    if options.diff:
+        typer.echo(f"\n✓ Diff complete for '{result.target_name}' (stack: {result.stack_name})")
+    elif options.plan:
+        typer.echo(f"\n✓ Dry run complete for '{result.target_name}' (stack: {result.stack_name})")
+        typer.echo("\nRun `agentcore deploy` to deploy.")
+    else:
+        typer.echo(f"\n✓ Deployed to '{result.target_name}' (stack: {result.stack_name})")
+        if result.outputs:
+            typer.echo("\nOutputs:")
+            for key, value in result.outputs.items():
+                typer.echo(f"  {key}: {value}")
+        if result.post_deploy_warnings:
+            typer.echo("\n⚠ Post-deploy warnings:")
+            for warning in result.post_deploy_warnings:
+                typer.echo(f"  {warning}")
+        for note in result.notes or []:
+            typer.echo(f"\nNote: {note}")
+        if result.next_steps:
+            typer.echo(f"Next: {' | '.join(result.next_steps)}")
+
+    if result.log_path:
+        typer.echo(f"\nLog: {result.log_path}")
+
+
+# ---------------------------------------------------------------------------
+# Interactive mode (replaces the Ink DeployScreen)
+# ---------------------------------------------------------------------------
+
+
+def _select_target() -> str | None:
+    """useAwsTargetConfig: populate aws-targets.json when empty, choose among several targets."""
+    from agentcore.aws import aws_context
+    from agentcore.lib.errors.types import ConfigNotFoundError
+    from agentcore.lib.schemas.io.config_io import ConfigIO
+
+    config_io = ConfigIO()
+    try:
+        targets = config_io.read_aws_deployment_targets()
+    except ConfigNotFoundError:
+        targets = []
+
+    if not targets:
+        ctx = aws_context.detect_aws_context()
+        account = ctx.account_id
+        region = ctx.region
+        if account and interactive.confirm(f"Deploy to account {account} in region {region}?", default=True):
+            pass
+        else:
+            account = interactive.text(
+                "AWS account ID",
+                default=account or "",
+                validate=lambda v: None if v.isdigit() and len(v) == 12 else "Account ID must be 12 digits",
+            )
+            region = interactive.text("AWS region", default=region or "us-east-1")
+        config_io.write_aws_deployment_targets([{"name": "default", "account": account, "region": region}])
+        return "default"
+
+    if len(targets) == 1:
+        return targets[0].name
+    return interactive.select(
+        "Select deployment target",
+        [interactive.Choice(f"{t.name} ({t.region}:{t.account})", t.name) for t in targets],
+    )
+
+
+def _credential_prompt(options: ValidatedDeployOptions) -> None:
+    """CredentialSourcePrompt: use .env.local, enter values now (not saved), or skip identity setup."""
+    from agentcore.lib.schemas.io.config_io import ConfigIO
+    from agentcore.operations.deploy import pre_deploy_identity as pdi
+
+    try:
+        spec = ConfigIO().read_project_spec()
+    except Exception:  # noqa: BLE001
+        return
+    if not (pdi.has_identity_api_providers(spec) or pdi.has_identity_o_auth_providers(spec)):
+        return
+    credentials = pdi.get_all_credentials(spec)
+    typer.echo("Credentials required:")
+    for cred in credentials:
+        typer.echo(f"  {cred.env_var_name}")
+    choice = interactive.select(
+        "How should credentials be provided?",
+        [
+            interactive.Choice("Use values from agentcore/.env.local", "env"),
+            interactive.Choice("Enter values now (not saved)", "manual"),
+            interactive.Choice("Skip credential setup", "skip"),
+        ],
+    )
+    if choice == "manual":
+        values = {}
+        for cred in credentials:
+            value = interactive.text(cred.env_var_name, secret=True)
+            if value:
+                values[cred.env_var_name] = value
+        options.runtime_credentials = SecureCredentials(values)
+    elif choice == "skip":
+        options.skip_identity_setup = True
+
+
+def handle_deploy_interactive(diff_mode: bool = False) -> None:
+    from agentcore.cli.external_requirements import check_dependency_versions
+    from agentcore.lib.schemas.io.config_io import ConfigIO
+    from agentcore.operations.deploy.constants import BOOTSTRAP_EXPLAINER, BOOTSTRAP_TITLE
+
+    target = _select_target()
+    if not target:
+        raise typer.Exit(1)
+
+    # The TUI preflight also checks Node/uv/npm-cache before building.
+    try:
+        deps = check_dependency_versions(ConfigIO().read_project_spec())
+        if not deps.passed:
+            typer.echo("\n".join(deps.errors), err=True)
+            raise typer.Exit(1)
+    except typer.Exit:
+        raise
+    except Exception:  # noqa: BLE001 - project errors surface in the deploy itself
+        pass
+
+    while True:
+        spinner = create_spinner_progress()
+        state = {"step": ""}
+
+        def on_progress(step: str, status: str, _spinner=spinner, state=state) -> None:  # type: ignore[no-untyped-def]
+            if status == "start":
+                state["step"] = step
+            _spinner.on_progress(step, status)  # type: ignore[arg-type]
+
+        def on_deploy_message(msg: Any, _spinner=spinner, state=state) -> None:  # type: ignore[no-untyped-def]
+            if msg.progress and state["step"]:
+                _spinner.on_progress(
+                    f"{state['step']} ({msg.progress.completed}/{msg.progress.total} resources)", "start"
+                )
+
+        def on_notice(message: str, _spinner=spinner) -> None:  # type: ignore[no-untyped-def]
+            _spinner.cleanup()
+            typer.echo(f"\nNote: {message}\n")
+
+        def confirm_teardown(_spinner=spinner) -> bool:  # type: ignore[no-untyped-def]
+            _spinner.cleanup()
+            typer.echo(
+                "This will delete all AWS resources and the CloudFormation stack for this target. "
+                "This action cannot be undone."
+            )
+            return interactive.confirm("Tear down all deployed resources?", default=False)
+
+        def confirm_bootstrap(_spinner=spinner) -> bool:  # type: ignore[no-untyped-def]
+            _spinner.cleanup()
+            typer.echo(f"{BOOTSTRAP_TITLE}\n{BOOTSTRAP_EXPLAINER}")
+            return interactive.confirm("Bootstrap now?", default=True)
+
+        options = ValidatedDeployOptions(
+            target=target,
+            diff=diff_mode,
+            verbose=diff_mode,
+            on_progress=on_progress,
+            on_deploy_message=on_deploy_message,
+            on_notice=on_notice,
+            confirm_teardown=confirm_teardown,
+            confirm_bootstrap=confirm_bootstrap,
+        )
+        if not diff_mode:
+            _credential_prompt(options)
+        try:
+            result = handle_deploy(options)
+        finally:
+            spinner.cleanup()
+
+        if result.success:
+            if result.dependency_sync_result and result.dependency_sync_result.notice:
+                typer.echo(result.dependency_sync_result.notice)
+            print_deploy_result(result, DeployOptions(target=target, diff=diff_mode))
+            if not diff_mode:
+                raise typer.Exit(2 if result.post_deploy_warnings else 0)
+            return
+
+        typer.echo(f"{ANSI.red}{result.error}{ANSI.reset}", err=True)
+        if result.log_path:
+            typer.echo(f"Log: {result.log_path}", err=True)
+        if is_expired_token_error(result.error) or is_no_credentials_error(result.error):
+            from agentcore.cli.external_requirements import get_aws_login_guidance
+
+            typer.echo(f"\nYour AWS credentials are expired or missing. {get_aws_login_guidance()}", err=True)
+            if interactive.confirm("Retry after re-authenticating?", default=True):
+                continue
+        raise typer.Exit(1)
+
+
+# ---------------------------------------------------------------------------
+# Registration
+# ---------------------------------------------------------------------------
+
+
+def deploy_command(
+    target: str | None = typer.Option(
+        None, "--target", help='Deployment target name (default: "default") [non-interactive]'
+    ),
+    yes: bool = typer.Option(
+        False, "-y", "--yes", help="Auto-confirm prompts, read credentials from env [non-interactive]"
+    ),
+    verbose: bool = typer.Option(
+        False, "-v", "--verbose", help="Show resource-level deployment events [non-interactive]"
+    ),
+    as_json: bool = typer.Option(False, "--json", help="Output as JSON [non-interactive]"),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Preview deployment without deploying [non-interactive]"),
+    diff: bool = typer.Option(False, "--diff", help="Show CDK diff without deploying [non-interactive]"),
+    region: str | None = typer.Option(
+        None, "--region", help="AWS region to deploy the target to (e.g. us-east-1) [non-interactive]"
+    ),
+) -> None:
+    try:
+        require_project()
+        if region:
+            from agentcore.operations.deploy.region_override import apply_region_override
+
+            apply_region_override(region, target or "default")
+        if as_json or target or dry_run or yes or verbose or region:
+            handle_deploy_cli(
+                DeployOptions(
+                    target=target or "default",
+                    yes=yes,
+                    verbose=verbose,
+                    json=as_json,
+                    plan=dry_run,
+                    diff=diff,
+                    progress=not as_json,
+                )
+            )
+        elif diff:
+            interactive.require_tty()
+            handle_deploy_interactive(diff_mode=True)
+        else:
+            interactive.require_tty()
+            handle_deploy_interactive()
+    except typer.Exit:
+        raise
+    except Exception as exc:  # noqa: BLE001 - top-level command boundary
+        if as_json:
+            _emit_json({"success": False, "error": get_error_message(exc)})
+        else:
+            print(f"{ANSI.red}Error: {get_error_message(exc)}{ANSI.reset}", file=sys.stdout)
+        raise typer.Exit(1) from None
+
+
+def register_deploy(app: typer.Typer) -> None:
+    description = COMMAND_DESCRIPTIONS["deploy"]
+    app.command("deploy", help=description)(deploy_command)
+    app.command("dp", help=description, hidden=True)(deploy_command)

agentcore/cli/commands/deploy/progress.py

@@ -0,0 +1,115 @@
+"""Spinner progress for CLI deploys (port of ``commands/deploy/progress.ts``)."""
+
+from __future__ import annotations
+
+import sys
+import threading
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Literal
+
+from agentcore.cli.constants import ANSI
+from agentcore.lib.schemas.io.config_io import ConfigIO
+
+SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+
+StepStatus = Literal["start", "success", "error", "warn"]
+
+
+@dataclass
+class SpinnerProgress:
+    on_progress: Callable[[str, StepStatus], None]
+    cleanup: Callable[[], None]
+
+
+def create_spinner_progress(stream=None) -> SpinnerProgress:  # type: ignore[no-untyped-def]
+    """``⠋ step...`` while running, then ``✓ step`` / ``✗ step`` / yellow ``⚠ step``."""
+    out = stream or sys.stdout
+    state: dict[str, object] = {"stop": None, "thread": None}
+    lock = threading.Lock()
+
+    def clear_spinner() -> None:
+        stop = state["stop"]
+        if stop is not None:
+            stop.set()  # type: ignore[attr-defined]
+            thread = state["thread"]
+            if thread is not None:
+                thread.join()  # type: ignore[attr-defined]
+            state["stop"] = state["thread"] = None
+            with lock:
+                out.write(f"\r{ANSI.clear_line}")
+                out.flush()
+
+    def on_progress(step: str, status: StepStatus) -> None:
+        clear_spinner()
+        if status == "start":
+            stop = threading.Event()
+            with lock:
+                out.write(f"{SPINNER_FRAMES[0]} {step}...")
+                out.flush()
+
+            def spin() -> None:
+                i = 0
+                while not stop.wait(0.08):
+                    i = (i + 1) % len(SPINNER_FRAMES)
+                    with lock:
+                        out.write(f"\r{SPINNER_FRAMES[i]} {step}...")
+                        out.flush()
+
+            thread = threading.Thread(target=spin, daemon=True)
+            state["stop"], state["thread"] = stop, thread
+            thread.start()
+        elif status == "success":
+            print(f"✓ {step}", file=out, flush=True)
+        elif status == "warn":
+            print(f"{ANSI.yellow}⚠ {step}{ANSI.reset}", file=out, flush=True)
+        else:
+            print(f"✗ {step}", file=out, flush=True)
+
+    return SpinnerProgress(on_progress=on_progress, cleanup=clear_spinner)
+
+
+def run_cli_deploy() -> None:
+    """Deploy used by `dev` before starting the server (failures never block the dev server)."""
+    from agentcore.cli.commands.deploy.actions import ValidatedDeployOptions, handle_deploy
+    from agentcore.operations.deploy.change_detection import can_skip_deploy
+    from agentcore.operations.deploy.ensure_target import ensure_default_deployment_target
+
+    print("Deploying project resources...")
+    spinner = create_spinner_progress()
+    try:
+        config_io = ConfigIO()
+        ensure_default_deployment_target(config_io)
+        if can_skip_deploy(config_io):
+            spinner.on_progress("No changes detected — skipping deploy", "success")
+            spinner.cleanup()
+            print()
+            return
+        result = handle_deploy(
+            ValidatedDeployOptions(target="default", auto_confirm=True, on_progress=spinner.on_progress)
+        )
+        spinner.cleanup()
+        sync = result.dependency_sync_result
+        if sync and sync.notice:
+            print(f"\n{sync.notice}\n")
+        for warning in sync.warnings if sync else []:
+            print(f"{ANSI.yellow}⚠ {warning}{ANSI.reset}", file=sys.stderr)
+        if result.success:
+            print("Deploy complete.")
+            if result.log_path:
+                print(f"Deploy log: {result.log_path}")
+            print()
+        else:
+            print(
+                f"{ANSI.yellow}Deploy failed: {result.error}. Starting dev server anyway...{ANSI.reset}",
+                file=sys.stderr,
+            )
+            if result.log_path:
+                print(f"Deploy log: {result.log_path}", file=sys.stderr)
+            print()
+    except Exception as exc:  # noqa: BLE001
+        spinner.cleanup()
+        print(f"{ANSI.yellow}Deploy failed: {exc}. Starting dev server anyway...{ANSI.reset}\n", file=sys.stderr)
+
+
+__all__ = ["SPINNER_FRAMES", "SpinnerProgress", "create_spinner_progress", "run_cli_deploy"]

agentcore/cli/commands/deploy/types.py

@@ -0,0 +1,68 @@
+"""Deploy option/result types (port of ``commands/deploy/types.ts``)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from agentcore.lib.dependency_management.types import DependencySyncResult
+from agentcore.lib.errors.types import BaseError
+from agentcore.operations.deploy.dependency_sync import dependency_sync_result_to_json
+
+
+@dataclass
+class DeployOptions:
+    target: str | None = None
+    yes: bool = False
+    progress: bool = False
+    verbose: bool = False
+    json: bool = False
+    plan: bool = False
+    diff: bool = False
+
+
+@dataclass
+class DeployResult:
+    """``Result<{targetName, stackName, outputs, nextSteps, notes, postDeployWarnings}> & {logPath, dependencySyncResult}``."""
+
+    success: bool
+    error: BaseException | None = None
+    target_name: str | None = None
+    stack_name: str | None = None
+    outputs: dict[str, str] | None = None
+    next_steps: list[str] | None = None
+    notes: list[str] | None = None
+    post_deploy_warnings: list[str] | None = None
+    log_path: str | None = None
+    dependency_sync_result: DependencySyncResult | None = None
+    extra: dict[str, Any] = field(default_factory=dict)
+
+    def to_json(self) -> dict[str, Any]:
+        """Keys in upstream's object order; ``None`` (undefined) dropped. Failures as ``serializeResult``."""
+        sync = dependency_sync_result_to_json(self.dependency_sync_result) if self.dependency_sync_result else None
+        if self.success:
+            data: dict[str, Any] = {
+                "success": True,
+                "targetName": self.target_name,
+                "stackName": self.stack_name,
+                "outputs": self.outputs,
+                "logPath": self.log_path,
+                "nextSteps": self.next_steps,
+                "notes": self.notes,
+                "postDeployWarnings": self.post_deploy_warnings,
+                "dependencySyncResult": sync,
+            }
+        else:
+            data = {
+                "success": False,
+                "logPath": self.log_path,
+                "dependencySyncResult": sync,
+                "error": str(self.error) if self.error is not None else None,
+            }
+            if isinstance(self.error, BaseError):
+                data["errorName"] = self.error.name
+                data["errorSource"] = self.error.error_source
+        return {k: v for k, v in data.items() if v is not None}
+
+
+__all__ = ["DeployOptions", "DeployResult"]

agentcore/cli/commands/deploy/utils.py

@@ -0,0 +1,43 @@
+"""Deploy telemetry attributes (port of ``commands/deploy/utils.ts``; telemetry itself is not ported)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+DEFAULT_DEPLOY_ATTRS: dict[str, Any] = {
+    "runtime_count": 0,
+    "harness_count": 0,
+    "memory_count": 0,
+    "credential_count": 0,
+    "evaluator_count": 0,
+    "online_eval_count": 0,
+    "gateway_count": 0,
+    "gateway_target_count": 0,
+    "policy_engine_count": 0,
+    "policy_count": 0,
+    "deploy_mode": "deploy",
+}
+
+
+def compute_deploy_attrs(project_spec: Any, mode: str) -> dict[str, Any]:
+    def items(name: str) -> list[Any]:
+        return list(getattr(project_spec, name, None) or [])
+
+    gateways = items("agent_core_gateways")
+    engines = items("policy_engines")
+    return {
+        "runtime_count": len(items("runtimes")),
+        "harness_count": len(items("harnesses")),
+        "memory_count": len(items("memories")),
+        "credential_count": len(items("credentials")),
+        "evaluator_count": len(items("evaluators")),
+        "online_eval_count": len(items("online_eval_configs")),
+        "gateway_count": len(gateways),
+        "gateway_target_count": sum(len(getattr(g, "targets", None) or []) for g in gateways),
+        "policy_engine_count": len(engines),
+        "policy_count": sum(len(getattr(pe, "policies", None) or []) for pe in engines),
+        "deploy_mode": mode,
+    }
+
+
+__all__ = ["DEFAULT_DEPLOY_ATTRS", "compute_deploy_attrs"]

agentcore/cli/commands/deploy/validate.py

@@ -0,0 +1,21 @@
+"""Deploy option validation (port of ``commands/deploy/validate.ts``)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from agentcore.cli.commands.deploy.types import DeployOptions
+
+
+@dataclass(frozen=True)
+class ValidationResult:
+    valid: bool
+    error: str | None = None
+
+
+def validate_deploy_options(_options: DeployOptions) -> ValidationResult:
+    # Target is always set (defaulted to 'default' by the command handler).
+    return ValidationResult(valid=True)
+
+
+__all__ = ["ValidationResult", "validate_deploy_options"]

agentcore/cli/commands/dev/__init__.py

@@ -0,0 +1,5 @@
+"""`agentcore dev` (port of src/cli/commands/dev)."""
+
+from agentcore.cli.commands.dev.command import register
+
+__all__ = ["register"]

agentcore/cli/commands/dev/_deps.py

@@ -0,0 +1,50 @@
+"""Bridges to other feature areas (deploy, status, project guard), resolved lazily.
+
+Upstream imports `runCliDeploy` (commands/deploy/progress) and `isDeploySkippable`
+(operations/deploy/change-detection) directly; here they are looked up at call time so `dev`
+keeps working while those areas are still being ported.
+"""
+
+import subprocess
+import sys
+
+DESCRIPTION = "Launch local dev server, or invoke an agent locally."
+"""COMMAND_DESCRIPTIONS.dev from upstream cli/constants.ts."""
+
+# ANSI escapes from upstream cli/constants.ts (ANSI.*), used by dev output.
+ANSI_YELLOW = "\x1b[33m"
+ANSI_RESET = "\x1b[0m"
+
+
+def run_cli_deploy() -> None:
+    try:
+        from agentcore.cli.commands.deploy.progress import run_cli_deploy as deploy  # type: ignore[import-not-found]
+    except ImportError:
+        deploy = None
+    if deploy is not None:
+        deploy()
+        return
+    # Fallback until the deploy port exposes run_cli_deploy: run `agentcore deploy --yes`.
+    print("Deploying project resources...")
+    code = subprocess.call(
+        [sys.executable, "-c", "from agentcore.cli.main import app; app()", "deploy", "--yes"],
+    )
+    if code != 0:
+        raise RuntimeError("Deploy failed.")
+
+
+def is_deploy_skippable() -> bool:
+    try:
+        from agentcore.operations.deploy.change_detection import is_deploy_skippable as skippable
+    except ImportError:
+        return False
+    try:
+        return bool(skippable())
+    except Exception:  # noqa: BLE001 - when unsure, deploy (as upstream's catch-all)
+        return False
+
+
+def require_project() -> None:
+    from agentcore.cli.commands.logs.guards import require_project as guard
+
+    guard()