agentcore-cli 0.31.1__py3-none-any.whl

agentcore/cli/constants.py

@@ -0,0 +1,96 @@
+"""CLI constants (port of the parts of ``src/cli/constants.ts`` used so far).
+
+Keep this a flat module of constants; other areas append what they need.
+"""
+
+import os
+import sys
+from typing import Final
+
+from agentcore.cdk.constants import CDK_APP_ENTRY, CDK_PROJECT_DIR
+
+# Max length AWS BedrockAgentCore allows for a runtime name (combined projectName_agentName).
+MAX_RUNTIME_NAME_LENGTH: Final = 48
+
+# Max length of a gateway name (deployed as `${projectName}-${gatewayName}`).
+MAX_GATEWAY_NAME_LENGTH: Final = 48
+
+# Current schema version for AgentCore configuration files.
+SCHEMA_VERSION: Final = 1
+
+# Default runtime endpoint name used in log group paths and console URLs.
+DEFAULT_ENDPOINT_NAME: Final = "DEFAULT"
+
+TELEMETRY_ENDPOINT: Final = "https://telemetry.agentcore.aws.dev"
+
+# Base image for generated Python Dockerfiles.
+PYTHON_BASE_IMAGE: Final = "public.ecr.aws/docker/library/python:3.12-slim-trixie"
+
+# Command descriptions used in CLI help.
+COMMAND_DESCRIPTIONS: Final[dict[str, str]] = {
+    "program": "Build and deploy Agentic AI applications on AgentCore",
+    "add": "Add resources to project config.",
+    "create": "Create a new AgentCore project",
+    "deploy": "Deploy project infrastructure to AWS via CDK.",
+    "dev": "Launch local dev server, or invoke an agent locally.",
+    "exec": "Open an interactive shell or run a one-shot command in a deployed agent container.",
+    "invoke": "Invoke a deployed agent endpoint.",
+    "logs": "Stream or search agent runtime logs.",
+    "package": "Package agent artifacts without deploying.",
+    "remove": "Remove resources from project config.",
+    "status": "Show deployed resource details and status.",
+    "traces": "View and download agent traces.",
+    "evals": "View saved eval and batch eval results from past runs.",
+    "feedback": "Send feedback about the AgentCore CLI to the team.",
+    "fetch": "Fetch access info for deployed resources.",
+    "pause": "Pause a deployed resource (online eval config, A/B test).",
+    "resume": "Resume a paused resource (online eval config, A/B test).",
+    "recommend": "Run optimization recommendations for system prompts and tool descriptions.",
+    "recommendations": "View recommendation history from past runs.",
+    "run": "Run evaluations, batch evaluations, or optimization recommendations.",
+    "stop": "Stop a running batch evaluation or A/B test.",
+    "import": "Import a runtime, memory, or starter toolkit into this project. [experimental]",
+    "telemetry": "Manage anonymous usage analytics preferences.",
+    "update": "Check for and install CLI updates",
+    "validate": "Validate agentcore/ config files.",
+    "config-bundle": "Manage configuration bundle versions and diffs.",
+    "archive": "Archive (delete) a batch evaluation or recommendation on the service and clear local history.",
+    "config": "Adjust global configuration settings such as telemetry opt-out status",
+    "export": "Export a harness to a Strands runtime agent.",
+}
+
+# Color gating: ANSI codes only when both streams are TTYs (FORCE_COLOR / NO_COLOR override).
+_STYLING_ENABLED: Final = bool(os.environ.get("FORCE_COLOR")) or (
+    not os.environ.get("NO_COLOR") and sys.stdout.isatty() and sys.stderr.isatty()
+)
+
+
+def _style(code: str) -> str:
+    return code if _STYLING_ENABLED else ""
+
+
+class ANSI:
+    red: Final = _style("\x1b[31m")
+    green: Final = _style("\x1b[32m")
+    yellow: Final = _style("\x1b[33m")
+    cyan: Final = _style("\x1b[36m")
+    dim: Final = _style("\x1b[2m")
+    reset: Final = _style("\x1b[0m")
+    clear_line: Final = "\x1b[K"
+    enter_alt_screen: Final = "\x1b[?1049h\x1b[H"
+    exit_alt_screen: Final = "\x1b[?1049l"
+    show_cursor: Final = "\x1b[?25h"
+
+
+__all__ = [
+    "ANSI",
+    "CDK_APP_ENTRY",
+    "CDK_PROJECT_DIR",
+    "COMMAND_DESCRIPTIONS",
+    "DEFAULT_ENDPOINT_NAME",
+    "MAX_GATEWAY_NAME_LENGTH",
+    "MAX_RUNTIME_NAME_LENGTH",
+    "PYTHON_BASE_IMAGE",
+    "SCHEMA_VERSION",
+    "TELEMETRY_ENDPOINT",
+]

agentcore/cli/errors.py

@@ -0,0 +1,118 @@
+"""Error classification helpers (port of src/cli/errors.ts).
+
+Upstream inspects AWS SDK v3 errors via ``err.name`` / ``err.Code``. For botocore the
+equivalent is ``ClientError.response["Error"]["Code"]``; ``_error_code`` covers both.
+"""
+
+from typing import Any
+
+EXPIRED_TOKEN_ERROR_CODES = frozenset(
+    {
+        "ExpiredToken",
+        "ExpiredTokenException",
+        "TokenRefreshRequired",
+        "CredentialsExpired",
+        "InvalidIdentityToken",
+        "UnauthorizedAccess",
+        # AccessDenied / AccessDeniedException are authorization errors, not expired tokens.
+        "InvalidClientTokenId",
+        "SignatureDoesNotMatch",
+        "RequestExpired",
+    }
+)
+
+
+def get_error_message(err: Any) -> str:
+    return str(err)
+
+
+def _error_code(err: Any) -> str | None:
+    response = getattr(err, "response", None)
+    if isinstance(response, dict):
+        code = (response.get("Error") or {}).get("Code")
+        if isinstance(code, str):
+            return code
+    for attr in ("name", "Code", "code"):
+        value = getattr(err, attr, None)
+        if isinstance(value, str):
+            return value
+    return None
+
+
+def is_access_denied_error(err: Any) -> bool:
+    return err is not None and _error_code(err) in ("AccessDeniedException", "AccessDenied")
+
+
+def is_no_credentials_error(err: Any) -> bool:
+    if err is None:
+        return False
+    if type(err).__name__ in ("AwsCredentialsError", "NoCredentialsError"):
+        return True
+    message = get_error_message(err).lower()
+    return any(
+        p in message
+        for p in (
+            "no aws credentials",
+            "could not load credentials",
+            "credentials not found",
+            "unable to locate credentials",
+        )
+    )
+
+
+def is_expired_token_error(err: Any) -> bool:
+    if err is None:
+        return False
+    if _error_code(err) in EXPIRED_TOKEN_ERROR_CODES:
+        return True
+    if type(err).__name__ == "TokenRetrievalError":  # botocore: SSO token expired
+        return True
+    cause = getattr(err, "__cause__", None)
+    if cause is not None:  # upstream checks a wrapped error instead of the outer message
+        return is_expired_token_error(cause)
+    message = get_error_message(err).lower()
+    return any(
+        p in message
+        for p in (
+            "expired token",
+            "token has expired",
+            "credentials have expired",
+            "security token included in the request is expired",
+            "the security token included in the request is invalid",
+        )
+    )
+
+
+def is_quota_exceeded_error(err: Any) -> bool:
+    if err is None:
+        return False
+    if _error_code(err) in ("ServiceQuotaExceededException", "LimitExceededException", "TooManyRequestsException"):
+        return True
+    message = get_error_message(err).lower()
+    return any(p in message for p in ("quota exceeded", "limit exceeded", "too many", "maximum number", "maxmanagers"))
+
+
+def is_stack_in_progress_error(err: Any) -> bool:
+    message = get_error_message(err).lower()
+    return ("is in" in message and "state and cannot be updated" in message) or any(
+        p in message
+        for p in (
+            "update_in_progress",
+            "create_in_progress",
+            "delete_in_progress",
+            "rollback_in_progress",
+            "stack is currently being updated",
+        )
+    )
+
+
+def is_changeset_in_progress_error(err: Any) -> bool:
+    message = get_error_message(err).lower()
+    return any(
+        p in message
+        for p in (
+            "invalidchangesetstatus",
+            "changeset is currently in progress",
+            "an operation on this changeset is currently in progress",
+        )
+    )

agentcore/cli/external_requirements/__init__.py

@@ -0,0 +1,67 @@
+"""External tool requirements: Node, uv, AWS CLI, container runtimes (port of ``src/cli/external-requirements``)."""
+
+from agentcore.cli.external_requirements.checks import (
+    CheckSeverity,
+    CliToolCheck,
+    CliToolsCheckResult,
+    DependencyCheckResult,
+    NpmCacheCheckResult,
+    VersionCheckResult,
+    check_aws_cli_version,
+    check_create_dependencies,
+    check_dependency_versions,
+    check_node_version,
+    check_npm_cache_ownership,
+    check_uv_version,
+    format_npm_cache_error,
+    format_version_error,
+    get_aws_login_guidance,
+    requires_container_runtime,
+    requires_uv,
+)
+from agentcore.cli.external_requirements.detect import (
+    ContainerRuntimeInfo,
+    DetectionResult,
+    detect_container_runtime,
+    require_container_runtime,
+)
+from agentcore.cli.external_requirements.versions import (
+    AWS_CLI_MIN_VERSION,
+    NODE_MIN_VERSION,
+    SemVer,
+    compare_sem_ver,
+    format_sem_ver,
+    parse_sem_ver,
+    sem_ver_gte,
+)
+
+__all__ = [
+    "AWS_CLI_MIN_VERSION",
+    "NODE_MIN_VERSION",
+    "CheckSeverity",
+    "CliToolCheck",
+    "CliToolsCheckResult",
+    "ContainerRuntimeInfo",
+    "DependencyCheckResult",
+    "DetectionResult",
+    "NpmCacheCheckResult",
+    "SemVer",
+    "VersionCheckResult",
+    "check_aws_cli_version",
+    "check_create_dependencies",
+    "check_dependency_versions",
+    "check_node_version",
+    "check_npm_cache_ownership",
+    "check_uv_version",
+    "compare_sem_ver",
+    "detect_container_runtime",
+    "format_npm_cache_error",
+    "format_sem_ver",
+    "format_version_error",
+    "get_aws_login_guidance",
+    "parse_sem_ver",
+    "require_container_runtime",
+    "requires_container_runtime",
+    "requires_uv",
+    "sem_ver_gte",
+]

agentcore/cli/external_requirements/checks.py

@@ -0,0 +1,280 @@
+"""External dependency version checks (port of ``external-requirements/checks.ts``)."""
+
+from __future__ import annotations
+
+import os
+import re
+from dataclasses import dataclass, field
+from typing import Any, Literal
+
+from agentcore.cli.external_requirements import detect as _detect
+from agentcore.cli.external_requirements.versions import (
+    AWS_CLI_MIN_VERSION,
+    NODE_MIN_VERSION,
+    format_sem_ver,
+    parse_sem_ver,
+    sem_ver_gte,
+)
+from agentcore.lib.utils.platform import is_windows
+from agentcore.lib.utils.subprocess import check_subprocess, run_subprocess_capture
+
+AWS_CLI_INSTALL_URL = "https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html"
+
+
+@dataclass(frozen=True)
+class VersionCheckResult:
+    satisfied: bool
+    current: str | None
+    required: str
+    binary: str
+
+
+def _parse_node_version(output: str) -> str | None:
+    match = re.search(r"v?(\d+\.\d+\.\d+)", output.strip())
+    return match.group(1) if match else None
+
+
+def _check_min_version(binary: str, args: list[str], parse, minimum) -> VersionCheckResult:  # type: ignore[no-untyped-def]
+    required = format_sem_ver(minimum)
+    result = run_subprocess_capture(binary, args)
+    if result.code != 0:
+        return VersionCheckResult(False, None, required, binary)
+    version_str = parse(result.stdout)
+    if not version_str:
+        return VersionCheckResult(False, None, required, binary)
+    current = parse_sem_ver(version_str)
+    if current is None:
+        return VersionCheckResult(False, version_str, required, binary)
+    return VersionCheckResult(sem_ver_gte(current, minimum), version_str, required, binary)
+
+
+def check_node_version() -> VersionCheckResult:
+    """Node.js >= 18 (required for CDK synth)."""
+    return _check_min_version("node", ["--version"], _parse_node_version, NODE_MIN_VERSION)
+
+
+def check_uv_version() -> VersionCheckResult:
+    """uv available in PATH (any version)."""
+    result = run_subprocess_capture("uv", ["--version"])
+    if result.code != 0:
+        return VersionCheckResult(False, None, "any", "uv")
+    match = re.search(r"uv\s+(\d+\.\d+\.\d+)", result.stdout.strip())
+    return VersionCheckResult(True, match.group(1) if match else "unknown", "any", "uv")
+
+
+def _parse_aws_cli_version(output: str) -> str | None:
+    match = re.search(r"aws-cli/(\d+\.\d+\.\d+)", output.strip())
+    return match.group(1) if match else None
+
+
+def check_aws_cli_version() -> VersionCheckResult:
+    """AWS CLI >= 2.32.0 (required for `aws login`)."""
+    return _check_min_version("aws", ["--version"], _parse_aws_cli_version, AWS_CLI_MIN_VERSION)
+
+
+_aws_login_guidance: str | None = None
+
+
+def get_aws_login_guidance() -> str:
+    """Version-aware guidance for authenticating with AWS (cached for the process lifetime)."""
+    global _aws_login_guidance
+    if _aws_login_guidance:
+        return _aws_login_guidance
+    check = check_aws_cli_version()
+    minimum = format_sem_ver(AWS_CLI_MIN_VERSION)
+    if check.current is None:
+        _aws_login_guidance = f"Install AWS CLI (v{minimum}+) from {AWS_CLI_INSTALL_URL} and run: aws login"
+    elif not check.satisfied:
+        _aws_login_guidance = (
+            f"Update AWS CLI from v{check.current} to v{minimum}+ ({AWS_CLI_INSTALL_URL}) and run: aws login"
+        )
+    else:
+        _aws_login_guidance = "Run: aws login"
+    return _aws_login_guidance
+
+
+def reset_aws_login_guidance_cache() -> None:
+    """Testing hook (upstream resets module state between tests)."""
+    global _aws_login_guidance
+    _aws_login_guidance = None
+
+
+def format_version_error(result: VersionCheckResult) -> str:
+    if result.current is None:
+        if result.binary == "uv":
+            return "'uv' not found. Install from https://github.com/astral-sh/uv#installation"
+        return f"'{result.binary}' not found. Install {result.binary} >= {result.required}"
+    return f"{result.binary} {result.current} is below minimum required version {result.required}"
+
+
+@dataclass(frozen=True)
+class NpmCacheCheckResult:
+    satisfied: bool
+    owner: str | None
+    cache_dir: str
+
+
+def check_npm_cache_ownership() -> NpmCacheCheckResult:
+    """``~/.npm`` must be owned by the current user (a past `sudo npm install` breaks npm)."""
+    cache_dir = os.path.join(os.path.expanduser("~"), ".npm")
+    if is_windows or not hasattr(os, "getuid"):
+        return NpmCacheCheckResult(True, None, cache_dir)
+    try:
+        stats = os.stat(cache_dir)
+    except OSError:
+        return NpmCacheCheckResult(True, None, cache_dir)
+    if stats.st_uid != os.getuid():
+        owner_result = run_subprocess_capture("id", ["-un", str(stats.st_uid)])
+        owner = owner_result.stdout.strip() if owner_result.code == 0 else f"uid={stats.st_uid}"
+        return NpmCacheCheckResult(False, owner, cache_dir)
+    return NpmCacheCheckResult(True, None, cache_dir)
+
+
+def format_npm_cache_error(result: NpmCacheCheckResult) -> str:
+    return (
+        f"npm cache directory ({result.cache_dir}) is owned by '{result.owner}' instead of the current user. "
+        "This was likely caused by a previous 'sudo npm install'. "
+        f"Fix: sudo chown -R $(whoami) {result.cache_dir}"
+    )
+
+
+def _runtimes(project_spec: Any) -> list[Any]:
+    return list(getattr(project_spec, "runtimes", None) or [])
+
+
+def requires_uv(project_spec: Any) -> bool:
+    """Any Python CodeZip agent needs uv."""
+    return any(agent.build == "CodeZip" for agent in _runtimes(project_spec))
+
+
+def requires_container_runtime(project_spec: Any) -> bool:
+    return any(agent.build == "Container" for agent in _runtimes(project_spec))
+
+
+@dataclass
+class DependencyCheckResult:
+    passed: bool
+    node_check: VersionCheckResult
+    uv_check: VersionCheckResult | None
+    npm_cache_check: NpmCacheCheckResult
+    container_runtime_available: bool
+    errors: list[str] = field(default_factory=list)
+
+
+def check_dependency_versions(project_spec: Any) -> DependencyCheckResult:
+    """Node >= 18 always; uv when there are CodeZip agents; npm cache ownership; container runtime (warn)."""
+    errors: list[str] = []
+    node_check = check_node_version()
+    if not node_check.satisfied:
+        errors.append(format_version_error(node_check))
+
+    uv_check = None
+    if requires_uv(project_spec):
+        uv_check = check_uv_version()
+        if not uv_check.satisfied:
+            errors.append(format_version_error(uv_check))
+
+    npm_cache_check = check_npm_cache_ownership()
+    if not npm_cache_check.satisfied:
+        errors.append(format_npm_cache_error(npm_cache_check))
+
+    container_runtime_available = True
+    if requires_container_runtime(project_spec):
+        # Warning only: deploy still works via CodeBuild.
+        container_runtime_available = _detect.detect_container_runtime().runtime is not None
+
+    return DependencyCheckResult(
+        passed=not errors,
+        node_check=node_check,
+        uv_check=uv_check,
+        npm_cache_check=npm_cache_check,
+        container_runtime_available=container_runtime_available,
+        errors=errors,
+    )
+
+
+CheckSeverity = Literal["error", "warn"]
+
+
+@dataclass(frozen=True)
+class CliToolCheck:
+    binary: str
+    severity: CheckSeverity
+    available: bool
+    install_hint: str | None = None
+
+
+@dataclass
+class CliToolsCheckResult:
+    passed: bool
+    checks: list[CliToolCheck]
+    errors: list[str]
+    warnings: list[str]
+
+
+def _check_binary_available(binary: str) -> bool:
+    strategies = [
+        lambda: check_subprocess("where", [binary]) if is_windows else check_subprocess("which", [binary]),
+        lambda: check_subprocess(binary, ["--version"]),
+        lambda: check_subprocess(binary, ["-v"]),
+    ]
+    return any(strategy() for strategy in strategies)
+
+
+def check_create_dependencies(language: str | None = None) -> CliToolsCheckResult:
+    """CLI tools for `create`: uv (Python only, error), npm (error), aws (warn)."""
+    checks: list[CliToolCheck] = []
+    errors: list[str] = []
+    warnings: list[str] = []
+
+    if language == "Python":
+        uv_available = _check_binary_available("uv")
+        checks.append(
+            CliToolCheck("uv", "error", uv_available, "Install from https://github.com/astral-sh/uv#installation")
+        )
+        if not uv_available:
+            errors.append(
+                "'uv' is required for Python projects. Install from https://github.com/astral-sh/uv#installation"
+            )
+
+    npm_available = _check_binary_available("npm")
+    checks.append(CliToolCheck("npm", "error", npm_available, "Install Node.js from https://nodejs.org/"))
+    if not npm_available:
+        errors.append("'npm' is required. Install Node.js from https://nodejs.org/")
+
+    if npm_available:
+        npm_cache_check = check_npm_cache_ownership()
+        if not npm_cache_check.satisfied:
+            errors.append(format_npm_cache_error(npm_cache_check))
+
+    aws_available = _check_binary_available("aws")
+    checks.append(CliToolCheck("aws", "warn", aws_available, "Install from https://aws.amazon.com/cli/"))
+    if not aws_available:
+        warnings.append(
+            f"'aws' CLI not found. Required for 'aws login'. Install v{format_sem_ver(AWS_CLI_MIN_VERSION)}+ "
+            f"from {AWS_CLI_INSTALL_URL}"
+        )
+
+    return CliToolsCheckResult(passed=not errors, checks=checks, errors=errors, warnings=warnings)
+
+
+__all__ = [
+    "AWS_CLI_INSTALL_URL",
+    "CheckSeverity",
+    "CliToolCheck",
+    "CliToolsCheckResult",
+    "DependencyCheckResult",
+    "NpmCacheCheckResult",
+    "VersionCheckResult",
+    "check_aws_cli_version",
+    "check_create_dependencies",
+    "check_dependency_versions",
+    "check_node_version",
+    "check_npm_cache_ownership",
+    "check_uv_version",
+    "format_npm_cache_error",
+    "format_version_error",
+    "get_aws_login_guidance",
+    "requires_container_runtime",
+    "requires_uv",
+]

agentcore/cli/external_requirements/detect.py

@@ -0,0 +1,55 @@
+"""Container runtime detection (port of ``external-requirements/detect.ts``)."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+from agentcore.lib.constants import CONTAINER_RUNTIMES, ContainerRuntime
+from agentcore.lib.utils.platform import is_windows
+from agentcore.lib.utils.subprocess import check_subprocess, run_subprocess_capture
+
+
+@dataclass(frozen=True)
+class ContainerRuntimeInfo:
+    runtime: ContainerRuntime
+    binary: str
+    version: str
+
+
+@dataclass(frozen=True)
+class DetectionResult:
+    runtime: ContainerRuntimeInfo | None
+
+
+def detect_container_runtime() -> DetectionResult:
+    """First installed runtime (docker, podman, finch) that can actually build containers."""
+    for runtime in CONTAINER_RUNTIMES:
+        exists = check_subprocess("where", [runtime]) if is_windows else check_subprocess("which", [runtime])
+        if not exists:
+            continue
+        result = run_subprocess_capture(runtime, ["--version"])
+        if result.code != 0:
+            continue
+        # Some shims answer --version but can't build; they may exit 0 on failure, so check stderr too.
+        build_check = run_subprocess_capture(runtime, ["build", "--help"])
+        if build_check.code != 0:
+            continue
+        if build_check.stderr and re.search(r"unknown command|not found", build_check.stderr, re.IGNORECASE):
+            continue
+        version = (result.stdout.strip().split("\n") or ["unknown"])[0] or "unknown"
+        return DetectionResult(ContainerRuntimeInfo(runtime=runtime, binary=runtime, version=version))
+    return DetectionResult(None)
+
+
+def require_container_runtime() -> ContainerRuntimeInfo:
+    runtime = detect_container_runtime().runtime
+    if runtime is None:
+        raise RuntimeError(
+            "No container runtime found. Install Docker (https://docker.com), "
+            "Podman (https://podman.io), or Finch (https://runfinch.com)."
+        )
+    return runtime
+
+
+__all__ = ["ContainerRuntimeInfo", "DetectionResult", "detect_container_runtime", "require_container_runtime"]

agentcore/cli/external_requirements/versions.py

@@ -0,0 +1,57 @@
+"""Semantic version parsing and comparison (port of ``external-requirements/versions.ts``)."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, order=True)
+class SemVer:
+    major: int
+    minor: int
+    patch: int
+
+
+_SEMVER_RE = re.compile(r"^(\d+)\.(\d+)\.(\d+)")
+
+
+def parse_sem_ver(version: str) -> SemVer | None:
+    """Parse ``"v18.0.0"`` / ``"18.0.0"`` / ``"0.9.2-beta"``; None when not semver-like."""
+    match = _SEMVER_RE.match(re.sub(r"^v", "", version))
+    if not match:
+        return None
+    return SemVer(int(match.group(1)), int(match.group(2)), int(match.group(3)))
+
+
+def compare_sem_ver(a: SemVer, b: SemVer) -> int:
+    if a.major != b.major:
+        return a.major - b.major
+    if a.minor != b.minor:
+        return a.minor - b.minor
+    return a.patch - b.patch
+
+
+def sem_ver_gte(a: SemVer, b: SemVer) -> bool:
+    return compare_sem_ver(a, b) >= 0
+
+
+def format_sem_ver(v: SemVer) -> str:
+    return f"{v.major}.{v.minor}.{v.patch}"
+
+
+# Minimum Node.js version required for CDK synth (ES2022 target).
+NODE_MIN_VERSION = SemVer(18, 0, 0)
+
+# Minimum AWS CLI version required for `aws login`.
+AWS_CLI_MIN_VERSION = SemVer(2, 32, 0)
+
+__all__ = [
+    "AWS_CLI_MIN_VERSION",
+    "NODE_MIN_VERSION",
+    "SemVer",
+    "compare_sem_ver",
+    "format_sem_ver",
+    "parse_sem_ver",
+    "sem_ver_gte",
+]