refactor: move CLI source modules to crewai-cli package

Copy all CLI source modules from lib/crewai/src/crewai/cli/ to the
new lib/cli/src/crewai_cli/ package, updating internal imports from
crewai.cli.* to crewai_cli.* throughout.

Includes: authentication, deploy, enterprise, organization, settings,
tools, triggers, templates, and all top-level CLI command modules.

Also excludes lib/cli/ from pre-commit mypy checks to match existing
behavior (original CLI code has the same type gaps).

.pre-commit-config.yaml

@@ -19,7 +19,7 @@ repos:
         language: system
         pass_filenames: true
         types: [python]
-        exclude: ^(lib/crewai/src/crewai/cli/templates/|lib/crewai/tests/|lib/crewai-tools/tests/|lib/crewai-files/tests/)
+        exclude: ^(lib/crewai/src/crewai/cli/templates/|lib/cli/|lib/crewai/tests/|lib/crewai-tools/tests/|lib/crewai-files/tests/)
   - repo: https://github.com/astral-sh/uv-pre-commit
     rev: 0.9.3
     hooks:

lib/cli/src/crewai_cli/add_crew_to_flow.py

@@ -0,0 +1,72 @@
+from pathlib import Path
+
+import click
+
+from crewai_cli.utils import copy_template
+
+
+def add_crew_to_flow(crew_name: str) -> None:
+    """Add a new crew to the current flow."""
+    # Check if pyproject.toml exists in the current directory
+    if not Path("pyproject.toml").exists():
+        click.secho(
+            "This command must be run from the root of a flow project.", fg="red"
+        )
+        raise click.ClickException(
+            "This command must be run from the root of a flow project."
+        )
+
+    # Determine the flow folder based on the current directory
+    flow_folder = Path.cwd()
+    crews_folder = flow_folder / "src" / flow_folder.name / "crews"
+
+    if not crews_folder.exists():
+        click.secho("Crews folder does not exist in the current flow.", fg="red")
+        raise click.ClickException("Crews folder does not exist in the current flow.")
+
+    # Create the crew within the flow's crews directory
+    create_embedded_crew(crew_name, parent_folder=crews_folder)
+
+    click.echo(
+        f"Crew {crew_name} added to the current flow successfully!",
+    )
+
+
+def create_embedded_crew(crew_name: str, parent_folder: Path) -> None:
+    """Create a new crew within an existing flow project."""
+    folder_name = crew_name.replace(" ", "_").replace("-", "_").lower()
+    class_name = crew_name.replace("_", " ").replace("-", " ").title().replace(" ", "")
+
+    crew_folder = parent_folder / folder_name
+
+    if crew_folder.exists():
+        if not click.confirm(
+            f"Crew {folder_name} already exists. Do you want to override it?"
+        ):
+            click.secho("Operation cancelled.", fg="yellow")
+            return
+        click.secho(f"Overriding crew {folder_name}...", fg="green", bold=True)
+    else:
+        click.secho(f"Creating crew {folder_name}...", fg="green", bold=True)
+        crew_folder.mkdir(parents=True)
+
+    # Create config and crew.py files
+    config_folder = crew_folder / "config"
+    config_folder.mkdir(exist_ok=True)
+
+    templates_dir = Path(__file__).parent / "templates" / "crew"
+    config_template_files = ["agents.yaml", "tasks.yaml"]
+    crew_template_file = f"{folder_name}.py"  # Updated file name
+
+    for file_name in config_template_files:
+        src_file = templates_dir / "config" / file_name
+        dst_file = config_folder / file_name
+        copy_template(src_file, dst_file, crew_name, class_name, folder_name)
+
+    src_file = templates_dir / "crew.py"
+    dst_file = crew_folder / crew_template_file
+    copy_template(src_file, dst_file, crew_name, class_name, folder_name)
+
+    click.secho(
+        f"Crew {crew_name} added to the flow successfully!", fg="green", bold=True
+    )

lib/cli/src/crewai_cli/authentication/__init__.py

@@ -0,0 +1,4 @@
+from crewai_cli.authentication.main import AuthenticationCommand
+
+
+__all__ = ["AuthenticationCommand"]

lib/cli/src/crewai_cli/authentication/constants.py

@@ -0,0 +1 @@
+ALGORITHMS = ["RS256"]

lib/cli/src/crewai_cli/authentication/main.py

@@ -0,0 +1,215 @@
+import time
+from typing import TYPE_CHECKING, Any, TypeVar, cast
+import webbrowser
+
+import httpx
+from pydantic import BaseModel, Field
+from rich.console import Console
+
+from crewai_cli.authentication.utils import validate_jwt_token
+from crewai_cli.config import Settings
+from crewai_cli.shared.token_manager import TokenManager
+
+
+console = Console()
+
+TOauth2Settings = TypeVar("TOauth2Settings", bound="Oauth2Settings")
+
+
+class Oauth2Settings(BaseModel):
+    provider: str = Field(
+        description="OAuth2 provider used for authentication (e.g., workos, okta, auth0)."
+    )
+    client_id: str = Field(
+        description="OAuth2 client ID issued by the provider, used during authentication requests."
+    )
+    domain: str = Field(
+        description="OAuth2 provider's domain (e.g., your-org.auth0.com) used for issuing tokens."
+    )
+    audience: str | None = Field(
+        description="OAuth2 audience value, typically used to identify the target API or resource.",
+        default=None,
+    )
+    extra: dict[str, Any] = Field(
+        description="Extra configuration for the OAuth2 provider.",
+        default={},
+    )
+
+    @classmethod
+    def from_settings(cls: type[TOauth2Settings]) -> TOauth2Settings:
+        """Create an Oauth2Settings instance from the CLI settings."""
+
+        settings = Settings()
+
+        return cls(
+            provider=settings.oauth2_provider,
+            domain=settings.oauth2_domain,
+            client_id=settings.oauth2_client_id,
+            audience=settings.oauth2_audience,
+            extra=settings.oauth2_extra,
+        )
+
+
+if TYPE_CHECKING:
+    from crewai_cli.authentication.providers.base_provider import BaseProvider
+
+
+class ProviderFactory:
+    @classmethod
+    def from_settings(
+        cls: type["ProviderFactory"],  # noqa: UP037
+        settings: Oauth2Settings | None = None,
+    ) -> "BaseProvider":  # noqa: UP037
+        settings = settings or Oauth2Settings.from_settings()
+
+        import importlib
+
+        module = importlib.import_module(
+            f"crewai_cli.authentication.providers.{settings.provider.lower()}"
+        )
+        # Converts from snake_case to CamelCase to obtain the provider class name.
+        provider = getattr(
+            module,
+            f"{''.join(word.capitalize() for word in settings.provider.split('_'))}Provider",
+        )
+
+        return cast("BaseProvider", provider(settings))
+
+
+class AuthenticationCommand:
+    def __init__(self) -> None:
+        self.token_manager = TokenManager()
+        self.oauth2_provider = ProviderFactory.from_settings()
+
+    def login(self) -> None:
+        """Sign up to CrewAI+"""
+        console.print("Signing in to CrewAI AMP...\n", style="bold blue")
+
+        device_code_data = self._get_device_code()
+        self._display_auth_instructions(device_code_data)
+
+        return self._poll_for_token(device_code_data)
+
+    def _get_device_code(self) -> dict[str, Any]:
+        """Get the device code to authenticate the user."""
+
+        device_code_payload = {
+            "client_id": self.oauth2_provider.get_client_id(),
+            "scope": " ".join(self.oauth2_provider.get_oauth_scopes()),
+            "audience": self.oauth2_provider.get_audience(),
+        }
+        response = httpx.post(
+            url=self.oauth2_provider.get_authorize_url(),
+            data=device_code_payload,
+            timeout=20,
+        )
+        response.raise_for_status()
+        return cast(dict[str, Any], response.json())
+
+    def _display_auth_instructions(self, device_code_data: dict[str, str]) -> None:
+        """Display the authentication instructions to the user."""
+
+        verification_uri = device_code_data.get(
+            "verification_uri_complete", device_code_data.get("verification_uri", "")
+        )
+
+        console.print("1. Navigate to: ", verification_uri)
+        console.print("2. Enter the following code: ", device_code_data["user_code"])
+        webbrowser.open(verification_uri)
+
+    def _poll_for_token(self, device_code_data: dict[str, Any]) -> None:
+        """Polls the server for the token until it is received, or max attempts are reached."""
+
+        token_payload = {
+            "grant_type": "urn:ietf:params:oauth:grant-type:device_code",
+            "device_code": device_code_data["device_code"],
+            "client_id": self.oauth2_provider.get_client_id(),
+        }
+
+        console.print("\nWaiting for authentication... ", style="bold blue", end="")
+
+        attempts = 0
+        while True and attempts < 10:
+            response = httpx.post(
+                self.oauth2_provider.get_token_url(), data=token_payload, timeout=30
+            )
+            token_data = response.json()
+
+            if response.status_code == 200:
+                self._validate_and_save_token(token_data)
+
+                console.print(
+                    "Success!",
+                    style="bold green",
+                )
+
+                self._login_to_tool_repository()
+
+                console.print("\n[bold green]Welcome to CrewAI AMP![/bold green]\n")
+                return
+
+            if token_data["error"] not in ("authorization_pending", "slow_down"):
+                raise httpx.HTTPError(
+                    token_data.get("error_description") or token_data.get("error")
+                )
+
+            time.sleep(device_code_data["interval"])
+            attempts += 1
+
+        console.print(
+            "Timeout: Failed to get the token. Please try again.", style="bold red"
+        )
+
+    def _validate_and_save_token(self, token_data: dict[str, Any]) -> None:
+        """Validates the JWT token and saves the token to the token manager."""
+
+        jwt_token = token_data["access_token"]
+        issuer = self.oauth2_provider.get_issuer()
+        jwt_token_data = {
+            "jwt_token": jwt_token,
+            "jwks_url": self.oauth2_provider.get_jwks_url(),
+            "issuer": issuer,
+            "audience": self.oauth2_provider.get_audience(),
+        }
+
+        decoded_token = validate_jwt_token(**jwt_token_data)
+
+        expires_at = decoded_token.get("exp", 0)
+        self.token_manager.save_tokens(jwt_token, expires_at)
+
+    def _login_to_tool_repository(self) -> None:
+        """Login to the tool repository."""
+
+        from crewai_cli.tools.main import ToolCommand
+
+        try:
+            console.print(
+                "Now logging you in to the Tool Repository... ",
+                style="bold blue",
+                end="",
+            )
+
+            ToolCommand().login()
+
+            console.print(
+                "Success!\n",
+                style="bold green",
+            )
+
+            settings = Settings()
+
+            console.print(
+                f"You are now authenticated to the tool repository for organization [bold cyan]'{settings.org_name if settings.org_name else settings.org_uuid}'[/bold cyan]",
+                style="green",
+            )
+        except Exception:
+            console.print(
+                "\n[bold yellow]Warning:[/bold yellow] Authentication with the Tool Repository failed.",
+                style="yellow",
+            )
+            console.print(
+                "Other features will work normally, but you may experience limitations "
+                "with downloading and publishing tools."
+                "\nRun [bold]crewai login[/bold] to try logging in again.\n",
+                style="yellow",
+            )

lib/cli/src/crewai_cli/authentication/providers/auth0.py

@@ -0,0 +1,34 @@
+from crewai_cli.authentication.providers.base_provider import BaseProvider
+
+
+class Auth0Provider(BaseProvider):
+    def get_authorize_url(self) -> str:
+        return f"https://{self._get_domain()}/oauth/device/code"
+
+    def get_token_url(self) -> str:
+        return f"https://{self._get_domain()}/oauth/token"
+
+    def get_jwks_url(self) -> str:
+        return f"https://{self._get_domain()}/.well-known/jwks.json"
+
+    def get_issuer(self) -> str:
+        return f"https://{self._get_domain()}/"
+
+    def get_audience(self) -> str:
+        if self.settings.audience is None:
+            raise ValueError(
+                "Audience is required. Please set it in the configuration."
+            )
+        return self.settings.audience
+
+    def get_client_id(self) -> str:
+        if self.settings.client_id is None:
+            raise ValueError(
+                "Client ID is required. Please set it in the configuration."
+            )
+        return self.settings.client_id
+
+    def _get_domain(self) -> str:
+        if self.settings.domain is None:
+            raise ValueError("Domain is required. Please set it in the configuration.")
+        return self.settings.domain

lib/cli/src/crewai_cli/authentication/providers/base_provider.py

@@ -0,0 +1,33 @@
+from abc import ABC, abstractmethod
+
+from crewai_cli.authentication.main import Oauth2Settings
+
+
+class BaseProvider(ABC):
+    def __init__(self, settings: Oauth2Settings):
+        self.settings = settings
+
+    @abstractmethod
+    def get_authorize_url(self) -> str: ...
+
+    @abstractmethod
+    def get_token_url(self) -> str: ...
+
+    @abstractmethod
+    def get_jwks_url(self) -> str: ...
+
+    @abstractmethod
+    def get_issuer(self) -> str: ...
+
+    @abstractmethod
+    def get_audience(self) -> str: ...
+
+    @abstractmethod
+    def get_client_id(self) -> str: ...
+
+    def get_required_fields(self) -> list[str]:
+        """Returns which provider-specific fields inside the "extra" dict will be required"""
+        return []
+
+    def get_oauth_scopes(self) -> list[str]:
+        return ["openid", "profile", "email"]

lib/cli/src/crewai_cli/authentication/providers/entra_id.py

@@ -0,0 +1,43 @@
+from typing import cast
+
+from crewai_cli.authentication.providers.base_provider import BaseProvider
+
+
+class EntraIdProvider(BaseProvider):
+    def get_authorize_url(self) -> str:
+        return f"{self._base_url()}/oauth2/v2.0/devicecode"
+
+    def get_token_url(self) -> str:
+        return f"{self._base_url()}/oauth2/v2.0/token"
+
+    def get_jwks_url(self) -> str:
+        return f"{self._base_url()}/discovery/v2.0/keys"
+
+    def get_issuer(self) -> str:
+        return f"{self._base_url()}/v2.0"
+
+    def get_audience(self) -> str:
+        if self.settings.audience is None:
+            raise ValueError(
+                "Audience is required. Please set it in the configuration."
+            )
+        return self.settings.audience
+
+    def get_client_id(self) -> str:
+        if self.settings.client_id is None:
+            raise ValueError(
+                "Client ID is required. Please set it in the configuration."
+            )
+        return self.settings.client_id
+
+    def get_oauth_scopes(self) -> list[str]:
+        return [
+            *super().get_oauth_scopes(),
+            *cast(str, self.settings.extra.get("scope", "")).split(),
+        ]
+
+    def get_required_fields(self) -> list[str]:
+        return ["scope"]
+
+    def _base_url(self) -> str:
+        return f"https://login.microsoftonline.com/{self.settings.domain}"

lib/cli/src/crewai_cli/authentication/providers/keycloak.py

@@ -0,0 +1,32 @@
+from crewai_cli.authentication.providers.base_provider import BaseProvider
+
+
+class KeycloakProvider(BaseProvider):
+    def get_authorize_url(self) -> str:
+        return f"{self._oauth2_base_url()}/realms/{self.settings.extra.get('realm')}/protocol/openid-connect/auth/device"
+
+    def get_token_url(self) -> str:
+        return f"{self._oauth2_base_url()}/realms/{self.settings.extra.get('realm')}/protocol/openid-connect/token"
+
+    def get_jwks_url(self) -> str:
+        return f"{self._oauth2_base_url()}/realms/{self.settings.extra.get('realm')}/protocol/openid-connect/certs"
+
+    def get_issuer(self) -> str:
+        return f"{self._oauth2_base_url()}/realms/{self.settings.extra.get('realm')}"
+
+    def get_audience(self) -> str:
+        return self.settings.audience or "no-audience-provided"
+
+    def get_client_id(self) -> str:
+        if self.settings.client_id is None:
+            raise ValueError(
+                "Client ID is required. Please set it in the configuration."
+            )
+        return self.settings.client_id
+
+    def get_required_fields(self) -> list[str]:
+        return ["realm"]
+
+    def _oauth2_base_url(self) -> str:
+        domain = self.settings.domain.removeprefix("https://").removeprefix("http://")
+        return f"https://{domain}"

lib/cli/src/crewai_cli/authentication/providers/okta.py

@@ -0,0 +1,42 @@
+from crewai_cli.authentication.providers.base_provider import BaseProvider
+
+
+class OktaProvider(BaseProvider):
+    def get_authorize_url(self) -> str:
+        return f"{self._oauth2_base_url()}/v1/device/authorize"
+
+    def get_token_url(self) -> str:
+        return f"{self._oauth2_base_url()}/v1/token"
+
+    def get_jwks_url(self) -> str:
+        return f"{self._oauth2_base_url()}/v1/keys"
+
+    def get_issuer(self) -> str:
+        return self._oauth2_base_url().removesuffix("/oauth2")
+
+    def get_audience(self) -> str:
+        if self.settings.audience is None:
+            raise ValueError(
+                "Audience is required. Please set it in the configuration."
+            )
+        return self.settings.audience
+
+    def get_client_id(self) -> str:
+        if self.settings.client_id is None:
+            raise ValueError(
+                "Client ID is required. Please set it in the configuration."
+            )
+        return self.settings.client_id
+
+    def get_required_fields(self) -> list[str]:
+        return ["authorization_server_name", "using_org_auth_server"]
+
+    def _oauth2_base_url(self) -> str:
+        using_org_auth_server = self.settings.extra.get("using_org_auth_server", False)
+
+        if using_org_auth_server:
+            base_url = f"https://{self.settings.domain}/oauth2"
+        else:
+            base_url = f"https://{self.settings.domain}/oauth2/{self.settings.extra.get('authorization_server_name', 'default')}"
+
+        return f"{base_url}"

lib/cli/src/crewai_cli/authentication/providers/workos.py

@@ -0,0 +1,30 @@
+from crewai_cli.authentication.providers.base_provider import BaseProvider
+
+
+class WorkosProvider(BaseProvider):
+    def get_authorize_url(self) -> str:
+        return f"https://{self._get_domain()}/oauth2/device_authorization"
+
+    def get_token_url(self) -> str:
+        return f"https://{self._get_domain()}/oauth2/token"
+
+    def get_jwks_url(self) -> str:
+        return f"https://{self._get_domain()}/oauth2/jwks"
+
+    def get_issuer(self) -> str:
+        return f"https://{self._get_domain()}"
+
+    def get_audience(self) -> str:
+        return self.settings.audience or ""
+
+    def get_client_id(self) -> str:
+        if self.settings.client_id is None:
+            raise ValueError(
+                "Client ID is required. Please set it in the configuration."
+            )
+        return self.settings.client_id
+
+    def _get_domain(self) -> str:
+        if self.settings.domain is None:
+            raise ValueError("Domain is required. Please set it in the configuration.")
+        return self.settings.domain

lib/cli/src/crewai_cli/authentication/token.py

@@ -0,0 +1,13 @@
+from crewai_cli.shared.token_manager import TokenManager
+
+
+class AuthError(Exception):
+    pass
+
+
+def get_auth_token() -> str:
+    """Get the authentication token."""
+    access_token = TokenManager().get_token()
+    if not access_token:
+        raise AuthError("No token found, make sure you are logged in")
+    return access_token

lib/cli/src/crewai_cli/authentication/utils.py

@@ -0,0 +1,63 @@
+from typing import Any
+
+import jwt
+from jwt import PyJWKClient
+
+
+def validate_jwt_token(
+    jwt_token: str, jwks_url: str, issuer: str, audience: str
+) -> Any:
+    """
+    Verify the token's signature and claims using PyJWT.
+    :param jwt_token: The JWT (JWS) string to validate.
+    :param jwks_url: The URL of the JWKS endpoint.
+    :param issuer: The expected issuer of the token.
+    :param audience: The expected audience of the token.
+    :return: The decoded token.
+    :raises Exception: If the token is invalid for any reason (e.g., signature mismatch,
+                       expired, incorrect issuer/audience, JWKS fetching error,
+                       missing required claims).
+    """
+
+    try:
+        jwk_client = PyJWKClient(jwks_url)
+        signing_key = jwk_client.get_signing_key_from_jwt(jwt_token)
+
+        _unverified_decoded_token = jwt.decode(
+            jwt_token, options={"verify_signature": False}
+        )
+
+        return jwt.decode(
+            jwt_token,
+            signing_key.key,
+            algorithms=["RS256"],
+            audience=audience,
+            issuer=issuer,
+            leeway=10.0,
+            options={
+                "verify_signature": True,
+                "verify_exp": True,
+                "verify_nbf": True,
+                "verify_iat": True,
+                "require": ["exp", "iat", "iss", "aud", "sub"],
+            },
+        )
+
+    except jwt.ExpiredSignatureError as e:
+        raise Exception("Token has expired.") from e
+    except jwt.InvalidAudienceError as e:
+        actual_audience = _unverified_decoded_token.get("aud", "[no audience found]")
+        raise Exception(
+            f"Invalid token audience. Got: '{actual_audience}'. Expected: '{audience}'"
+        ) from e
+    except jwt.InvalidIssuerError as e:
+        actual_issuer = _unverified_decoded_token.get("iss", "[no issuer found]")
+        raise Exception(
+            f"Invalid token issuer. Got: '{actual_issuer}'. Expected: '{issuer}'"
+        ) from e
+    except jwt.MissingRequiredClaimError as e:
+        raise Exception(f"Token is missing required claims: {e!s}") from e
+    except jwt.exceptions.PyJWKClientError as e:
+        raise Exception(f"JWKS or key processing error: {e!s}") from e
+    except jwt.InvalidTokenError as e:
+        raise Exception(f"Invalid token: {e!s}") from e

lib/cli/src/crewai_cli/cli.py

@@ -0,0 +1,781 @@
+from __future__ import annotations
+
+from importlib.metadata import version as get_version
+import os
+import subprocess
+from typing import Any
+
+import click
+
+from crewai_cli.add_crew_to_flow import add_crew_to_flow
+from crewai_cli.authentication.main import AuthenticationCommand
+from crewai_cli.config import Settings
+from crewai_cli.create_crew import create_crew
+from crewai_cli.create_flow import create_flow
+from crewai_cli.crew_chat import run_chat
+from crewai_cli.deploy.main import DeployCommand
+from crewai_cli.enterprise.main import EnterpriseConfigureCommand
+from crewai_cli.evaluate_crew import evaluate_crew
+from crewai_cli.install_crew import install_crew
+from crewai_cli.kickoff_flow import kickoff_flow
+from crewai_cli.organization.main import OrganizationCommand
+from crewai_cli.plot_flow import plot_flow
+from crewai_cli.replay_from_task import replay_task_command
+from crewai_cli.reset_memories_command import reset_memories_command
+from crewai_cli.run_crew import run_crew
+from crewai_cli.settings.main import SettingsCommand
+from crewai_cli.task_outputs import load_task_outputs
+from crewai_cli.tools.main import ToolCommand
+from crewai_cli.train_crew import train_crew
+from crewai_cli.triggers.main import TriggersCommand
+from crewai_cli.update_crew import update_crew
+from crewai_cli.user_data import (
+    _load_user_data,
+    _save_user_data,
+    is_tracing_enabled,
+)
+from crewai_cli.utils import build_env_with_tool_repository_credentials, read_toml
+
+
+def _get_cli_version() -> str:
+    """Return the best available version string for the CLI."""
+    # Prefer crewai version if installed (keeps existing UX)
+    try:
+        return get_version("crewai")
+    except Exception:  # noqa: S110
+        pass
+    try:
+        return get_version("crewai-cli")
+    except Exception:
+        return "unknown"
+
+
+@click.group()
+@click.version_option(_get_cli_version())
+def crewai():
+    """Top-level command group for crewai."""
+
+
+@crewai.command(
+    name="uv",
+    context_settings={"ignore_unknown_options": True},
+)
+@click.argument("uv_args", nargs=-1, type=click.UNPROCESSED)
+def uv(uv_args):
+    """A wrapper around uv commands that adds custom tool authentication through env vars."""
+    env = os.environ.copy()
+    try:
+        pyproject_data = read_toml()
+        sources = pyproject_data.get("tool", {}).get("uv", {}).get("sources", {})
+
+        for source_config in sources.values():
+            if isinstance(source_config, dict):
+                index = source_config.get("index")
+                if index:
+                    index_env = build_env_with_tool_repository_credentials(index)
+                    env.update(index_env)
+    except (FileNotFoundError, KeyError) as e:
+        raise SystemExit(
+            "Error. A valid pyproject.toml file is required. Check that a valid pyproject.toml file exists in the current directory."
+        ) from e
+    except Exception as e:
+        raise SystemExit(f"Error: {e}") from e
+
+    try:
+        subprocess.run(  # noqa: S603
+            ["uv", *uv_args],  # noqa: S607
+            capture_output=False,
+            env=env,
+            text=True,
+            check=True,
+        )
+    except subprocess.CalledProcessError as e:
+        click.secho(f"uv command failed with exit code {e.returncode}", fg="red")
+        raise SystemExit(e.returncode) from e
+
+
+@crewai.command()
+@click.argument("type", type=click.Choice(["crew", "flow"]))
+@click.argument("name")
+@click.option("--provider", type=str, help="The provider to use for the crew")
+@click.option("--skip_provider", is_flag=True, help="Skip provider validation")
+def create(type, name, provider, skip_provider=False):
+    """Create a new crew, or flow."""
+    if type == "crew":
+        create_crew(name, provider, skip_provider)
+    elif type == "flow":
+        create_flow(name)
+    else:
+        click.secho("Error: Invalid type. Must be 'crew' or 'flow'.", fg="red")
+
+
+@crewai.command()
+@click.option(
+    "--tools", is_flag=True, help="Show the installed version of crewai tools"
+)
+def version(tools):
+    """Show the installed version of crewai."""
+    try:
+        crewai_version = get_version("crewai")
+    except Exception:
+        crewai_version = "unknown version"
+    click.echo(f"crewai version: {crewai_version}")
+
+    if tools:
+        try:
+            tools_version = get_version("crewai-tools")
+            click.echo(f"crewai tools version: {tools_version}")
+        except Exception:
+            click.echo("crewai tools not installed")
+
+
+@crewai.command()
+@click.option(
+    "-n",
+    "--n_iterations",
+    type=int,
+    default=5,
+    help="Number of iterations to train the crew",
+)
+@click.option(
+    "-f",
+    "--filename",
+    type=str,
+    default="trained_agents_data.pkl",
+    help="Path to a custom file for training",
+)
+def train(n_iterations: int, filename: str):
+    """Train the crew."""
+    click.echo(f"Training the Crew for {n_iterations} iterations")
+    train_crew(n_iterations, filename)
+
+
+@crewai.command()
+@click.option(
+    "-t",
+    "--task_id",
+    type=str,
+    help="Replay the crew from this task ID, including all subsequent tasks.",
+)
+def replay(task_id: str) -> None:
+    """Replay the crew execution from a specific task."""
+    try:
+        click.echo(f"Replaying the crew from task {task_id}")
+        replay_task_command(task_id)
+    except Exception as e:
+        click.echo(f"An error occurred while replaying: {e}", err=True)
+
+
+@crewai.command()
+def log_tasks_outputs() -> None:
+    """Retrieve your latest crew.kickoff() task outputs."""
+    try:
+        tasks = load_task_outputs()
+
+        if not tasks:
+            click.echo(
+                "No task outputs found. Only crew kickoff task outputs are logged."
+            )
+            return
+
+        for index, task in enumerate(tasks, 1):
+            click.echo(f"Task {index}: {task['task_id']}")
+            click.echo(f"Description: {task['expected_output']}")
+            click.echo("------")
+
+    except Exception as e:
+        click.echo(f"An error occurred while logging task outputs: {e}", err=True)
+
+
+@crewai.command()
+@click.option("-m", "--memory", is_flag=True, help="Reset MEMORY")
+@click.option(
+    "-l",
+    "--long",
+    is_flag=True,
+    hidden=True,
+    help="[Deprecated: use --memory] Reset memory",
+)
+@click.option(
+    "-s",
+    "--short",
+    is_flag=True,
+    hidden=True,
+    help="[Deprecated: use --memory] Reset memory",
+)
+@click.option(
+    "-e",
+    "--entities",
+    is_flag=True,
+    hidden=True,
+    help="[Deprecated: use --memory] Reset memory",
+)
+@click.option("-kn", "--knowledge", is_flag=True, help="Reset KNOWLEDGE storage")
+@click.option(
+    "-akn", "--agent-knowledge", is_flag=True, help="Reset AGENT KNOWLEDGE storage"
+)
+@click.option(
+    "-k", "--kickoff-outputs", is_flag=True, help="Reset LATEST KICKOFF TASK OUTPUTS"
+)
+@click.option("-a", "--all", is_flag=True, help="Reset ALL memories")
+def reset_memories(
+    memory: bool,
+    long: bool,
+    short: bool,
+    entities: bool,
+    knowledge: bool,
+    kickoff_outputs: bool,
+    agent_knowledge: bool,
+    all: bool,
+) -> None:
+    """Reset the crew memories (memory, knowledge, agent_knowledge, kickoff_outputs). This will delete all the data saved."""
+    try:
+        if long or short or entities:
+            legacy_used = [
+                f
+                for f, v in [
+                    ("--long", long),
+                    ("--short", short),
+                    ("--entities", entities),
+                ]
+                if v
+            ]
+            click.echo(
+                f"Warning: {', '.join(legacy_used)} {'is' if len(legacy_used) == 1 else 'are'} "
+                "deprecated. Use --memory (-m) instead. All memory is now unified."
+            )
+            memory = True
+
+        memory_types = [
+            memory,
+            knowledge,
+            agent_knowledge,
+            kickoff_outputs,
+            all,
+        ]
+        if not any(memory_types):
+            click.echo(
+                "Please specify at least one memory type to reset using the appropriate flags."
+            )
+            return
+        reset_memories_command(memory, knowledge, agent_knowledge, kickoff_outputs, all)
+    except Exception as e:
+        click.echo(f"An error occurred while resetting memories: {e}", err=True)
+
+
+@crewai.command()
+@click.option(
+    "--storage-path",
+    type=str,
+    default=None,
+    help="Path to LanceDB memory directory. If omitted, uses ./.crewai/memory.",
+)
+@click.option(
+    "--embedder-provider",
+    type=str,
+    default=None,
+    help="Embedder provider for recall queries (e.g. openai, google-vertex, cohere, ollama).",
+)
+@click.option(
+    "--embedder-model",
+    type=str,
+    default=None,
+    help="Embedder model name (e.g. text-embedding-3-small, gemini-embedding-001).",
+)
+@click.option(
+    "--embedder-config",
+    type=str,
+    default=None,
+    help='Full embedder config as JSON (e.g. \'{"provider": "cohere", "config": {"model_name": "embed-v4.0"}}\').',
+)
+def memory(
+    storage_path: str | None,
+    embedder_provider: str | None,
+    embedder_model: str | None,
+    embedder_config: str | None,
+) -> None:
+    """Open the Memory TUI to browse scopes and recall memories."""
+    try:
+        from crewai_cli.memory_tui import MemoryTUI
+    except ImportError as exc:
+        click.echo(
+            "Textual is required for the memory TUI but could not be imported. "
+            "Try reinstalling crewai or: pip install textual"
+        )
+        raise SystemExit(1) from exc
+
+    # Build embedder spec from CLI flags.
+    embedder_spec: dict[str, Any] | None = None
+    if embedder_config:
+        import json as _json
+
+        try:
+            embedder_spec = _json.loads(embedder_config)
+        except _json.JSONDecodeError as exc:
+            click.echo(f"Invalid --embedder-config JSON: {exc}")
+            raise SystemExit(1) from exc
+    elif embedder_provider:
+        cfg: dict[str, str] = {}
+        if embedder_model:
+            cfg["model_name"] = embedder_model
+        embedder_spec = {"provider": embedder_provider, "config": cfg}
+
+    app = MemoryTUI(storage_path=storage_path, embedder_config=embedder_spec)
+    app.run()
+
+
+@crewai.command()
+@click.option(
+    "-n",
+    "--n_iterations",
+    type=int,
+    default=3,
+    help="Number of iterations to Test the crew",
+)
+@click.option(
+    "-m",
+    "--model",
+    type=str,
+    default="gpt-4o-mini",
+    help="LLM Model to run the tests on the Crew. For now only accepting only OpenAI models.",
+)
+def test(n_iterations: int, model: str):
+    """Test the crew and evaluate the results."""
+    click.echo(f"Testing the crew for {n_iterations} iterations with model {model}")
+    evaluate_crew(n_iterations, model)
+
+
+@crewai.command(
+    context_settings={
+        "ignore_unknown_options": True,
+        "allow_extra_args": True,
+    }
+)
+@click.pass_context
+def install(context):
+    """Install the Crew."""
+    install_crew(context.args)
+
+
+@crewai.command()
+def run():
+    """Run the Crew."""
+    run_crew()
+
+
+@crewai.command()
+def update():
+    """Update the pyproject.toml of the Crew project to use uv."""
+    update_crew()
+
+
+@crewai.command()
+def login():
+    """Sign Up/Login to CrewAI AMP."""
+    Settings().clear_user_settings()
+    AuthenticationCommand().login()
+
+
+# DEPLOY CREWAI+ COMMANDS
+@crewai.group()
+def deploy():
+    """Deploy the Crew CLI group."""
+
+
+@deploy.command(name="create")
+@click.option("-y", "--yes", is_flag=True, help="Skip the confirmation prompt")
+def deploy_create(yes: bool):
+    """Create a Crew deployment."""
+    deploy_cmd = DeployCommand()
+    deploy_cmd.create_crew(yes)
+
+
+@deploy.command(name="list")
+def deploy_list():
+    """List all deployments."""
+    deploy_cmd = DeployCommand()
+    deploy_cmd.list_crews()
+
+
+@deploy.command(name="push")
+@click.option("-u", "--uuid", type=str, help="Crew UUID parameter")
+def deploy_push(uuid: str | None):
+    """Deploy the Crew."""
+    deploy_cmd = DeployCommand()
+    deploy_cmd.deploy(uuid=uuid)
+
+
+@deploy.command(name="status")
+@click.option("-u", "--uuid", type=str, help="Crew UUID parameter")
+def deply_status(uuid: str | None):
+    """Get the status of a deployment."""
+    deploy_cmd = DeployCommand()
+    deploy_cmd.get_crew_status(uuid=uuid)
+
+
+@deploy.command(name="logs")
+@click.option("-u", "--uuid", type=str, help="Crew UUID parameter")
+def deploy_logs(uuid: str | None):
+    """Get the logs of a deployment."""
+    deploy_cmd = DeployCommand()
+    deploy_cmd.get_crew_logs(uuid=uuid)
+
+
+@deploy.command(name="remove")
+@click.option("-u", "--uuid", type=str, help="Crew UUID parameter")
+def deploy_remove(uuid: str | None):
+    """Remove a deployment."""
+    deploy_cmd = DeployCommand()
+    deploy_cmd.remove_crew(uuid=uuid)
+
+
+@crewai.group()
+def tool():
+    """Tool Repository related commands."""
+
+
+@tool.command(name="create")
+@click.argument("handle")
+def tool_create(handle: str):
+    tool_cmd = ToolCommand()
+    tool_cmd.create(handle)
+
+
+@tool.command(name="install")
+@click.argument("handle")
+def tool_install(handle: str):
+    tool_cmd = ToolCommand()
+    tool_cmd.login()
+    tool_cmd.install(handle)
+
+
+@tool.command(name="publish")
+@click.option(
+    "--force",
+    is_flag=True,
+    show_default=True,
+    default=False,
+    help="Bypasses Git remote validations",
+)
+@click.option("--public", "is_public", flag_value=True, default=False)
+@click.option("--private", "is_public", flag_value=False)
+def tool_publish(is_public: bool, force: bool):
+    tool_cmd = ToolCommand()
+    tool_cmd.login()
+    tool_cmd.publish(is_public, force)
+
+
+@crewai.group()
+def flow():
+    """Flow related commands."""
+
+
+@flow.command(name="kickoff")
+def flow_run():
+    """Kickoff the Flow."""
+    click.echo("Running the Flow")
+    kickoff_flow()
+
+
+@flow.command(name="plot")
+def flow_plot():
+    """Plot the Flow."""
+    click.echo("Plotting the Flow")
+    plot_flow()
+
+
+@flow.command(name="add-crew")
+@click.argument("crew_name")
+def flow_add_crew(crew_name):
+    """Add a crew to an existing flow."""
+    click.echo(f"Adding crew {crew_name} to the flow")
+    add_crew_to_flow(crew_name)
+
+
+@crewai.group()
+def triggers():
+    """Trigger related commands. Use 'crewai triggers list' to see available triggers, or 'crewai triggers run app_slug/trigger_slug' to execute."""
+
+
+@triggers.command(name="list")
+def triggers_list():
+    """List all available triggers from integrations."""
+    triggers_cmd = TriggersCommand()
+    triggers_cmd.list_triggers()
+
+
+@triggers.command(name="run")
+@click.argument("trigger_path")
+def triggers_run(trigger_path: str):
+    """Execute crew with trigger payload. Format: app_slug/trigger_slug"""
+    triggers_cmd = TriggersCommand()
+    triggers_cmd.execute_with_trigger(trigger_path)
+
+
+@crewai.command()
+def chat():
+    """Start a conversation with the Crew, collecting user-supplied inputs,
+    and using the Chat LLM to generate responses.
+    """
+    click.secho(
+        "\nStarting a conversation with the Crew\nType 'exit' or Ctrl+C to quit.\n",
+    )
+    run_chat()
+
+
+@crewai.group(invoke_without_command=True)
+def org():
+    """Organization management commands."""
+
+
+@org.command("list")
+def org_list():
+    """List available organizations."""
+    org_command = OrganizationCommand()
+    org_command.list()
+
+
+@org.command()
+@click.argument("id")
+def switch(id):
+    """Switch to a specific organization."""
+    org_command = OrganizationCommand()
+    org_command.switch(id)
+
+
+@org.command()
+def current():
+    """Show current organization when 'crewai org' is called without subcommands."""
+    org_command = OrganizationCommand()
+    org_command.current()
+
+
+@crewai.group()
+def enterprise():
+    """Enterprise Configuration commands."""
+
+
+@enterprise.command("configure")
+@click.argument("enterprise_url")
+def enterprise_configure(enterprise_url: str):
+    """Configure CrewAI AMP OAuth2 settings from the provided Enterprise URL."""
+    enterprise_command = EnterpriseConfigureCommand()
+    enterprise_command.configure(enterprise_url)
+
+
+@crewai.group()
+def config():
+    """CLI Configuration commands."""
+
+
+@config.command("list")
+def config_list():
+    """List all CLI configuration parameters."""
+    config_command = SettingsCommand()
+    config_command.list()
+
+
+@config.command("set")
+@click.argument("key")
+@click.argument("value")
+def config_set(key: str, value: str):
+    """Set a CLI configuration parameter."""
+    config_command = SettingsCommand()
+    config_command.set(key, value)
+
+
+@config.command("reset")
+def config_reset():
+    """Reset all CLI configuration parameters to default values."""
+    config_command = SettingsCommand()
+    config_command.reset_all_settings()
+
+
+@crewai.group()
+def env():
+    """Environment variable commands."""
+
+
+@env.command("view")
+def env_view():
+    """View tracing-related environment variables."""
+    import os
+    from pathlib import Path
+
+    from rich.console import Console
+    from rich.panel import Panel
+    from rich.table import Table
+
+    console = Console()
+
+    # Check for .env file
+    env_file = Path(".env")
+    env_file_exists = env_file.exists()
+
+    # Create table for environment variables
+    table = Table(show_header=True, header_style="bold cyan", expand=True)
+    table.add_column("Environment Variable", style="cyan", width=30)
+    table.add_column("Value", style="white", width=20)
+    table.add_column("Source", style="yellow", width=20)
+
+    # Check CREWAI_TRACING_ENABLED
+    crewai_tracing = os.getenv("CREWAI_TRACING_ENABLED", "")
+    if crewai_tracing:
+        table.add_row(
+            "CREWAI_TRACING_ENABLED",
+            crewai_tracing,
+            "Environment/Shell",
+        )
+    else:
+        table.add_row(
+            "CREWAI_TRACING_ENABLED",
+            "[dim]Not set[/dim]",
+            "[dim]---[/dim]",
+        )
+
+    # Check other related env vars
+    crewai_testing = os.getenv("CREWAI_TESTING", "")
+    if crewai_testing:
+        table.add_row("CREWAI_TESTING", crewai_testing, "Environment/Shell")
+
+    crewai_user_id = os.getenv("CREWAI_USER_ID", "")
+    if crewai_user_id:
+        table.add_row("CREWAI_USER_ID", crewai_user_id, "Environment/Shell")
+
+    crewai_org_id = os.getenv("CREWAI_ORG_ID", "")
+    if crewai_org_id:
+        table.add_row("CREWAI_ORG_ID", crewai_org_id, "Environment/Shell")
+
+    # Check if .env file exists
+    table.add_row(
+        ".env file",
+        "Found" if env_file_exists else "Not found",
+        str(env_file.resolve()) if env_file_exists else "N/A",
+    )
+
+    panel = Panel(
+        table,
+        title="Tracing Environment Variables",
+        border_style="blue",
+        padding=(1, 2),
+    )
+    console.print("\n")
+    console.print(panel)
+
+    # Show helpful message
+    if env_file_exists:
+        console.print(
+            "\n[dim]Tip: To enable tracing via .env, add: CREWAI_TRACING_ENABLED=true[/dim]"
+        )
+    else:
+        console.print(
+            "\n[dim]Tip: Create a .env file in your project root and add: CREWAI_TRACING_ENABLED=true[/dim]"
+        )
+    console.print()
+
+
+@crewai.group()
+def traces():
+    """Trace collection management commands."""
+
+
+@traces.command("enable")
+def traces_enable():
+    """Enable trace collection for crew/flow executions."""
+    from rich.console import Console
+    from rich.panel import Panel
+
+    console = Console()
+
+    # Update user data to enable traces
+    user_data = _load_user_data()
+    user_data["trace_consent"] = True
+    user_data["first_execution_done"] = True
+    _save_user_data(user_data)
+
+    panel = Panel(
+        "Trace collection has been enabled!\n\n"
+        "Your crew/flow executions will now send traces to CrewAI+.\n"
+        "Use 'crewai traces disable' to turn off trace collection.",
+        title="Traces Enabled",
+        border_style="green",
+        padding=(1, 2),
+    )
+    console.print(panel)
+
+
+@traces.command("disable")
+def traces_disable():
+    """Disable trace collection for crew/flow executions."""
+    from rich.console import Console
+    from rich.panel import Panel
+
+    console = Console()
+
+    # Update user data to disable traces
+    user_data = _load_user_data()
+    user_data["trace_consent"] = False
+    user_data["first_execution_done"] = True
+    _save_user_data(user_data)
+
+    panel = Panel(
+        "Trace collection has been disabled!\n\n"
+        "Your crew/flow executions will no longer send traces.\n"
+        "Use 'crewai traces enable' to turn trace collection back on.",
+        title="Traces Disabled",
+        border_style="red",
+        padding=(1, 2),
+    )
+    console.print(panel)
+
+
+@traces.command("status")
+def traces_status():
+    """Show current trace collection status."""
+    import os
+
+    from rich.console import Console
+    from rich.panel import Panel
+    from rich.table import Table
+
+    console = Console()
+    user_data = _load_user_data()
+
+    table = Table(show_header=False, box=None)
+    table.add_column("Setting", style="cyan")
+    table.add_column("Value", style="white")
+
+    # Check environment variable
+    env_enabled = os.getenv("CREWAI_TRACING_ENABLED", "false")
+    table.add_row("CREWAI_TRACING_ENABLED", env_enabled)
+
+    # Check user consent
+    trace_consent = user_data.get("trace_consent")
+    if trace_consent is True:
+        consent_status = "Enabled (user consented)"
+    elif trace_consent is False:
+        consent_status = "Disabled (user declined)"
+    else:
+        consent_status = "Not set (first-time user)"
+    table.add_row("User Consent", consent_status)
+
+    # Check overall status
+    if is_tracing_enabled():
+        overall_status = "ENABLED"
+        border_style = "green"
+    else:
+        overall_status = "DISABLED"
+        border_style = "red"
+    table.add_row("Overall Status", overall_status)
+
+    panel = Panel(
+        table,
+        title="Trace Collection Status",
+        border_style=border_style,
+        padding=(1, 2),
+    )
+    console.print(panel)
+
+
+if __name__ == "__main__":
+    crewai()

lib/cli/src/crewai_cli/command.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+import json
+
+import httpx
+from rich.console import Console
+
+from crewai_cli.authentication.token import get_auth_token
+from crewai_cli.plus_api import PlusAPI
+
+
+console = Console()
+
+
+class BaseCommand:
+    def __init__(self) -> None:
+        pass
+
+
+class PlusAPIMixin:
+    def __init__(self) -> None:
+        try:
+            self.plus_api_client = PlusAPI(api_key=get_auth_token())
+        except Exception:
+            console.print(
+                "Please sign up/login to CrewAI+ before using the CLI.",
+                style="bold red",
+            )
+            console.print("Run 'crewai login' to sign up/login.", style="bold green")
+            raise SystemExit from None
+
+    def _validate_response(self, response: httpx.Response) -> None:
+        try:
+            json_response = response.json()
+        except (json.JSONDecodeError, ValueError):
+            console.print(
+                "Failed to parse response from Enterprise API failed. Details:",
+                style="bold red",
+            )
+            console.print(f"Status Code: {response.status_code}")
+            console.print(
+                f"Response:\n{response.content.decode('utf-8', errors='replace')}"
+            )
+            raise SystemExit from None
+
+        if response.status_code == 422:
+            console.print(
+                "Failed to complete operation. Please fix the following errors:",
+                style="bold red",
+            )
+            for field, messages in json_response.items():
+                for message in messages:
+                    console.print(
+                        f"* [bold red]{field.capitalize()}[/bold red] {message}"
+                    )
+            raise SystemExit
+
+        if not response.is_success:
+            console.print(
+                "Request to Enterprise API failed. Details:", style="bold red"
+            )
+            details = (
+                json_response.get("error")
+                or json_response.get("message")
+                or response.content.decode("utf-8", errors="replace")
+            )
+            console.print(f"{details}")
+            raise SystemExit

lib/cli/src/crewai_cli/config.py

@@ -0,0 +1,221 @@
+import json
+from logging import getLogger
+from pathlib import Path
+import tempfile
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+from crewai_cli.constants import (
+    CREWAI_ENTERPRISE_DEFAULT_OAUTH2_AUDIENCE,
+    CREWAI_ENTERPRISE_DEFAULT_OAUTH2_CLIENT_ID,
+    CREWAI_ENTERPRISE_DEFAULT_OAUTH2_DOMAIN,
+    CREWAI_ENTERPRISE_DEFAULT_OAUTH2_PROVIDER,
+    DEFAULT_CREWAI_ENTERPRISE_URL,
+)
+from crewai_cli.shared.token_manager import TokenManager
+
+
+logger = getLogger(__name__)
+
+DEFAULT_CONFIG_PATH = Path.home() / ".config" / "crewai" / "settings.json"
+
+
+def get_writable_config_path() -> Path | None:
+    """
+    Find a writable location for the config file with fallback options.
+
+    Tries in order:
+    1. Default: ~/.config/crewai/settings.json
+    2. Temp directory: /tmp/crewai_settings.json (or OS equivalent)
+    3. Current directory: ./crewai_settings.json
+    4. In-memory only (returns None)
+
+    Returns:
+        Path object for writable config location, or None if no writable location found
+    """
+    fallback_paths = [
+        DEFAULT_CONFIG_PATH,  # Default location
+        Path(tempfile.gettempdir()) / "crewai_settings.json",  # Temporary directory
+        Path.cwd() / "crewai_settings.json",  # Current working directory
+    ]
+
+    for config_path in fallback_paths:
+        try:
+            config_path.parent.mkdir(parents=True, exist_ok=True)
+            test_file = config_path.parent / ".crewai_write_test"
+            try:
+                test_file.write_text("test")
+                test_file.unlink()  # Clean up test file
+                logger.info(f"Using config path: {config_path}")
+                return config_path
+            except Exception:  # noqa: S112
+                continue
+
+        except Exception:  # noqa: S112
+            continue
+
+    return None
+
+
+# Settings that are related to the user's account
+USER_SETTINGS_KEYS = [
+    "tool_repository_username",
+    "tool_repository_password",
+    "org_name",
+    "org_uuid",
+]
+
+# Settings that are related to the CLI
+CLI_SETTINGS_KEYS = [
+    "enterprise_base_url",
+    "oauth2_provider",
+    "oauth2_audience",
+    "oauth2_client_id",
+    "oauth2_domain",
+    "oauth2_extra",
+]
+
+# Default values for CLI settings
+DEFAULT_CLI_SETTINGS = {
+    "enterprise_base_url": DEFAULT_CREWAI_ENTERPRISE_URL,
+    "oauth2_provider": CREWAI_ENTERPRISE_DEFAULT_OAUTH2_PROVIDER,
+    "oauth2_audience": CREWAI_ENTERPRISE_DEFAULT_OAUTH2_AUDIENCE,
+    "oauth2_client_id": CREWAI_ENTERPRISE_DEFAULT_OAUTH2_CLIENT_ID,
+    "oauth2_domain": CREWAI_ENTERPRISE_DEFAULT_OAUTH2_DOMAIN,
+    "oauth2_extra": {},
+}
+
+# Readonly settings - cannot be set by the user
+READONLY_SETTINGS_KEYS = [
+    "org_name",
+    "org_uuid",
+]
+
+# Hidden settings - not displayed by the 'list' command and cannot be set by the user
+HIDDEN_SETTINGS_KEYS = [
+    "config_path",
+    "tool_repository_username",
+    "tool_repository_password",
+]
+
+
+class Settings(BaseModel):
+    enterprise_base_url: str | None = Field(
+        default=DEFAULT_CLI_SETTINGS["enterprise_base_url"],
+        description="Base URL of the CrewAI AMP instance",
+    )
+    tool_repository_username: str | None = Field(
+        None, description="Username for interacting with the Tool Repository"
+    )
+    tool_repository_password: str | None = Field(
+        None, description="Password for interacting with the Tool Repository"
+    )
+    org_name: str | None = Field(
+        None, description="Name of the currently active organization"
+    )
+    org_uuid: str | None = Field(
+        None, description="UUID of the currently active organization"
+    )
+    config_path: Path = Field(default=DEFAULT_CONFIG_PATH, frozen=True, exclude=True)
+
+    oauth2_provider: str = Field(
+        description="OAuth2 provider used for authentication (e.g., workos, okta, auth0).",
+        default=DEFAULT_CLI_SETTINGS["oauth2_provider"],
+    )
+
+    oauth2_audience: str | None = Field(
+        description="OAuth2 audience value, typically used to identify the target API or resource.",
+        default=DEFAULT_CLI_SETTINGS["oauth2_audience"],
+    )
+
+    oauth2_client_id: str = Field(
+        default=DEFAULT_CLI_SETTINGS["oauth2_client_id"],
+        description="OAuth2 client ID issued by the provider, used during authentication requests.",
+    )
+
+    oauth2_domain: str = Field(
+        description="OAuth2 provider's domain (e.g., your-org.auth0.com) used for issuing tokens.",
+        default=DEFAULT_CLI_SETTINGS["oauth2_domain"],
+    )
+
+    oauth2_extra: dict[str, Any] = Field(
+        description="Extra configuration for the OAuth2 provider.",
+        default={},
+    )
+
+    def __init__(self, config_path: Path | None = None, **data: dict[str, Any]) -> None:
+        """Load Settings from config path with fallback support"""
+        if config_path is None:
+            config_path = get_writable_config_path()
+
+        # If config_path is None, we're in memory-only mode
+        if config_path is None:
+            merged_data = {**data}
+            # Dummy path for memory-only mode
+            super().__init__(config_path=Path("/dev/null"), **merged_data)
+            return
+
+        try:
+            config_path.parent.mkdir(parents=True, exist_ok=True)
+        except Exception:
+            merged_data = {**data}
+            # Dummy path for memory-only mode
+            super().__init__(config_path=Path("/dev/null"), **merged_data)
+            return
+
+        file_data = {}
+        if config_path.is_file():
+            try:
+                with config_path.open("r") as f:
+                    file_data = json.load(f)
+            except Exception:
+                file_data = {}
+
+        merged_data = {**file_data, **data}
+        super().__init__(config_path=config_path, **merged_data)
+
+    def clear_user_settings(self) -> None:
+        """Clear all user settings"""
+        self._reset_user_settings()
+        self.dump()
+
+    def reset(self) -> None:
+        """Reset all settings to default values"""
+        self._reset_user_settings()
+        self._reset_cli_settings()
+        self._clear_auth_tokens()
+        self.dump()
+
+    def dump(self) -> None:
+        """Save current settings to settings.json"""
+        if str(self.config_path) == "/dev/null":
+            return
+
+        try:
+            if self.config_path.is_file():
+                with self.config_path.open("r") as f:
+                    existing_data = json.load(f)
+            else:
+                existing_data = {}
+
+            updated_data = {**existing_data, **self.model_dump(exclude_unset=True)}
+            with self.config_path.open("w") as f:
+                json.dump(updated_data, f, indent=4)
+
+        except Exception:  # noqa: S110
+            pass
+
+    def _reset_user_settings(self) -> None:
+        """Reset all user settings to default values"""
+        for key in USER_SETTINGS_KEYS:
+            setattr(self, key, None)
+
+    def _reset_cli_settings(self) -> None:
+        """Reset all CLI settings to default values"""
+        for key in CLI_SETTINGS_KEYS:
+            setattr(self, key, DEFAULT_CLI_SETTINGS.get(key))
+
+    def _clear_auth_tokens(self) -> None:
+        """Clear all authentication tokens"""
+        TokenManager().clear_tokens()

lib/cli/src/crewai_cli/constants.py

@@ -0,0 +1,333 @@
+from typing import Any
+
+
+DEFAULT_CREWAI_ENTERPRISE_URL = "https://app.crewai.com"
+CREWAI_ENTERPRISE_DEFAULT_OAUTH2_PROVIDER = "workos"
+CREWAI_ENTERPRISE_DEFAULT_OAUTH2_AUDIENCE = "client_01JNJQWBJ4SPFN3SWJM5T7BDG8"
+CREWAI_ENTERPRISE_DEFAULT_OAUTH2_CLIENT_ID = "client_01JYT06R59SP0NXYGD994NFXXX"
+CREWAI_ENTERPRISE_DEFAULT_OAUTH2_DOMAIN = "login.crewai.com"
+
+ENV_VARS: dict[str, list[dict[str, Any]]] = {
+    "openai": [
+        {
+            "prompt": "Enter your OPENAI API key (press Enter to skip)",
+            "key_name": "OPENAI_API_KEY",
+        }
+    ],
+    "anthropic": [
+        {
+            "prompt": "Enter your ANTHROPIC API key (press Enter to skip)",
+            "key_name": "ANTHROPIC_API_KEY",
+        }
+    ],
+    "gemini": [
+        {
+            "prompt": "Enter your GEMINI API key from https://ai.dev/apikey (press Enter to skip)",
+            "key_name": "GEMINI_API_KEY",
+        }
+    ],
+    "nvidia_nim": [
+        {
+            "prompt": "Enter your NVIDIA API key (press Enter to skip)",
+            "key_name": "NVIDIA_NIM_API_KEY",
+        }
+    ],
+    "groq": [
+        {
+            "prompt": "Enter your GROQ API key (press Enter to skip)",
+            "key_name": "GROQ_API_KEY",
+        }
+    ],
+    "watson": [
+        {
+            "prompt": "Enter your WATSONX URL (press Enter to skip)",
+            "key_name": "WATSONX_URL",
+        },
+        {
+            "prompt": "Enter your WATSONX API Key (press Enter to skip)",
+            "key_name": "WATSONX_APIKEY",
+        },
+        {
+            "prompt": "Enter your WATSONX Project Id (press Enter to skip)",
+            "key_name": "WATSONX_PROJECT_ID",
+        },
+    ],
+    "ollama": [
+        {
+            "default": True,
+            "API_BASE": "http://localhost:11434",
+        }
+    ],
+    "bedrock": [
+        {
+            "prompt": "Enter your AWS Access Key ID (press Enter to skip)",
+            "key_name": "AWS_ACCESS_KEY_ID",
+        },
+        {
+            "prompt": "Enter your AWS Secret Access Key (press Enter to skip)",
+            "key_name": "AWS_SECRET_ACCESS_KEY",
+        },
+        {
+            "prompt": "Enter your AWS Region Name (press Enter to skip)",
+            "key_name": "AWS_DEFAULT_REGION",
+        },
+    ],
+    "azure": [
+        {
+            "prompt": "Enter your Azure deployment name (must start with 'azure/')",
+            "key_name": "model",
+        },
+        {
+            "prompt": "Enter your AZURE API key (press Enter to skip)",
+            "key_name": "AZURE_API_KEY",
+        },
+        {
+            "prompt": "Enter your AZURE API base URL (press Enter to skip)",
+            "key_name": "AZURE_API_BASE",
+        },
+        {
+            "prompt": "Enter your AZURE API version (press Enter to skip)",
+            "key_name": "AZURE_API_VERSION",
+        },
+    ],
+    "cerebras": [
+        {
+            "prompt": "Enter your Cerebras model name (must start with 'cerebras/')",
+            "key_name": "model",
+        },
+        {
+            "prompt": "Enter your Cerebras API version (press Enter to skip)",
+            "key_name": "CEREBRAS_API_KEY",
+        },
+    ],
+    "huggingface": [
+        {
+            "prompt": "Enter your Huggingface API key (HF_TOKEN) (press Enter to skip)",
+            "key_name": "HF_TOKEN",
+        },
+    ],
+    "sambanova": [
+        {
+            "prompt": "Enter your SambaNovaCloud API key (press Enter to skip)",
+            "key_name": "SAMBANOVA_API_KEY",
+        }
+    ],
+}
+
+
+PROVIDERS: list[str] = [
+    "openai",
+    "anthropic",
+    "gemini",
+    "nvidia_nim",
+    "groq",
+    "huggingface",
+    "ollama",
+    "watson",
+    "bedrock",
+    "azure",
+    "cerebras",
+    "sambanova",
+]
+
+MODELS: dict[str, list[str]] = {
+    "openai": [
+        "gpt-4",
+        "gpt-4.1",
+        "gpt-4.1-mini-2025-04-14",
+        "gpt-4.1-nano-2025-04-14",
+        "gpt-4o",
+        "gpt-4o-mini",
+        "o1-mini",
+        "o1-preview",
+    ],
+    "anthropic": [
+        "claude-3-5-sonnet-20240620",
+        "claude-3-sonnet-20240229",
+        "claude-3-opus-20240229",
+        "claude-3-haiku-20240307",
+    ],
+    "gemini": [
+        "gemini/gemini-3-pro-preview",
+        "gemini/gemini-1.5-flash",
+        "gemini/gemini-1.5-pro",
+        "gemini/gemini-2.0-flash-lite-001",
+        "gemini/gemini-2.0-flash-001",
+        "gemini/gemini-2.0-flash-thinking-exp-01-21",
+        "gemini/gemini-2.5-flash-preview-04-17",
+        "gemini/gemini-2.5-pro-exp-03-25",
+        "gemini/gemini-gemma-2-9b-it",
+        "gemini/gemini-gemma-2-27b-it",
+        "gemini/gemma-3-1b-it",
+        "gemini/gemma-3-4b-it",
+        "gemini/gemma-3-12b-it",
+        "gemini/gemma-3-27b-it",
+    ],
+    "nvidia_nim": [
+        "nvidia_nim/nvidia/mistral-nemo-minitron-8b-8k-instruct",
+        "nvidia_nim/nvidia/nemotron-4-mini-hindi-4b-instruct",
+        "nvidia_nim/nvidia/llama-3.1-nemotron-70b-instruct",
+        "nvidia_nim/nvidia/llama3-chatqa-1.5-8b",
+        "nvidia_nim/nvidia/llama3-chatqa-1.5-70b",
+        "nvidia_nim/nvidia/vila",
+        "nvidia_nim/nvidia/neva-22",
+        "nvidia_nim/nvidia/nemotron-mini-4b-instruct",
+        "nvidia_nim/nvidia/usdcode-llama3-70b-instruct",
+        "nvidia_nim/nvidia/nemotron-4-340b-instruct",
+        "nvidia_nim/meta/codellama-70b",
+        "nvidia_nim/meta/llama2-70b",
+        "nvidia_nim/meta/llama3-8b-instruct",
+        "nvidia_nim/meta/llama3-70b-instruct",
+        "nvidia_nim/meta/llama-3.1-8b-instruct",
+        "nvidia_nim/meta/llama-3.1-70b-instruct",
+        "nvidia_nim/meta/llama-3.1-405b-instruct",
+        "nvidia_nim/meta/llama-3.2-1b-instruct",
+        "nvidia_nim/meta/llama-3.2-3b-instruct",
+        "nvidia_nim/meta/llama-3.2-11b-vision-instruct",
+        "nvidia_nim/meta/llama-3.2-90b-vision-instruct",
+        "nvidia_nim/meta/llama-3.1-70b-instruct",
+        "nvidia_nim/google/gemma-7b",
+        "nvidia_nim/google/gemma-2b",
+        "nvidia_nim/google/codegemma-7b",
+        "nvidia_nim/google/codegemma-1.1-7b",
+        "nvidia_nim/google/recurrentgemma-2b",
+        "nvidia_nim/google/gemma-2-9b-it",
+        "nvidia_nim/google/gemma-2-27b-it",
+        "nvidia_nim/google/gemma-2-2b-it",
+        "nvidia_nim/google/deplot",
+        "nvidia_nim/google/paligemma",
+        "nvidia_nim/mistralai/mistral-7b-instruct-v0.2",
+        "nvidia_nim/mistralai/mixtral-8x7b-instruct-v0.1",
+        "nvidia_nim/mistralai/mistral-large",
+        "nvidia_nim/mistralai/mixtral-8x22b-instruct-v0.1",
+        "nvidia_nim/mistralai/mistral-7b-instruct-v0.3",
+        "nvidia_nim/nv-mistralai/mistral-nemo-12b-instruct",
+        "nvidia_nim/mistralai/mamba-codestral-7b-v0.1",
+        "nvidia_nim/microsoft/phi-3-mini-128k-instruct",
+        "nvidia_nim/microsoft/phi-3-mini-4k-instruct",
+        "nvidia_nim/microsoft/phi-3-small-8k-instruct",
+        "nvidia_nim/microsoft/phi-3-small-128k-instruct",
+        "nvidia_nim/microsoft/phi-3-medium-4k-instruct",
+        "nvidia_nim/microsoft/phi-3-medium-128k-instruct",
+        "nvidia_nim/microsoft/phi-3.5-mini-instruct",
+        "nvidia_nim/microsoft/phi-3.5-moe-instruct",
+        "nvidia_nim/microsoft/kosmos-2",
+        "nvidia_nim/microsoft/phi-3-vision-128k-instruct",
+        "nvidia_nim/microsoft/phi-3.5-vision-instruct",
+        "nvidia_nim/databricks/dbrx-instruct",
+        "nvidia_nim/snowflake/arctic",
+        "nvidia_nim/aisingapore/sea-lion-7b-instruct",
+        "nvidia_nim/ibm/granite-8b-code-instruct",
+        "nvidia_nim/ibm/granite-34b-code-instruct",
+        "nvidia_nim/ibm/granite-3.0-8b-instruct",
+        "nvidia_nim/ibm/granite-3.0-3b-a800m-instruct",
+        "nvidia_nim/mediatek/breeze-7b-instruct",
+        "nvidia_nim/upstage/solar-10.7b-instruct",
+        "nvidia_nim/writer/palmyra-med-70b-32k",
+        "nvidia_nim/writer/palmyra-med-70b",
+        "nvidia_nim/writer/palmyra-fin-70b-32k",
+        "nvidia_nim/01-ai/yi-large",
+        "nvidia_nim/deepseek-ai/deepseek-coder-6.7b-instruct",
+        "nvidia_nim/rakuten/rakutenai-7b-instruct",
+        "nvidia_nim/rakuten/rakutenai-7b-chat",
+        "nvidia_nim/baichuan-inc/baichuan2-13b-chat",
+    ],
+    "groq": [
+        "groq/llama-3.1-8b-instant",
+        "groq/llama-3.1-70b-versatile",
+        "groq/llama-3.1-405b-reasoning",
+        "groq/gemma2-9b-it",
+        "groq/gemma-7b-it",
+    ],
+    "ollama": ["ollama/llama3.1", "ollama/mixtral"],
+    "watson": [
+        "watsonx/meta-llama/llama-3-1-70b-instruct",
+        "watsonx/meta-llama/llama-3-1-8b-instruct",
+        "watsonx/meta-llama/llama-3-2-11b-vision-instruct",
+        "watsonx/meta-llama/llama-3-2-1b-instruct",
+        "watsonx/meta-llama/llama-3-2-90b-vision-instruct",
+        "watsonx/meta-llama/llama-3-405b-instruct",
+        "watsonx/mistral/mistral-large",
+        "watsonx/ibm/granite-3-8b-instruct",
+    ],
+    "bedrock": [
+        "bedrock/us.amazon.nova-pro-v1:0",
+        "bedrock/us.amazon.nova-micro-v1:0",
+        "bedrock/us.amazon.nova-lite-v1:0",
+        "bedrock/us.anthropic.claude-3-5-sonnet-20240620-v1:0",
+        "bedrock/us.anthropic.claude-3-5-haiku-20241022-v1:0",
+        "bedrock/us.anthropic.claude-3-5-sonnet-20241022-v2:0",
+        "bedrock/us.anthropic.claude-3-7-sonnet-20250219-v1:0",
+        "bedrock/us.anthropic.claude-3-sonnet-20240229-v1:0",
+        "bedrock/us.anthropic.claude-3-opus-20240229-v1:0",
+        "bedrock/us.anthropic.claude-3-haiku-20240307-v1:0",
+        "bedrock/us.meta.llama3-2-11b-instruct-v1:0",
+        "bedrock/us.meta.llama3-2-3b-instruct-v1:0",
+        "bedrock/us.meta.llama3-2-90b-instruct-v1:0",
+        "bedrock/us.meta.llama3-2-1b-instruct-v1:0",
+        "bedrock/us.meta.llama3-1-8b-instruct-v1:0",
+        "bedrock/us.meta.llama3-1-70b-instruct-v1:0",
+        "bedrock/us.meta.llama3-3-70b-instruct-v1:0",
+        "bedrock/us.meta.llama3-1-405b-instruct-v1:0",
+        "bedrock/eu.anthropic.claude-3-5-sonnet-20240620-v1:0",
+        "bedrock/eu.anthropic.claude-3-sonnet-20240229-v1:0",
+        "bedrock/eu.anthropic.claude-3-haiku-20240307-v1:0",
+        "bedrock/eu.meta.llama3-2-3b-instruct-v1:0",
+        "bedrock/eu.meta.llama3-2-1b-instruct-v1:0",
+        "bedrock/apac.anthropic.claude-3-5-sonnet-20240620-v1:0",
+        "bedrock/apac.anthropic.claude-3-5-sonnet-20241022-v2:0",
+        "bedrock/apac.anthropic.claude-3-sonnet-20240229-v1:0",
+        "bedrock/apac.anthropic.claude-3-haiku-20240307-v1:0",
+        "bedrock/amazon.nova-pro-v1:0",
+        "bedrock/amazon.nova-micro-v1:0",
+        "bedrock/amazon.nova-lite-v1:0",
+        "bedrock/anthropic.claude-3-5-sonnet-20240620-v1:0",
+        "bedrock/anthropic.claude-3-5-haiku-20241022-v1:0",
+        "bedrock/anthropic.claude-3-5-sonnet-20241022-v2:0",
+        "bedrock/anthropic.claude-3-7-sonnet-20250219-v1:0",
+        "bedrock/anthropic.claude-3-sonnet-20240229-v1:0",
+        "bedrock/anthropic.claude-3-opus-20240229-v1:0",
+        "bedrock/anthropic.claude-3-haiku-20240307-v1:0",
+        "bedrock/anthropic.claude-v2:1",
+        "bedrock/anthropic.claude-v2",
+        "bedrock/anthropic.claude-instant-v1",
+        "bedrock/meta.llama3-1-405b-instruct-v1:0",
+        "bedrock/meta.llama3-1-70b-instruct-v1:0",
+        "bedrock/meta.llama3-1-8b-instruct-v1:0",
+        "bedrock/meta.llama3-70b-instruct-v1:0",
+        "bedrock/meta.llama3-8b-instruct-v1:0",
+        "bedrock/amazon.titan-text-lite-v1",
+        "bedrock/amazon.titan-text-express-v1",
+        "bedrock/cohere.command-text-v14",
+        "bedrock/ai21.j2-mid-v1",
+        "bedrock/ai21.j2-ultra-v1",
+        "bedrock/ai21.jamba-instruct-v1:0",
+        "bedrock/mistral.mistral-7b-instruct-v0:2",
+        "bedrock/mistral.mixtral-8x7b-instruct-v0:1",
+    ],
+    "huggingface": [
+        "huggingface/meta-llama/Meta-Llama-3.1-8B-Instruct",
+        "huggingface/mistralai/Mixtral-8x7B-Instruct-v0.1",
+        "huggingface/tiiuae/falcon-180B-chat",
+        "huggingface/google/gemma-7b-it",
+    ],
+    "sambanova": [
+        "sambanova/Meta-Llama-3.3-70B-Instruct",
+        "sambanova/QwQ-32B-Preview",
+        "sambanova/Qwen2.5-72B-Instruct",
+        "sambanova/Qwen2.5-Coder-32B-Instruct",
+        "sambanova/Meta-Llama-3.1-405B-Instruct",
+        "sambanova/Meta-Llama-3.1-70B-Instruct",
+        "sambanova/Meta-Llama-3.1-8B-Instruct",
+        "sambanova/Llama-3.2-90B-Vision-Instruct",
+        "sambanova/Llama-3.2-11B-Vision-Instruct",
+        "sambanova/Meta-Llama-3.2-3B-Instruct",
+        "sambanova/Meta-Llama-3.2-1B-Instruct",
+    ],
+}
+
+DEFAULT_LLM_MODEL = "gpt-4.1-mini"
+
+JSON_URL = "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json"
+
+LITELLM_PARAMS = ["api_key", "api_base", "api_version"]

lib/cli/src/crewai_cli/create_crew.py

@@ -0,0 +1,321 @@
+from pathlib import Path
+import shutil
+import sys
+
+import click
+import tomli
+
+from crewai_cli.constants import ENV_VARS, MODELS
+from crewai_cli.provider import (
+    get_provider_data,
+    select_model,
+    select_provider,
+)
+from crewai_cli.utils import copy_template, load_env_vars, write_env_file
+
+
+def get_reserved_script_names() -> set[str]:
+    """Get reserved script names from pyproject.toml template.
+
+    Returns:
+        Set of reserved script names that would conflict with crew folder names.
+    """
+    package_dir = Path(__file__).parent
+    template_path = package_dir / "templates" / "crew" / "pyproject.toml"
+
+    with open(template_path, "r") as f:
+        template_content = f.read()
+
+    template_content = template_content.replace("{{folder_name}}", "_placeholder_")
+    template_content = template_content.replace("{{name}}", "placeholder")
+    template_content = template_content.replace("{{crew_name}}", "Placeholder")
+
+    template_data = tomli.loads(template_content)
+    script_names = set(template_data.get("project", {}).get("scripts", {}).keys())
+    script_names.discard("_placeholder_")
+    return script_names
+
+
+def create_folder_structure(
+    name: str, parent_folder: str | None = None
+) -> tuple[Path, str, str]:
+    import keyword
+    import re
+
+    name = name.rstrip("/")
+
+    if not name.strip():
+        raise ValueError("Project name cannot be empty or contain only whitespace")
+
+    folder_name = name.replace(" ", "_").replace("-", "_").lower()
+    folder_name = re.sub(r"[^a-zA-Z0-9_]", "", folder_name)
+
+    # Check if the name starts with invalid characters or is primarily invalid
+    if re.match(r"^[^a-zA-Z0-9_-]+", name):
+        raise ValueError(
+            f"Project name '{name}' contains no valid characters for a Python module name"
+        )
+
+    if not folder_name:
+        raise ValueError(
+            f"Project name '{name}' contains no valid characters for a Python module name"
+        )
+
+    if folder_name[0].isdigit():
+        raise ValueError(
+            f"Project name '{name}' would generate folder name '{folder_name}' which cannot start with a digit (invalid Python module name)"
+        )
+
+    if keyword.iskeyword(folder_name):
+        raise ValueError(
+            f"Project name '{name}' would generate folder name '{folder_name}' which is a reserved Python keyword"
+        )
+
+    if not folder_name.isidentifier():
+        raise ValueError(
+            f"Project name '{name}' would generate invalid Python module name '{folder_name}'"
+        )
+
+    reserved_names = get_reserved_script_names()
+    if folder_name in reserved_names:
+        raise ValueError(
+            f"Project name '{name}' would generate folder name '{folder_name}' which is reserved. "
+            f"Reserved names are: {', '.join(sorted(reserved_names))}. "
+            "Please choose a different name."
+        )
+
+    class_name = name.replace("_", " ").replace("-", " ").title().replace(" ", "")
+
+    class_name = re.sub(r"[^a-zA-Z0-9_]", "", class_name)
+
+    if not class_name:
+        raise ValueError(
+            f"Project name '{name}' contains no valid characters for a Python class name"
+        )
+
+    if class_name[0].isdigit():
+        raise ValueError(
+            f"Project name '{name}' would generate class name '{class_name}' which cannot start with a digit"
+        )
+
+    # Check if the original name (before title casing) is a keyword
+    original_name_clean = re.sub(
+        r"[^a-zA-Z0-9_]", "", name.replace("_", "").replace("-", "").lower()
+    )
+    if (
+        keyword.iskeyword(original_name_clean)
+        or keyword.iskeyword(class_name)
+        or class_name in ("True", "False", "None")
+    ):
+        raise ValueError(
+            f"Project name '{name}' would generate class name '{class_name}' which is a reserved Python keyword"
+        )
+
+    if not class_name.isidentifier():
+        raise ValueError(
+            f"Project name '{name}' would generate invalid Python class name '{class_name}'"
+        )
+
+    if parent_folder:
+        folder_path = Path(parent_folder) / folder_name
+    else:
+        folder_path = Path(folder_name)
+
+    if folder_path.exists():
+        if not click.confirm(
+            f"Folder {folder_name} already exists. Do you want to override it?"
+        ):
+            click.secho("Operation cancelled.", fg="yellow")
+            sys.exit(0)
+        click.secho(f"Overriding folder {folder_name}...", fg="green", bold=True)
+        shutil.rmtree(folder_path)  # Delete the existing folder and its contents
+
+    click.secho(
+        f"Creating {'crew' if parent_folder else 'folder'} {folder_name}...",
+        fg="green",
+        bold=True,
+    )
+
+    folder_path.mkdir(parents=True)
+    (folder_path / "tests").mkdir(exist_ok=True)
+    (folder_path / "knowledge").mkdir(exist_ok=True)
+    if not parent_folder:
+        (folder_path / "src" / folder_name).mkdir(parents=True)
+        (folder_path / "src" / folder_name / "tools").mkdir(parents=True)
+        (folder_path / "src" / folder_name / "config").mkdir(parents=True)
+
+        # Copy AGENTS.md to project root (top-level projects only)
+        package_dir = Path(__file__).parent
+        agents_md_src = package_dir / "templates" / "AGENTS.md"
+        if agents_md_src.exists():
+            shutil.copy2(agents_md_src, folder_path / "AGENTS.md")
+
+    return folder_path, folder_name, class_name
+
+
+def copy_template_files(
+    folder_path: Path, name: str, class_name: str, parent_folder: str | None
+) -> None:
+    package_dir = Path(__file__).parent
+    templates_dir = package_dir / "templates" / "crew"
+
+    root_template_files = (
+        [
+            ".gitignore",
+            "pyproject.toml",
+            "README.md",
+            "knowledge/user_preference.txt",
+        ]
+        if not parent_folder
+        else []
+    )
+    tools_template_files = ["tools/custom_tool.py", "tools/__init__.py"]
+    config_template_files = ["config/agents.yaml", "config/tasks.yaml"]
+    src_template_files = (
+        ["__init__.py", "main.py", "crew.py"] if not parent_folder else ["crew.py"]
+    )
+
+    for file_name in root_template_files:
+        src_file = templates_dir / file_name
+        dst_file = folder_path / file_name
+        copy_template(src_file, dst_file, name, class_name, folder_path.name)
+
+    src_folder = (
+        folder_path / "src" / folder_path.name if not parent_folder else folder_path
+    )
+
+    for file_name in src_template_files:
+        src_file = templates_dir / file_name
+        dst_file = src_folder / file_name
+        copy_template(src_file, dst_file, name, class_name, folder_path.name)
+
+    if not parent_folder:
+        for file_name in tools_template_files + config_template_files:
+            src_file = templates_dir / file_name
+            dst_file = src_folder / file_name
+            copy_template(src_file, dst_file, name, class_name, folder_path.name)
+
+
+def create_crew(
+    name: str,
+    provider: str | None = None,
+    skip_provider: bool = False,
+    parent_folder: str | None = None,
+) -> None:
+    folder_path, folder_name, class_name = create_folder_structure(name, parent_folder)
+    env_vars = load_env_vars(folder_path)
+    if not skip_provider:
+        if not provider:
+            provider_models = get_provider_data()
+            if not provider_models:
+                return
+
+        existing_provider = None
+        for provider, env_keys in ENV_VARS.items():
+            if any(
+                "key_name" in details and details["key_name"] in env_vars
+                for details in env_keys
+            ):
+                existing_provider = provider
+                break
+
+        if existing_provider:
+            if not click.confirm(
+                f"Found existing environment variable configuration for {existing_provider.capitalize()}. Do you want to override it?"
+            ):
+                click.secho("Keeping existing provider configuration.", fg="yellow")
+                return
+
+        provider_models = get_provider_data()
+        if not provider_models:
+            return
+
+        while True:
+            selected_provider = select_provider(provider_models)
+            if selected_provider is None:  # User typed 'q'
+                click.secho("Exiting...", fg="yellow")
+                sys.exit(0)
+            if selected_provider and isinstance(
+                selected_provider, str
+            ):  # Valid selection
+                break
+            click.secho(
+                "No provider selected. Please try again or press 'q' to exit.", fg="red"
+            )
+
+        # Check if the selected provider has predefined models
+        if MODELS.get(selected_provider):
+            while True:
+                selected_model = select_model(selected_provider, provider_models)
+                if selected_model is None:  # User typed 'q'
+                    click.secho("Exiting...", fg="yellow")
+                    sys.exit(0)
+                if selected_model:  # Valid selection
+                    break
+                click.secho(
+                    "No model selected. Please try again or press 'q' to exit.",
+                    fg="red",
+                )
+            env_vars["MODEL"] = selected_model
+
+        # Check if the selected provider requires API keys
+        if selected_provider in ENV_VARS:
+            provider_env_vars = ENV_VARS[selected_provider]
+            for details in provider_env_vars:
+                if details.get("default", False):
+                    # Automatically add default key-value pairs
+                    for key, value in details.items():
+                        if key not in ["prompt", "key_name", "default"]:
+                            env_vars[key] = value
+                elif "key_name" in details:
+                    # Prompt for non-default key-value pairs
+                    prompt = details["prompt"]
+                    key_name = details["key_name"]
+                    api_key_value = click.prompt(prompt, default="", show_default=False)
+
+                    if api_key_value.strip():
+                        env_vars[key_name] = api_key_value
+
+        if env_vars:
+            write_env_file(folder_path, env_vars)
+            click.secho("API keys and model saved to .env file", fg="green")
+        else:
+            click.secho(
+                "No API keys provided. Skipping .env file creation.", fg="yellow"
+            )
+
+        click.secho(f"Selected model: {env_vars.get('MODEL', 'N/A')}", fg="green")
+
+    package_dir = Path(__file__).parent
+    templates_dir = package_dir / "templates" / "crew"
+
+    root_template_files = (
+        [".gitignore", "pyproject.toml", "README.md", "knowledge/user_preference.txt"]
+        if not parent_folder
+        else []
+    )
+    tools_template_files = ["tools/custom_tool.py", "tools/__init__.py"]
+    config_template_files = ["config/agents.yaml", "config/tasks.yaml"]
+    src_template_files = (
+        ["__init__.py", "main.py", "crew.py"] if not parent_folder else ["crew.py"]
+    )
+
+    for file_name in root_template_files:
+        src_file = templates_dir / file_name
+        dst_file = folder_path / file_name
+        copy_template(src_file, dst_file, name, class_name, folder_name)
+
+    src_folder = folder_path / "src" / folder_name if not parent_folder else folder_path
+
+    for file_name in src_template_files:
+        src_file = templates_dir / file_name
+        dst_file = src_folder / file_name
+        copy_template(src_file, dst_file, name, class_name, folder_name)
+
+    if not parent_folder:
+        for file_name in tools_template_files + config_template_files:
+            src_file = templates_dir / file_name
+            dst_file = src_folder / file_name
+            copy_template(src_file, dst_file, name, class_name, folder_name)
+
+    click.secho(f"Crew {name} created successfully!", fg="green", bold=True)

lib/cli/src/crewai_cli/create_flow.py

@@ -0,0 +1,99 @@
+from pathlib import Path
+import shutil
+
+import click
+
+
+def create_flow(name):
+    """Create a new flow."""
+    folder_name = name.replace(" ", "_").replace("-", "_").lower()
+    class_name = name.replace("_", " ").replace("-", " ").title().replace(" ", "")
+
+    click.secho(f"Creating flow {folder_name}...", fg="green", bold=True)
+
+    project_root = Path(folder_name)
+    if project_root.exists():
+        click.secho(f"Error: Folder {folder_name} already exists.", fg="red")
+        return
+
+    # Create directory structure
+    (project_root / "src" / folder_name).mkdir(parents=True)
+    (project_root / "src" / folder_name / "crews").mkdir(parents=True)
+    (project_root / "src" / folder_name / "tools").mkdir(parents=True)
+    (project_root / "tests").mkdir(exist_ok=True)
+
+    # Create .env file
+    with open(project_root / ".env", "w") as file:
+        file.write("OPENAI_API_KEY=YOUR_API_KEY")
+
+    package_dir = Path(__file__).parent
+    templates_dir = package_dir / "templates" / "flow"
+
+    # Copy AGENTS.md to project root
+    agents_md_src = package_dir / "templates" / "AGENTS.md"
+    if agents_md_src.exists():
+        shutil.copy2(agents_md_src, project_root / "AGENTS.md")
+
+    # List of template files to copy
+    root_template_files = [".gitignore", "pyproject.toml", "README.md"]
+    src_template_files = ["__init__.py", "main.py"]
+    tools_template_files = ["tools/__init__.py", "tools/custom_tool.py"]
+
+    crew_folders = [
+        "poem_crew",
+    ]
+
+    def process_file(src_file, dst_file):
+        if src_file.suffix in [".pyc", ".pyo", ".pyd"]:
+            return
+
+        try:
+            with open(src_file, "r", encoding="utf-8") as file:
+                content = file.read()
+        except Exception as e:
+            click.secho(f"Error processing file {src_file}: {e}", fg="red")
+            return
+
+        content = content.replace("{{name}}", name)
+        content = content.replace("{{flow_name}}", class_name)
+        content = content.replace("{{folder_name}}", folder_name)
+
+        with open(dst_file, "w") as file:
+            file.write(content)
+
+    # Copy and process root template files
+    for file_name in root_template_files:
+        src_file = templates_dir / file_name
+        dst_file = project_root / file_name
+        process_file(src_file, dst_file)
+
+    # Copy and process src template files
+    for file_name in src_template_files:
+        src_file = templates_dir / file_name
+        dst_file = project_root / "src" / folder_name / file_name
+        process_file(src_file, dst_file)
+
+    # Copy tools files
+    for file_name in tools_template_files:
+        src_file = templates_dir / file_name
+        dst_file = project_root / "src" / folder_name / file_name
+        process_file(src_file, dst_file)
+
+    # Copy crew folders
+    for crew_folder in crew_folders:
+        src_crew_folder = templates_dir / "crews" / crew_folder
+        dst_crew_folder = project_root / "src" / folder_name / "crews" / crew_folder
+        if src_crew_folder.exists():
+            for src_file in src_crew_folder.rglob("*"):
+                if src_file.is_file():
+                    relative_path = src_file.relative_to(src_crew_folder)
+                    dst_file = dst_crew_folder / relative_path
+                    dst_file.parent.mkdir(parents=True, exist_ok=True)
+                    process_file(src_file, dst_file)
+        else:
+            click.secho(
+                f"Warning: Crew folder {crew_folder} not found in template.",
+                fg="yellow",
+            )
+
+    click.secho(f"Flow {name} created successfully!", fg="green", bold=True)

lib/cli/src/crewai_cli/crew_chat.py

@@ -0,0 +1,23 @@
+"""Wrapper for the crew chat command.
+
+Delegates to ``crewai.cli.crew_chat.run_chat`` when the full crewai package is
+installed, otherwise prints a helpful error message.
+"""
+
+from __future__ import annotations
+
+import click
+
+
+def run_chat() -> None:
+    try:
+        from crewai.cli.crew_chat import run_chat as _run_chat
+    except ImportError:
+        click.secho(
+            "The 'chat' command requires the full crewai package.\n"
+            "Install it with: pip install crewai",
+            fg="red",
+        )
+        raise SystemExit(1) from None
+
+    _run_chat()

lib/cli/src/crewai_cli/deploy/main.py

@@ -0,0 +1,272 @@
+from typing import Any
+
+from rich.console import Console
+
+from crewai_cli import git
+from crewai_cli.command import BaseCommand, PlusAPIMixin
+from crewai_cli.utils import fetch_and_json_env_file, get_project_name
+
+
+console = Console()
+
+
+class DeployCommand(BaseCommand, PlusAPIMixin):
+    """
+    A class to handle deployment-related operations for CrewAI projects.
+    """
+
+    def __init__(self):
+        """
+        Initialize the DeployCommand with project name and API client.
+        """
+
+        BaseCommand.__init__(self)
+        PlusAPIMixin.__init__(self)
+        self.project_name = get_project_name(require=True)
+
+    def _standard_no_param_error_message(self) -> None:
+        """
+        Display a standard error message when no UUID or project name is available.
+        """
+        console.print(
+            "No UUID provided, project pyproject.toml not found or with error.",
+            style="bold red",
+        )
+
+    def _display_deployment_info(self, json_response: dict[str, Any]) -> None:
+        """
+        Display deployment information.
+
+        Args:
+            json_response (Dict[str, Any]): The deployment information to display.
+        """
+        console.print("Deploying the crew...\n", style="bold blue")
+        for key, value in json_response.items():
+            console.print(f"{key.title()}: [green]{value}[/green]")
+        console.print("\nTo check the status of the deployment, run:")
+        console.print("crewai deploy status")
+        console.print(" or")
+        console.print(f'crewai deploy status --uuid "{json_response["uuid"]}"')
+
+    def _display_logs(self, log_messages: list[dict[str, Any]]) -> None:
+        """
+        Display log messages.
+
+        Args:
+            log_messages (List[Dict[str, Any]]): The log messages to display.
+        """
+        for log_message in log_messages:
+            console.print(
+                f"{log_message['timestamp']} - {log_message['level']}: {log_message['message']}"
+            )
+
+    def deploy(self, uuid: str | None = None) -> None:
+        """
+        Deploy a crew using either UUID or project name.
+
+        Args:
+            uuid (Optional[str]): The UUID of the crew to deploy.
+        """
+        console.print("Starting deployment...", style="bold blue")
+        if uuid:
+            response = self.plus_api_client.deploy_by_uuid(uuid)
+        elif self.project_name:
+            response = self.plus_api_client.deploy_by_name(self.project_name)
+        else:
+            self._standard_no_param_error_message()
+            return
+
+        self._validate_response(response)
+        self._display_deployment_info(response.json())
+
+    def create_crew(self, confirm: bool = False) -> None:
+        """
+        Create a new crew deployment.
+        """
+        console.print("Creating deployment...", style="bold blue")
+        env_vars = fetch_and_json_env_file()
+
+        try:
+            remote_repo_url = git.Repository().origin_url()
+        except ValueError:
+            remote_repo_url = None
+
+        if remote_repo_url is None:
+            console.print("No remote repository URL found.", style="bold red")
+            console.print(
+                "Please ensure your project has a valid remote repository.",
+                style="yellow",
+            )
+            return
+
+        self._confirm_input(env_vars, remote_repo_url, confirm)
+        payload = self._create_payload(env_vars, remote_repo_url)
+        response = self.plus_api_client.create_crew(payload)
+
+        self._validate_response(response)
+        self._display_creation_success(response.json())
+
+    def _confirm_input(
+        self, env_vars: dict[str, str], remote_repo_url: str, confirm: bool
+    ) -> None:
+        """
+        Confirm input parameters with the user.
+
+        Args:
+            env_vars (Dict[str, str]): Environment variables.
+            remote_repo_url (str): Remote repository URL.
+            confirm (bool): Whether to confirm input.
+        """
+        if not confirm:
+            input(f"Press Enter to continue with the following Env vars: {env_vars}")
+            input(
+                f"Press Enter to continue with the following remote repository: {remote_repo_url}\n"
+            )
+
+    def _create_payload(
+        self,
+        env_vars: dict[str, str],
+        remote_repo_url: str,
+    ) -> dict[str, Any]:
+        """
+        Create the payload for crew creation.
+
+        Args:
+            remote_repo_url (str): Remote repository URL.
+            env_vars (Dict[str, str]): Environment variables.
+
+        Returns:
+            Dict[str, Any]: The payload for crew creation.
+        """
+        return {
+            "deploy": {
+                "name": self.project_name,
+                "repo_clone_url": remote_repo_url,
+                "env": env_vars,
+            }
+        }
+
+    def _display_creation_success(self, json_response: dict[str, Any]) -> None:
+        """
+        Display success message after crew creation.
+
+        Args:
+            json_response (Dict[str, Any]): The response containing crew information.
+        """
+        console.print("Deployment created successfully!\n", style="bold green")
+        console.print(
+            f"Name: {self.project_name} ({json_response['uuid']})", style="bold green"
+        )
+        console.print(f"Status: {json_response['status']}", style="bold green")
+        console.print("\nTo (re)deploy the crew, run:")
+        console.print("crewai deploy push")
+        console.print(" or")
+        console.print(f"crewai deploy push --uuid {json_response['uuid']}")
+
+    def list_crews(self) -> None:
+        """
+        List all available crews.
+        """
+        console.print("Listing all Crews\n", style="bold blue")
+
+        response = self.plus_api_client.list_crews()
+        json_response = response.json()
+        if response.status_code == 200:
+            self._display_crews(json_response)
+        else:
+            self._display_no_crews_message()
+
+    def _display_crews(self, crews_data: list[dict[str, Any]]) -> None:
+        """
+        Display the list of crews.
+
+        Args:
+            crews_data (List[Dict[str, Any]]): List of crew data to display.
+        """
+        for crew_data in crews_data:
+            console.print(
+                f"- {crew_data['name']} ({crew_data['uuid']}) [blue]{crew_data['status']}[/blue]"
+            )
+
+    def _display_no_crews_message(self) -> None:
+        """
+        Display a message when no crews are available.
+        """
+        console.print("You don't have any Crews yet. Let's create one!", style="yellow")
+        console.print("  crewai create crew <crew_name>", style="green")
+
+    def get_crew_status(self, uuid: str | None = None) -> None:
+        """
+        Get the status of a crew.
+
+        Args:
+            uuid (Optional[str]): The UUID of the crew to check.
+        """
+        console.print("Fetching deployment status...", style="bold blue")
+        if uuid:
+            response = self.plus_api_client.crew_status_by_uuid(uuid)
+        elif self.project_name:
+            response = self.plus_api_client.crew_status_by_name(self.project_name)
+        else:
+            self._standard_no_param_error_message()
+            return
+
+        self._validate_response(response)
+        self._display_crew_status(response.json())
+
+    def _display_crew_status(self, status_data: dict[str, str]) -> None:
+        """
+        Display the status of a crew.
+
+        Args:
+            status_data (Dict[str, str]): The status data to display.
+        """
+        console.print(f"Name:\t {status_data['name']}")
+        console.print(f"Status:\t {status_data['status']}")
+
+    def get_crew_logs(self, uuid: str | None, log_type: str = "deployment") -> None:
+        """
+        Get logs for a crew.
+
+        Args:
+            uuid (Optional[str]): The UUID of the crew to get logs for.
+            log_type (str): The type of logs to retrieve (default: "deployment").
+        """
+        console.print(f"Fetching {log_type} logs...", style="bold blue")
+
+        if uuid:
+            response = self.plus_api_client.crew_by_uuid(uuid, log_type)
+        elif self.project_name:
+            response = self.plus_api_client.crew_by_name(self.project_name, log_type)
+        else:
+            self._standard_no_param_error_message()
+            return
+
+        self._validate_response(response)
+        self._display_logs(response.json())
+
+    def remove_crew(self, uuid: str | None) -> None:
+        """
+        Remove a crew deployment.
+
+        Args:
+            uuid (Optional[str]): The UUID of the crew to remove.
+        """
+        console.print("Removing deployment...", style="bold blue")
+
+        if uuid:
+            response = self.plus_api_client.delete_crew_by_uuid(uuid)
+        elif self.project_name:
+            response = self.plus_api_client.delete_crew_by_name(self.project_name)
+        else:
+            self._standard_no_param_error_message()
+            return
+
+        if response.status_code == 204:
+            console.print(
+                f"Crew '{self.project_name}' removed successfully.", style="green"
+            )
+        else:
+            console.print(
+                f"Failed to remove crew '{self.project_name}'", style="bold red"
+            )

lib/cli/src/crewai_cli/enterprise/main.py

@@ -0,0 +1,125 @@
+import json
+from typing import Any, cast
+
+import httpx
+from rich.console import Console
+
+from crewai_cli.authentication.main import Oauth2Settings, ProviderFactory
+from crewai_cli.command import BaseCommand
+from crewai_cli.settings.main import SettingsCommand
+from crewai_cli.version import get_crewai_version
+
+
+console = Console()
+
+
+class EnterpriseConfigureCommand(BaseCommand):
+    def __init__(self) -> None:
+        super().__init__()
+        self.settings_command = SettingsCommand()
+
+    def configure(self, enterprise_url: str) -> None:
+        try:
+            enterprise_url = enterprise_url.rstrip("/")
+
+            oauth_config = self._fetch_oauth_config(enterprise_url)
+
+            self._update_oauth_settings(enterprise_url, oauth_config)
+
+            console.print(
+                f"✅ Successfully configured CrewAI AMP with OAuth2 settings from {enterprise_url}",
+                style="bold green",
+            )
+
+        except Exception as e:
+            console.print(
+                f"❌ Failed to configure Enterprise settings: {e!s}", style="bold red"
+            )
+            raise SystemExit(1) from e
+
+    def _fetch_oauth_config(self, enterprise_url: str) -> dict[str, Any]:
+        oauth_endpoint = f"{enterprise_url}/auth/parameters"
+
+        try:
+            console.print(f"🔄 Fetching OAuth2 configuration from {oauth_endpoint}...")
+            headers = {
+                "Content-Type": "application/json",
+                "User-Agent": f"CrewAI-CLI/{get_crewai_version()}",
+                "X-Crewai-Version": get_crewai_version(),
+            }
+            response = httpx.get(oauth_endpoint, timeout=30, headers=headers)
+            response.raise_for_status()
+
+            try:
+                oauth_config = response.json()
+            except json.JSONDecodeError as e:
+                raise ValueError(f"Invalid JSON response from {oauth_endpoint}") from e
+
+            self._validate_oauth_config(oauth_config)
+
+            console.print(
+                "✅ Successfully retrieved OAuth2 configuration", style="green"
+            )
+            return cast(dict[str, Any], oauth_config)
+
+        except httpx.HTTPError as e:
+            raise ValueError(f"Failed to connect to enterprise URL: {e!s}") from e
+        except Exception as e:
+            raise ValueError(f"Error fetching OAuth2 configuration: {e!s}") from e
+
+    def _update_oauth_settings(
+        self, enterprise_url: str, oauth_config: dict[str, Any]
+    ) -> None:
+        try:
+            config_mapping = {
+                "enterprise_base_url": enterprise_url,
+                "oauth2_provider": oauth_config["provider"],
+                "oauth2_audience": oauth_config["audience"],
+                "oauth2_client_id": oauth_config["device_authorization_client_id"],
+                "oauth2_domain": oauth_config["domain"],
+                "oauth2_extra": oauth_config["extra"],
+            }
+
+            console.print("🔄 Updating local OAuth2 configuration...")
+
+            for key, value in config_mapping.items():
+                self.settings_command.set(key, value)
+                console.print(f"  ✓ Set {key}: {value}", style="dim")
+
+        except Exception as e:
+            raise ValueError(f"Failed to update OAuth2 settings: {e!s}") from e
+
+    def _validate_oauth_config(self, oauth_config: dict[str, Any]) -> None:
+        required_fields = [
+            "audience",
+            "domain",
+            "device_authorization_client_id",
+            "provider",
+            "extra",
+        ]
+
+        missing_basic_fields = [
+            field for field in required_fields if field not in oauth_config
+        ]
+        missing_provider_specific_fields = [
+            field
+            for field in self._get_provider_specific_fields(oauth_config["provider"])
+            if field not in oauth_config.get("extra", {})
+        ]
+
+        if missing_basic_fields:
+            raise ValueError(
+                f"Missing required fields in OAuth2 configuration: [{', '.join(missing_basic_fields)}]"
+            )
+
+        if missing_provider_specific_fields:
+            raise ValueError(
+                f"Missing authentication provider required fields in OAuth2 configuration: [{', '.join(missing_provider_specific_fields)}] (Configured provider: '{oauth_config['provider']}')"
+            )
+
+    def _get_provider_specific_fields(self, provider_name: str) -> list[str]:
+        provider = ProviderFactory.from_settings(
+            Oauth2Settings(provider=provider_name, client_id="dummy", domain="dummy")
+        )
+
+        return provider.get_required_fields()

lib/cli/src/crewai_cli/evaluate_crew.py

@@ -0,0 +1,30 @@
+import subprocess
+
+import click
+
+
+def evaluate_crew(n_iterations: int, model: str) -> None:
+    """
+    Test and Evaluate the crew by running a command in the UV environment.
+
+    Args:
+        n_iterations (int): The number of iterations to test the crew.
+        model (str): The model to test the crew with.
+    """
+    command = ["uv", "run", "test", str(n_iterations), model]
+
+    try:
+        if n_iterations <= 0:
+            raise ValueError("The number of iterations must be a positive integer.")
+
+        result = subprocess.run(command, capture_output=False, text=True, check=True)  # noqa: S603
+
+        if result.stderr:
+            click.echo(result.stderr, err=True)
+
+    except subprocess.CalledProcessError as e:
+        click.echo(f"An error occurred while testing the crew: {e}", err=True)
+        click.echo(e.output, err=True)
+
+    except Exception as e:
+        click.echo(f"An unexpected error occurred: {e}", err=True)

lib/cli/src/crewai_cli/git.py

@@ -0,0 +1,89 @@
+from functools import lru_cache
+import subprocess
+
+
+class Repository:
+    def __init__(self, path: str = ".") -> None:
+        self.path = path
+
+        if not self.is_git_installed():
+            raise ValueError("Git is not installed or not found in your PATH.")
+
+        if not self.is_git_repo():
+            raise ValueError(f"{self.path} is not a Git repository.")
+
+        self.fetch()
+
+    @staticmethod
+    def is_git_installed() -> bool:
+        """Check if Git is installed and available in the system."""
+        try:
+            subprocess.run(
+                ["git", "--version"],  # noqa: S607
+                capture_output=True,
+                check=True,
+                text=True,
+            )
+            return True
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            return False
+
+    def fetch(self) -> None:
+        """Fetch latest updates from the remote."""
+        subprocess.run(["git", "fetch"], cwd=self.path, check=True)  # noqa: S607
+
+    def status(self) -> str:
+        """Get the git status in porcelain format."""
+        return subprocess.check_output(
+            ["git", "status", "--branch", "--porcelain"],  # noqa: S607
+            cwd=self.path,
+            encoding="utf-8",
+        ).strip()
+
+    @lru_cache(maxsize=None)  # noqa: B019
+    def is_git_repo(self) -> bool:
+        """Check if the current directory is a git repository.
+
+        Notes:
+          - TODO: This method is cached to avoid redundant checks, but using lru_cache on methods can lead to memory leaks
+        """
+        try:
+            subprocess.check_output(
+                ["git", "rev-parse", "--is-inside-work-tree"],  # noqa: S607
+                cwd=self.path,
+                encoding="utf-8",
+            )
+            return True
+        except subprocess.CalledProcessError:
+            return False
+
+    def has_uncommitted_changes(self) -> bool:
+        """Check if the repository has uncommitted changes."""
+        return len(self.status().splitlines()) > 1
+
+    def is_ahead_or_behind(self) -> bool:
+        """Check if the repository is ahead or behind the remote."""
+        for line in self.status().splitlines():
+            if line.startswith("##") and ("ahead" in line or "behind" in line):
+                return True
+        return False
+
+    def is_synced(self) -> bool:
+        """Return True if the Git repository is fully synced with the remote, False otherwise."""
+        if self.has_uncommitted_changes() or self.is_ahead_or_behind():
+            return False
+        return True
+
+    def origin_url(self) -> str | None:
+        """Get the Git repository's remote URL."""
+        try:
+            result = subprocess.run(
+                ["git", "remote", "get-url", "origin"],  # noqa: S607
+                cwd=self.path,
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            return result.stdout.strip()
+        except subprocess.CalledProcessError:
+            return None

lib/cli/src/crewai_cli/install_crew.py

@@ -0,0 +1,23 @@
+import subprocess
+
+import click
+
+
+# Be mindful about changing this.
+# on some environments we don't use this command but instead uv sync directly
+# so if you expect this to support more things you will need to replicate it there
+# ask @joaomdmoura if you are unsure
+def install_crew(proxy_options: list[str]) -> None:
+    """
+    Install the crew by running the UV command to lock and install.
+    """
+    try:
+        command = ["uv", "sync", *proxy_options]
+        subprocess.run(command, check=True, capture_output=False, text=True)  # noqa: S603
+
+    except subprocess.CalledProcessError as e:
+        click.echo(f"An error occurred while running the crew: {e}", err=True)
+        click.echo(e.output, err=True)
+
+    except Exception as e:
+        click.echo(f"An unexpected error occurred: {e}", err=True)

lib/cli/src/crewai_cli/kickoff_flow.py

@@ -0,0 +1,23 @@
+import subprocess
+
+import click
+
+
+def kickoff_flow() -> None:
+    """
+    Kickoff the flow by running a command in the UV environment.
+    """
+    command = ["uv", "run", "kickoff"]
+
+    try:
+        result = subprocess.run(command, capture_output=False, text=True, check=True)  # noqa: S603
+
+        if result.stderr:
+            click.echo(result.stderr, err=True)
+
+    except subprocess.CalledProcessError as e:
+        click.echo(f"An error occurred while running the flow: {e}", err=True)
+        click.echo(e.output, err=True)
+
+    except Exception as e:
+        click.echo(f"An unexpected error occurred: {e}", err=True)

lib/cli/src/crewai_cli/memory_tui.py

@@ -0,0 +1,403 @@
+"""Textual TUI for browsing and recalling unified memory."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+from textual.app import App, ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.widgets import Footer, Header, Input, OptionList, Static, Tree
+
+
+# -- CrewAI brand palette --
+_PRIMARY = "#eb6658"  # coral
+_SECONDARY = "#1F7982"  # teal
+_TERTIARY = "#ffffff"  # white
+
+
+def _format_scope_info(info: Any) -> str:
+    """Format ScopeInfo with Rich markup."""
+    return (
+        f"[bold {_PRIMARY}]{info.path}[/]\n\n"
+        f"[dim]Records:[/]     [bold]{info.record_count}[/]\n"
+        f"[dim]Categories:[/]  {', '.join(info.categories) or 'none'}\n"
+        f"[dim]Oldest:[/]      {info.oldest_record or '-'}\n"
+        f"[dim]Newest:[/]      {info.newest_record or '-'}\n"
+        f"[dim]Children:[/]    {', '.join(info.child_scopes) or 'none'}"
+    )
+
+
+class MemoryTUI(App[None]):
+    """TUI to browse memory scopes and run recall queries."""
+
+    TITLE = "CrewAI Memory"
+    SUB_TITLE = "Browse scopes and recall memories"
+
+    CSS = f"""
+    Header {{
+        background: {_PRIMARY};
+        color: {_TERTIARY};
+    }}
+    Footer {{
+        background: {_SECONDARY};
+        color: {_TERTIARY};
+    }}
+    Footer > .footer-key--key {{
+        background: {_PRIMARY};
+        color: {_TERTIARY};
+    }}
+    Horizontal {{
+        height: 1fr;
+    }}
+    #scope-tree {{
+        width: 30%;
+        padding: 1 2;
+        background: {_SECONDARY} 8%;
+        border-right: solid {_SECONDARY};
+    }}
+    #scope-tree:focus > .tree--cursor {{
+        background: {_SECONDARY};
+        color: {_TERTIARY};
+    }}
+    #scope-tree > .tree--guides {{
+        color: {_SECONDARY} 50%;
+    }}
+    #scope-tree > .tree--guides-hover {{
+        color: {_PRIMARY};
+    }}
+    #scope-tree > .tree--guides-selected {{
+        color: {_SECONDARY};
+    }}
+    #right-panel {{
+        width: 70%;
+        padding: 0 1;
+    }}
+    #info-panel {{
+        height: 2fr;
+        padding: 1 2;
+        overflow-y: auto;
+        border: round {_SECONDARY};
+    }}
+    #info-panel:focus {{
+        border: round {_PRIMARY};
+    }}
+    #info-panel LoadingIndicator {{
+        color: {_PRIMARY};
+    }}
+    #entry-list {{
+        height: 1fr;
+        border: round {_SECONDARY};
+        padding: 0 1;
+        scrollbar-color: {_PRIMARY};
+    }}
+    #entry-list:focus {{
+        border: round {_PRIMARY};
+    }}
+    #entry-list > .option-list--option-highlighted {{
+        background: {_SECONDARY};
+        color: {_TERTIARY};
+    }}
+    #recall-input {{
+        margin: 0 1 1 1;
+        border: tall {_SECONDARY};
+    }}
+    #recall-input:focus {{
+        border: tall {_PRIMARY};
+    }}
+    """
+
+    def __init__(
+        self,
+        storage_path: str | None = None,
+        embedder_config: dict[str, Any] | None = None,
+    ) -> None:
+        super().__init__()
+        self._memory: Any = None
+        self._init_error: str | None = None
+        self._selected_scope: str = "/"
+        self._entries: list[Any] = []
+        self._view_mode: str = "list"  # "list" | "recall"
+        self._recall_matches: list[Any] = []
+        self._last_scope_info: Any = None
+        self._custom_embedder = embedder_config is not None
+        try:
+            from crewai.memory.storage.lancedb_storage import LanceDBStorage
+            from crewai.memory.unified_memory import Memory
+
+            storage = (
+                LanceDBStorage(path=storage_path) if storage_path else LanceDBStorage()
+            )
+            embedder = None
+            if embedder_config is not None:
+                from crewai.rag.embeddings.factory import build_embedder
+
+                embedder = build_embedder(embedder_config)
+            self._memory = (
+                Memory(storage=storage, embedder=embedder)
+                if embedder
+                else Memory(storage=storage)
+            )
+        except Exception as e:
+            self._init_error = str(e)
+
+    def compose(self) -> ComposeResult:
+        yield Header(show_clock=False)
+        with Horizontal():
+            yield self._build_scope_tree()
+            initial = (
+                self._init_error
+                if self._init_error
+                else "Select a scope or type a recall query."
+            )
+            with Vertical(id="right-panel"):
+                yield Static(initial, id="info-panel")
+                yield OptionList(id="entry-list")
+        yield Input(
+            placeholder="Type a query and press Enter to recall...",
+            id="recall-input",
+        )
+        yield Footer()
+
+    def on_mount(self) -> None:
+        """Set initial border titles on mounted widgets."""
+        self.query_one("#info-panel", Static).border_title = "Detail"
+        self.query_one("#entry-list", OptionList).border_title = "Entries"
+
+    def _build_scope_tree(self) -> Tree[str]:
+        tree: Tree[str] = Tree("/", id="scope-tree")
+        if self._memory is None:
+            tree.root.data = "/"
+            tree.root.label = "/ (0 records)"
+            return tree
+        info = self._memory.info("/")
+        tree.root.label = f"/ ({info.record_count} records)"
+        tree.root.data = "/"
+        self._add_children(tree.root, "/", depth=0, max_depth=3)
+        tree.root.expand()
+        return tree
+
+    def _add_children(
+        self,
+        parent_node: Tree.Node[str],
+        path: str,
+        depth: int,
+        max_depth: int,
+    ) -> None:
+        if depth >= max_depth or self._memory is None:
+            return
+        info = self._memory.info(path)
+        for child in info.child_scopes:
+            child_info = self._memory.info(child)
+            label = f"{child} ({child_info.record_count})"
+            node = parent_node.add(label, data=child)
+            self._add_children(node, child, depth + 1, max_depth)
+
+    # -- Populating the OptionList -------------------------------------------
+
+    def _populate_entry_list(self) -> None:
+        """Clear the OptionList and fill it with the current scope's entries."""
+        option_list = self.query_one("#entry-list", OptionList)
+        option_list.clear_options()
+        for record in self._entries:
+            date_str = record.created_at.strftime("%Y-%m-%d")
+            preview = (
+                (record.content[:80] + "…")
+                if len(record.content) > 80
+                else record.content
+            )
+            label = f"{date_str}  [bold]{record.importance:.1f}[/]  {preview}"
+            option_list.add_option(label)
+
+    def _populate_recall_list(self) -> None:
+        """Clear the OptionList and fill it with the current recall matches."""
+        option_list = self.query_one("#entry-list", OptionList)
+        option_list.clear_options()
+        if not self._recall_matches:
+            return
+        for m in self._recall_matches:
+            preview = (
+                (m.record.content[:80] + "…")
+                if len(m.record.content) > 80
+                else m.record.content
+            )
+            label = (
+                f"[bold]\\[{m.score:.2f}][/]  {preview}  [dim]scope={m.record.scope}[/]"
+            )
+            option_list.add_option(label)
+
+    # -- Detail rendering ----------------------------------------------------
+
+    def _format_record_detail(self, record: Any, context_line: str = "") -> str:
+        """Format a full MemoryRecord as Rich markup for the detail view.
+
+        Args:
+            record: A MemoryRecord instance.
+            context_line: Optional header line shown above the fields
+                (e.g. "Entry 3 of 47").
+
+        Returns:
+            A Rich-markup string with all meaningful record fields.
+        """
+        sep = f"[bold {_PRIMARY}]{'─' * 44}[/]"
+        lines: list[str] = []
+
+        if context_line:
+            lines.append(context_line)
+            lines.append("")
+
+        # -- Fields block --
+        lines.append(f"[dim]ID:[/]             {record.id}")
+        lines.append(f"[dim]Scope:[/]          [bold]{record.scope}[/]")
+        lines.append(f"[dim]Importance:[/]      [bold]{record.importance:.2f}[/]")
+        lines.append(
+            f"[dim]Created:[/]        {record.created_at.strftime('%Y-%m-%d %H:%M:%S')}"
+        )
+        lines.append(
+            f"[dim]Last accessed:[/]  "
+            f"{record.last_accessed.strftime('%Y-%m-%d %H:%M:%S')}"
+        )
+        lines.append(
+            f"[dim]Categories:[/]     "
+            f"{', '.join(record.categories) if record.categories else 'none'}"
+        )
+        lines.append(f"[dim]Source:[/]         {record.source or '-'}")
+        lines.append(f"[dim]Private:[/]        {'Yes' if record.private else 'No'}")
+
+        # -- Content block --
+        lines.append(f"\n{sep}")
+        lines.append("[bold]Content[/]\n")
+        lines.append(record.content)
+
+        # -- Metadata block --
+        if record.metadata:
+            lines.append(f"\n{sep}")
+            lines.append("[bold]Metadata[/]\n")
+            for k, v in record.metadata.items():
+                lines.append(f"[dim]{k}:[/] {v}")
+
+        return "\n".join(lines)
+
+    # -- Event handlers ------------------------------------------------------
+
+    def on_tree_node_selected(self, event: Tree.NodeSelected[str]) -> None:
+        """Load entries for the selected scope and populate the OptionList."""
+        path = event.node.data if event.node.data is not None else "/"
+        self._selected_scope = path
+        self._view_mode = "list"
+        panel = self.query_one("#info-panel", Static)
+        if self._memory is None:
+            panel.update(self._init_error or "No memory loaded.")
+            return
+        display_limit = 1000
+        info = self._memory.info(path)
+        self._last_scope_info = info
+        self._entries = self._memory.list_records(scope=path, limit=display_limit)
+        panel.update(_format_scope_info(info))
+        panel.border_title = "Detail"
+        entry_list = self.query_one("#entry-list", OptionList)
+        capped = info.record_count > display_limit
+        count_label = (
+            f"Entries (showing {display_limit} of {info.record_count} — display limit)"
+            if capped
+            else f"Entries ({len(self._entries)})"
+        )
+        entry_list.border_title = count_label
+        self._populate_entry_list()
+
+    def on_option_list_option_highlighted(
+        self, event: OptionList.OptionHighlighted
+    ) -> None:
+        """Live-update the info panel with the detail of the highlighted entry."""
+        panel = self.query_one("#info-panel", Static)
+        idx = event.option_index
+
+        if self._view_mode == "list":
+            if idx < len(self._entries):
+                record = self._entries[idx]
+                total = len(self._entries)
+                context = (
+                    f"[bold {_PRIMARY}]Entry {idx + 1} of {total}[/]  "
+                    f"[dim]in[/] [bold]{self._selected_scope}[/]"
+                )
+                panel.border_title = f"Entry {idx + 1} of {total}"
+                panel.update(self._format_record_detail(record, context_line=context))
+
+        elif self._view_mode == "recall":
+            if idx < len(self._recall_matches):
+                match = self._recall_matches[idx]
+                total = len(self._recall_matches)
+                panel.border_title = f"Match {idx + 1} of {total}"
+                score_color = _PRIMARY if match.score >= 0.5 else "dim"
+                header_lines: list[str] = [
+                    f"[bold {_PRIMARY}]Recall Match {idx + 1} of {total}[/]\n",
+                    f"[dim]Score:[/]          [{score_color}][bold]{match.score:.2f}[/][/]",
+                    (
+                        f"[dim]Match reasons:[/]  "
+                        f"{', '.join(match.match_reasons) if match.match_reasons else '-'}"
+                    ),
+                    (
+                        f"[dim]Evidence gaps:[/]  "
+                        f"{', '.join(match.evidence_gaps) if match.evidence_gaps else 'none'}"
+                    ),
+                    f"\n[bold {_PRIMARY}]{'─' * 44}[/]",
+                ]
+                record_detail = self._format_record_detail(match.record)
+                header_lines.append(record_detail)
+                panel.update("\n".join(header_lines))
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        query = event.value.strip()
+        if not query:
+            return
+        if self._memory is None:
+            panel = self.query_one("#info-panel", Static)
+            panel.update(self._init_error or "No memory loaded. Cannot recall.")
+            return
+        self.run_worker(self._do_recall(query), exclusive=True)
+
+    async def _do_recall(self, query: str) -> None:
+        """Execute a recall query and display results in the OptionList."""
+        panel = self.query_one("#info-panel", Static)
+        panel.loading = True
+        try:
+            scope = self._selected_scope if self._selected_scope != "/" else None
+            loop = asyncio.get_event_loop()
+            matches = await loop.run_in_executor(
+                None,
+                lambda: self._memory.recall(query, scope=scope, limit=10, depth="deep"),
+            )
+            self._recall_matches = matches or []
+            self._view_mode = "recall"
+
+            if not self._recall_matches:
+                panel.update("[dim]No memories found.[/]")
+                self.query_one("#entry-list", OptionList).clear_options()
+                return
+
+            info_lines: list[str] = []
+            info_lines.append(
+                "[dim italic]Searched the full dataset"
+                + (f" within [bold]{scope}[/]" if scope else "")
+                + " using the recall flow (semantic + recency + importance).[/]\n"
+            )
+            if not self._custom_embedder:
+                info_lines.append(
+                    "[dim italic]Note: Using default OpenAI embedder. "
+                    "If memories were created with a different embedder, "
+                    "pass --embedder-provider to match.[/]\n"
+                )
+            info_lines.append(
+                f"[bold]Recall Results[/] [dim]"
+                f"({len(self._recall_matches)} matches)[/]\n"
+                f"[dim]Navigate the list below to view details.[/]"
+            )
+            panel.update("\n".join(info_lines))
+            panel.border_title = "Recall Detail"
+            entry_list = self.query_one("#entry-list", OptionList)
+            entry_list.border_title = f"Recall Results ({len(self._recall_matches)})"
+            self._populate_recall_list()
+        except Exception as e:
+            panel.update(f"[bold red]Error:[/] {e}")
+        finally:
+            panel.loading = False

lib/cli/src/crewai_cli/organization/__init__.py

@@ -0,0 +1 @@
+

lib/cli/src/crewai_cli/organization/main.py

@@ -0,0 +1,107 @@
+from httpx import HTTPStatusError
+from rich.console import Console
+from rich.table import Table
+
+from crewai_cli.command import BaseCommand, PlusAPIMixin
+from crewai_cli.config import Settings
+
+
+console = Console()
+
+
+class OrganizationCommand(BaseCommand, PlusAPIMixin):
+    def __init__(self) -> None:
+        BaseCommand.__init__(self)
+        PlusAPIMixin.__init__(self)
+
+    def list(self) -> None:
+        try:
+            response = self.plus_api_client.get_organizations()
+            response.raise_for_status()
+            orgs = response.json()
+
+            if not orgs:
+                console.print(
+                    "You don't belong to any organizations yet.", style="yellow"
+                )
+                return
+
+            table = Table(title="Your Organizations")
+            table.add_column("Name", style="cyan")
+            table.add_column("ID", style="green")
+            for org in orgs:
+                table.add_row(org["name"], org["uuid"])
+
+            console.print(table)
+        except HTTPStatusError as e:
+            if e.response.status_code == 401:
+                console.print(
+                    "You are not logged in to any organization. Use 'crewai login' to login.",
+                    style="bold red",
+                )
+                return
+            console.print(
+                f"Failed to retrieve organization list: {e!s}", style="bold red"
+            )
+            raise SystemExit(1) from e
+        except Exception as e:
+            console.print(
+                f"Failed to retrieve organization list: {e!s}", style="bold red"
+            )
+            raise SystemExit(1) from e
+
+    def switch(self, org_id: str) -> None:
+        try:
+            response = self.plus_api_client.get_organizations()
+            response.raise_for_status()
+            orgs = response.json()
+
+            org = next((o for o in orgs if o["uuid"] == org_id), None)
+            if not org:
+                console.print(
+                    f"Organization with id '{org_id}' not found.", style="bold red"
+                )
+                return
+
+            settings = Settings()
+            settings.org_name = org["name"]
+            settings.org_uuid = org["uuid"]
+            settings.dump()
+
+            console.print(
+                f"Successfully switched to {org['name']} ({org['uuid']})",
+                style="bold green",
+            )
+        except HTTPStatusError as e:
+            if e.response.status_code == 401:
+                console.print(
+                    "You are not logged in to any organization. Use 'crewai login' to login.",
+                    style="bold red",
+                )
+                return
+            console.print(
+                f"Failed to retrieve organization list: {e!s}", style="bold red"
+            )
+            raise SystemExit(1) from e
+        except Exception as e:
+            console.print(f"Failed to switch organization: {e!s}", style="bold red")
+            raise SystemExit(1) from e
+
+    def current(self) -> None:
+        settings = Settings()
+        if settings.org_uuid:
+            console.print(
+                f"Currently logged in to organization {settings.org_name} ({settings.org_uuid})",
+                style="bold green",
+            )
+        else:
+            console.print(
+                "You're not currently logged in to any organization.", style="yellow"
+            )
+            console.print(
+                "Use 'crewai org list' to see available organizations.", style="yellow"
+            )
+            console.print(
+                "Use 'crewai org switch <id>' to switch to an organization.",
+                style="yellow",
+            )

lib/cli/src/crewai_cli/plot_flow.py

@@ -0,0 +1,23 @@
+import subprocess
+
+import click
+
+
+def plot_flow() -> None:
+    """
+    Plot the flow by running a command in the UV environment.
+    """
+    command = ["uv", "run", "plot"]
+
+    try:
+        result = subprocess.run(command, capture_output=False, text=True, check=True)  # noqa: S603
+
+        if result.stderr:
+            click.echo(result.stderr, err=True)
+
+    except subprocess.CalledProcessError as e:
+        click.echo(f"An error occurred while plotting the flow: {e}", err=True)
+        click.echo(e.output, err=True)
+
+    except Exception as e:
+        click.echo(f"An unexpected error occurred: {e}", err=True)

lib/cli/src/crewai_cli/plus_api.py

@@ -0,0 +1,210 @@
+import os
+from typing import Any
+from urllib.parse import urljoin
+
+import httpx
+
+from crewai_cli.config import Settings
+from crewai_cli.constants import DEFAULT_CREWAI_ENTERPRISE_URL
+from crewai_cli.version import get_crewai_version
+
+
+class PlusAPI:
+    """
+    This class exposes methods for working with the CrewAI+ API.
+    """
+
+    TOOLS_RESOURCE = "/crewai_plus/api/v1/tools"
+    ORGANIZATIONS_RESOURCE = "/crewai_plus/api/v1/me/organizations"
+    CREWS_RESOURCE = "/crewai_plus/api/v1/crews"
+    AGENTS_RESOURCE = "/crewai_plus/api/v1/agents"
+    TRACING_RESOURCE = "/crewai_plus/api/v1/tracing"
+    EPHEMERAL_TRACING_RESOURCE = "/crewai_plus/api/v1/tracing/ephemeral"
+    INTEGRATIONS_RESOURCE = "/crewai_plus/api/v1/integrations"
+
+    def __init__(self, api_key: str) -> None:
+        self.api_key = api_key
+        self.headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+            "User-Agent": f"CrewAI-CLI/{get_crewai_version()}",
+            "X-Crewai-Version": get_crewai_version(),
+        }
+        settings = Settings()
+        if settings.org_uuid:
+            self.headers["X-Crewai-Organization-Id"] = settings.org_uuid
+
+        self.base_url = (
+            os.getenv("CREWAI_PLUS_URL")
+            or str(settings.enterprise_base_url)
+            or DEFAULT_CREWAI_ENTERPRISE_URL
+        )
+
+    def _make_request(
+        self, method: str, endpoint: str, **kwargs: Any
+    ) -> httpx.Response:
+        url = urljoin(self.base_url, endpoint)
+        verify = kwargs.pop("verify", True)
+        with httpx.Client(trust_env=False, verify=verify) as client:
+            return client.request(method, url, headers=self.headers, **kwargs)
+
+    def login_to_tool_repository(self) -> httpx.Response:
+        return self._make_request("POST", f"{self.TOOLS_RESOURCE}/login")
+
+    def get_tool(self, handle: str) -> httpx.Response:
+        return self._make_request("GET", f"{self.TOOLS_RESOURCE}/{handle}")
+
+    async def get_agent(self, handle: str) -> httpx.Response:
+        url = urljoin(self.base_url, f"{self.AGENTS_RESOURCE}/{handle}")
+        async with httpx.AsyncClient() as client:
+            return await client.get(url, headers=self.headers)
+
+    def publish_tool(
+        self,
+        handle: str,
+        is_public: bool,
+        version: str,
+        description: str | None,
+        encoded_file: str,
+        available_exports: list[dict[str, Any]] | None = None,
+    ) -> httpx.Response:
+        params = {
+            "handle": handle,
+            "public": is_public,
+            "version": version,
+            "file": encoded_file,
+            "description": description,
+            "available_exports": available_exports,
+        }
+        return self._make_request("POST", f"{self.TOOLS_RESOURCE}", json=params)
+
+    def deploy_by_name(self, project_name: str) -> httpx.Response:
+        return self._make_request(
+            "POST", f"{self.CREWS_RESOURCE}/by-name/{project_name}/deploy"
+        )
+
+    def deploy_by_uuid(self, uuid: str) -> httpx.Response:
+        return self._make_request("POST", f"{self.CREWS_RESOURCE}/{uuid}/deploy")
+
+    def crew_status_by_name(self, project_name: str) -> httpx.Response:
+        return self._make_request(
+            "GET", f"{self.CREWS_RESOURCE}/by-name/{project_name}/status"
+        )
+
+    def crew_status_by_uuid(self, uuid: str) -> httpx.Response:
+        return self._make_request("GET", f"{self.CREWS_RESOURCE}/{uuid}/status")
+
+    def crew_by_name(
+        self, project_name: str, log_type: str = "deployment"
+    ) -> httpx.Response:
+        return self._make_request(
+            "GET", f"{self.CREWS_RESOURCE}/by-name/{project_name}/logs/{log_type}"
+        )
+
+    def crew_by_uuid(self, uuid: str, log_type: str = "deployment") -> httpx.Response:
+        return self._make_request(
+            "GET", f"{self.CREWS_RESOURCE}/{uuid}/logs/{log_type}"
+        )
+
+    def delete_crew_by_name(self, project_name: str) -> httpx.Response:
+        return self._make_request(
+            "DELETE", f"{self.CREWS_RESOURCE}/by-name/{project_name}"
+        )
+
+    def delete_crew_by_uuid(self, uuid: str) -> httpx.Response:
+        return self._make_request("DELETE", f"{self.CREWS_RESOURCE}/{uuid}")
+
+    def list_crews(self) -> httpx.Response:
+        return self._make_request("GET", self.CREWS_RESOURCE)
+
+    def create_crew(self, payload: dict[str, Any]) -> httpx.Response:
+        return self._make_request("POST", self.CREWS_RESOURCE, json=payload)
+
+    def get_organizations(self) -> httpx.Response:
+        return self._make_request("GET", self.ORGANIZATIONS_RESOURCE)
+
+    def initialize_trace_batch(self, payload: dict[str, Any]) -> httpx.Response:
+        return self._make_request(
+            "POST",
+            f"{self.TRACING_RESOURCE}/batches",
+            json=payload,
+            timeout=30,
+        )
+
+    def initialize_ephemeral_trace_batch(
+        self, payload: dict[str, Any]
+    ) -> httpx.Response:
+        return self._make_request(
+            "POST",
+            f"{self.EPHEMERAL_TRACING_RESOURCE}/batches",
+            json=payload,
+        )
+
+    def send_trace_events(
+        self, trace_batch_id: str, payload: dict[str, Any]
+    ) -> httpx.Response:
+        return self._make_request(
+            "POST",
+            f"{self.TRACING_RESOURCE}/batches/{trace_batch_id}/events",
+            json=payload,
+            timeout=30,
+        )
+
+    def send_ephemeral_trace_events(
+        self, trace_batch_id: str, payload: dict[str, Any]
+    ) -> httpx.Response:
+        return self._make_request(
+            "POST",
+            f"{self.EPHEMERAL_TRACING_RESOURCE}/batches/{trace_batch_id}/events",
+            json=payload,
+            timeout=30,
+        )
+
+    def finalize_trace_batch(
+        self, trace_batch_id: str, payload: dict[str, Any]
+    ) -> httpx.Response:
+        return self._make_request(
+            "PATCH",
+            f"{self.TRACING_RESOURCE}/batches/{trace_batch_id}/finalize",
+            json=payload,
+            timeout=30,
+        )
+
+    def finalize_ephemeral_trace_batch(
+        self, trace_batch_id: str, payload: dict[str, Any]
+    ) -> httpx.Response:
+        return self._make_request(
+            "PATCH",
+            f"{self.EPHEMERAL_TRACING_RESOURCE}/batches/{trace_batch_id}/finalize",
+            json=payload,
+            timeout=30,
+        )
+
+    def mark_trace_batch_as_failed(
+        self, trace_batch_id: str, error_message: str
+    ) -> httpx.Response:
+        return self._make_request(
+            "PATCH",
+            f"{self.TRACING_RESOURCE}/batches/{trace_batch_id}",
+            json={"status": "failed", "failure_reason": error_message},
+            timeout=30,
+        )
+
+    def get_mcp_configs(self, slugs: list[str]) -> httpx.Response:
+        """Get MCP server configurations for the given slugs."""
+        return self._make_request(
+            "GET",
+            f"{self.INTEGRATIONS_RESOURCE}/mcp_configs",
+            params={"slugs": ",".join(slugs)},
+            timeout=30,
+        )
+
+    def get_triggers(self) -> httpx.Response:
+        """Get all available triggers from integrations."""
+        return self._make_request("GET", f"{self.INTEGRATIONS_RESOURCE}/apps")
+
+    def get_trigger_payload(self, app_slug: str, trigger_slug: str) -> httpx.Response:
+        """Get sample payload for a specific trigger."""
+        return self._make_request(
+            "GET", f"{self.INTEGRATIONS_RESOURCE}/{app_slug}/{trigger_slug}/payload"
+        )

lib/cli/src/crewai_cli/provider.py

@@ -0,0 +1,231 @@
+from collections import defaultdict
+from collections.abc import Sequence
+import json
+import os
+from pathlib import Path
+import time
+from typing import Any
+
+import certifi
+import click
+import httpx
+
+from crewai_cli.constants import JSON_URL, MODELS, PROVIDERS
+
+
+def select_choice(prompt_message: str, choices: Sequence[str]) -> str | None:
+    """Presents a list of choices to the user and prompts them to select one.
+
+    Args:
+        prompt_message: The message to display to the user before presenting the choices.
+        choices: A list of options to present to the user.
+
+    Returns:
+        The selected choice from the list, or None if the user chooses to quit.
+    """
+
+    provider_models = get_provider_data()
+    if not provider_models:
+        return None
+    click.secho(prompt_message, fg="cyan")
+    for idx, choice in enumerate(choices, start=1):
+        click.secho(f"{idx}. {choice}", fg="cyan")
+    click.secho("q. Quit", fg="cyan")
+
+    while True:
+        choice = click.prompt(
+            "Enter the number of your choice or 'q' to quit", type=str
+        )
+
+        if choice.lower() == "q":
+            return None
+
+        try:
+            selected_index = int(choice) - 1
+            if 0 <= selected_index < len(choices):
+                return choices[selected_index]
+        except ValueError:
+            pass
+
+        click.secho(
+            "Invalid selection. Please select a number between 1 and 6 or 'q' to quit.",
+            fg="red",
+        )
+
+
+def select_provider(provider_models: dict[str, list[str]]) -> str | None | bool:
+    """Presents a list of providers to the user and prompts them to select one.
+
+    Args:
+        provider_models: A dictionary of provider models.
+
+    Returns:
+        The selected provider, None if user explicitly quits, or False if no selection.
+    """
+    predefined_providers = [p.lower() for p in PROVIDERS]
+    all_providers = sorted(set(predefined_providers + list(provider_models.keys())))
+
+    provider = select_choice(
+        "Select a provider to set up:", [*predefined_providers, "other"]
+    )
+    if provider is None:  # User typed 'q'
+        return None
+
+    if provider == "other":
+        provider = select_choice("Select a provider from the full list:", all_providers)
+        if provider is None:  # User typed 'q'
+            return None
+
+    return provider.lower() if provider else False
+
+
+def select_model(provider: str, provider_models: dict[str, list[str]]) -> str | None:
+    """Presents a list of models for a given provider to the user and prompts them to select one.
+
+    Args:
+        provider: The provider for which to select a model.
+        provider_models: A dictionary of provider models.
+
+    Returns:
+        The selected model, or None if the operation is aborted or an invalid selection is made.
+    """
+    predefined_providers = [p.lower() for p in PROVIDERS]
+
+    if provider in predefined_providers:
+        available_models = MODELS.get(provider, [])
+    else:
+        available_models = provider_models.get(provider, [])
+
+    if not available_models:
+        click.secho(f"No models available for provider '{provider}'.", fg="red")
+        return None
+
+    return select_choice(
+        f"Select a model to use for {provider.capitalize()}:", available_models
+    )
+
+
+def load_provider_data(cache_file: Path, cache_expiry: int) -> dict[str, Any] | None:
+    """Loads provider data from a cache file if it exists and is not expired.
+
+    If the cache is expired or corrupted, it fetches the data from the web.
+
+    Args:
+        cache_file: The path to the cache file.
+        cache_expiry: The cache expiry time in seconds.
+
+    Returns:
+        The loaded provider data or None if the operation fails.
+    """
+    current_time = time.time()
+    if (
+        cache_file.exists()
+        and (current_time - cache_file.stat().st_mtime) < cache_expiry
+    ):
+        data = read_cache_file(cache_file)
+        if data:
+            return data
+        click.secho(
+            "Cache is corrupted. Fetching provider data from the web...", fg="yellow"
+        )
+    else:
+        click.secho(
+            "Cache expired or not found. Fetching provider data from the web...",
+            fg="cyan",
+        )
+    return fetch_provider_data(cache_file)
+
+
+def read_cache_file(cache_file: Path) -> dict[str, Any] | None:
+    """Reads and returns the JSON content from a cache file.
+
+    Args:
+        cache_file: The path to the cache file.
+
+    Returns:
+        The JSON content of the cache file or None if the JSON is invalid.
+    """
+    try:
+        with open(cache_file, "r") as f:
+            data: dict[str, Any] = json.load(f)
+            return data
+    except json.JSONDecodeError:
+        return None
+
+
+def fetch_provider_data(cache_file: Path) -> dict[str, Any] | None:
+    """Fetches provider data from a specified URL and caches it to a file.
+
+    Args:
+        cache_file: The path to the cache file.
+
+    Returns:
+        The fetched provider data or None if the operation fails.
+    """
+    ssl_config = os.environ["SSL_CERT_FILE"] = certifi.where()
+
+    try:
+        with httpx.stream("GET", JSON_URL, timeout=60, verify=ssl_config) as response:
+            response.raise_for_status()
+            data = download_data(response)
+            with open(cache_file, "w") as f:
+                json.dump(data, f)
+            return data
+    except httpx.HTTPError as e:
+        click.secho(f"Error fetching provider data: {e}", fg="red")
+    except json.JSONDecodeError:
+        click.secho("Error parsing provider data. Invalid JSON format.", fg="red")
+    return None
+
+
+def download_data(response: httpx.Response) -> dict[str, Any]:
+    """Downloads data from a given HTTP response and returns the JSON content.
+
+    Args:
+        response: The HTTP response object.
+
+    Returns:
+        The JSON content of the response.
+    """
+    total_size = int(response.headers.get("content-length", 0))
+    block_size = 8192
+    data_chunks: list[bytes] = []
+    bar: Any
+    with click.progressbar(
+        length=total_size, label="Downloading", show_pos=True
+    ) as bar:
+        for chunk in response.iter_bytes(block_size):
+            if chunk:
+                data_chunks.append(chunk)
+                bar.update(len(chunk))
+    data_content = b"".join(data_chunks)
+    result: dict[str, Any] = json.loads(data_content.decode("utf-8"))
+    return result
+
+
+def get_provider_data() -> dict[str, list[str]] | None:
+    """Retrieves provider data from a cache file.
+
+    Filters out models based on provider criteria, and returns a dictionary of providers
+    mapped to their models.
+
+    Returns:
+        A dictionary of providers mapped to their models or None if the operation fails.
+    """
+    cache_dir = Path.home() / ".crewai"
+    cache_dir.mkdir(exist_ok=True)
+    cache_file = cache_dir / "provider_cache.json"
+    cache_expiry = 24 * 3600
+
+    data = load_provider_data(cache_file, cache_expiry)
+    if not data:
+        return None
+
+    provider_models = defaultdict(list)
+    for model_name, properties in data.items():
+        provider = properties.get("litellm_provider", "").strip().lower()
+        if "http" in provider or provider == "other":
+            continue
+        if provider:
+            provider_models[provider].append(model_name)
+    return provider_models

lib/cli/src/crewai_cli/replay_from_task.py

@@ -0,0 +1,25 @@
+import subprocess
+
+import click
+
+
+def replay_task_command(task_id: str) -> None:
+    """
+    Replay the crew execution from a specific task.
+
+    Args:
+      task_id (str): The ID of the task to replay from.
+    """
+    command = ["uv", "run", "replay", task_id]
+
+    try:
+        result = subprocess.run(command, capture_output=False, text=True, check=True)  # noqa: S603
+        if result.stderr:
+            click.echo(result.stderr, err=True)
+
+    except subprocess.CalledProcessError as e:
+        click.echo(f"An error occurred while replaying the task: {e}", err=True)
+        click.echo(e.output, err=True)
+
+    except Exception as e:
+        click.echo(f"An unexpected error occurred: {e}", err=True)

lib/cli/src/crewai_cli/reset_memories_command.py

@@ -0,0 +1,31 @@
+"""Wrapper for the reset-memories command.
+
+Delegates to ``crewai.cli.reset_memories_command`` when the full crewai
+package is installed, otherwise prints a helpful error message.
+"""
+
+from __future__ import annotations
+
+import click
+
+
+def reset_memories_command(
+    memory: bool,
+    knowledge: bool,
+    agent_knowledge: bool,
+    kickoff_outputs: bool,
+    all: bool,
+) -> None:
+    try:
+        from crewai.cli.reset_memories_command import (
+            reset_memories_command as _reset,
+        )
+    except ImportError:
+        click.secho(
+            "The 'reset-memories' command requires the full crewai package.\n"
+            "Install it with: pip install crewai",
+            fg="red",
+        )
+        raise SystemExit(1) from None
+
+    _reset(memory, knowledge, agent_knowledge, kickoff_outputs, all)

lib/cli/src/crewai_cli/run_crew.py

@@ -0,0 +1,103 @@
+from enum import Enum
+import os
+import subprocess
+
+import click
+from packaging import version
+
+from crewai_cli.utils import build_env_with_tool_repository_credentials, read_toml
+from crewai_cli.version import get_crewai_version
+
+
+class CrewType(Enum):
+    STANDARD = "standard"
+    FLOW = "flow"
+
+
+def run_crew() -> None:
+    """
+    Run the crew or flow by running a command in the UV environment.
+
+    Starting from version 0.103.0, this command can be used to run both
+    standard crews and flows. For flows, it detects the type from pyproject.toml
+    and automatically runs the appropriate command.
+    """
+    crewai_version = get_crewai_version()
+    min_required_version = "0.71.0"
+    pyproject_data = read_toml()
+
+    # Check for legacy poetry configuration
+    if pyproject_data.get("tool", {}).get("poetry") and (
+        version.parse(crewai_version) < version.parse(min_required_version)
+    ):
+        click.secho(
+            f"You are running an older version of crewAI ({crewai_version}) that uses poetry pyproject.toml. "
+            f"Please run `crewai update` to update your pyproject.toml to use uv.",
+            fg="red",
+        )
+
+    # Determine crew type
+    is_flow = pyproject_data.get("tool", {}).get("crewai", {}).get("type") == "flow"
+    crew_type = CrewType.FLOW if is_flow else CrewType.STANDARD
+
+    # Display appropriate message
+    click.echo(f"Running the {'Flow' if is_flow else 'Crew'}")
+
+    # Execute the appropriate command
+    execute_command(crew_type)
+
+
+def execute_command(crew_type: CrewType) -> None:
+    """
+    Execute the appropriate command based on crew type.
+
+    Args:
+        crew_type: The type of crew to run
+    """
+    command = ["uv", "run", "kickoff" if crew_type == CrewType.FLOW else "run_crew"]
+
+    env = os.environ.copy()
+    try:
+        pyproject_data = read_toml()
+        sources = pyproject_data.get("tool", {}).get("uv", {}).get("sources", {})
+
+        for source_config in sources.values():
+            if isinstance(source_config, dict):
+                index = source_config.get("index")
+                if index:
+                    index_env = build_env_with_tool_repository_credentials(index)
+                    env.update(index_env)
+    except Exception:  # noqa: S110
+        pass
+
+    try:
+        subprocess.run(command, capture_output=False, text=True, check=True, env=env)  # noqa: S603
+
+    except subprocess.CalledProcessError as e:
+        handle_error(e, crew_type)
+
+    except Exception as e:
+        click.echo(f"An unexpected error occurred: {e}", err=True)
+
+
+def handle_error(error: subprocess.CalledProcessError, crew_type: CrewType) -> None:
+    """
+    Handle subprocess errors with appropriate messaging.
+
+    Args:
+        error: The subprocess error that occurred
+        crew_type: The type of crew that was being run
+    """
+    entity_type = "flow" if crew_type == CrewType.FLOW else "crew"
+    click.echo(f"An error occurred while running the {entity_type}: {error}", err=True)
+
+    if error.output:
+        click.echo(error.output, err=True, nl=True)
+
+    pyproject_data = read_toml()
+    if pyproject_data.get("tool", {}).get("poetry"):
+        click.secho(
+            "It's possible that you are using an old version of crewAI that uses poetry, "
+            "please run `crewai update` to update your pyproject.toml to use uv.",
+            fg="yellow",
+        )

lib/cli/src/crewai_cli/settings/main.py

@@ -0,0 +1,110 @@
+from datetime import datetime
+import os
+from typing import Any
+
+from rich.console import Console
+from rich.table import Table
+
+from crewai_cli.command import BaseCommand
+from crewai_cli.config import HIDDEN_SETTINGS_KEYS, READONLY_SETTINGS_KEYS, Settings
+from crewai_cli.user_data import _load_user_data
+
+
+console = Console()
+
+
+class SettingsCommand(BaseCommand):
+    """A class to handle CLI configuration commands."""
+
+    def __init__(self, settings_kwargs: dict[str, Any] | None = None):
+        super().__init__()
+        settings_kwargs = settings_kwargs or {}
+        self.settings = Settings(**settings_kwargs)
+
+    def list(self) -> None:
+        """List all CLI configuration parameters."""
+        table = Table(title="CrewAI CLI Configuration")
+        table.add_column("Setting", style="cyan", no_wrap=True)
+        table.add_column("Value", style="green")
+        table.add_column("Description", style="yellow")
+
+        # Add all settings to the table
+        for field_name, field_info in Settings.model_fields.items():
+            if field_name in HIDDEN_SETTINGS_KEYS:
+                # Do not display hidden settings
+                continue
+
+            current_value = getattr(self.settings, field_name)
+            description = field_info.description or "No description available"
+            display_value = (
+                str(current_value) if current_value not in [None, {}] else "Not set"
+            )
+
+            table.add_row(field_name, display_value, description)
+
+        # Add trace-related settings from user data
+        user_data = _load_user_data()
+
+        # CREWAI_TRACING_ENABLED environment variable
+        env_tracing = os.getenv("CREWAI_TRACING_ENABLED", "")
+        env_tracing_display = env_tracing if env_tracing else "Not set"
+        table.add_row(
+            "CREWAI_TRACING_ENABLED",
+            env_tracing_display,
+            "Environment variable to enable/disable tracing",
+        )
+
+        # Trace consent status
+        trace_consent = user_data.get("trace_consent")
+        if trace_consent is True:
+            consent_display = "✅ Enabled"
+        elif trace_consent is False:
+            consent_display = "❌ Disabled"
+        else:
+            consent_display = "Not set"
+        table.add_row(
+            "trace_consent", consent_display, "Whether trace collection is enabled"
+        )
+
+        # First execution timestamp
+        if user_data.get("first_execution_at"):
+            timestamp = datetime.fromtimestamp(user_data["first_execution_at"])
+            first_exec_display = timestamp.strftime("%Y-%m-%d %H:%M:%S")
+        else:
+            first_exec_display = "Not set"
+        table.add_row(
+            "first_execution_at",
+            first_exec_display,
+            "Timestamp of first crew/flow execution",
+        )
+
+        console.print(table)
+
+    def set(self, key: str, value: str) -> None:
+        """Set a CLI configuration parameter."""
+
+        readonly_settings = READONLY_SETTINGS_KEYS + HIDDEN_SETTINGS_KEYS
+
+        if not hasattr(self.settings, key) or key in readonly_settings:
+            console.print(
+                f"Error: Unknown or readonly configuration key '{key}'",
+                style="bold red",
+            )
+            console.print("Available keys:", style="yellow")
+            for field_name in Settings.model_fields.keys():
+                if field_name not in readonly_settings:
+                    console.print(f"  - {field_name}", style="yellow")
+            raise SystemExit(1)
+
+        setattr(self.settings, key, value)
+        self.settings.dump()
+
+        console.print(f"Successfully set '{key}' to '{value}'", style="bold green")
+
+    def reset_all_settings(self) -> None:
+        """Reset all CLI configuration parameters to default values."""
+        self.settings.reset()
+        console.print(
+            "Successfully reset all configuration parameters to default values. It is recommended to run [bold yellow]'crewai login'[/bold yellow] to re-authenticate.",
+            style="bold green",
+        )

lib/cli/src/crewai_cli/shared/token_manager.py

@@ -0,0 +1,186 @@
+from datetime import datetime
+import json
+import os
+from pathlib import Path
+import sys
+import tempfile
+from typing import Final, Literal, cast
+
+from cryptography.fernet import Fernet
+
+
+_FERNET_KEY_LENGTH: Final[Literal[44]] = 44
+
+
+class TokenManager:
+    """Manages encrypted token storage."""
+
+    def __init__(self, file_path: str = "tokens.enc") -> None:
+        """Initialize the TokenManager.
+
+        Args:
+            file_path: The file path to store encrypted tokens.
+        """
+        self.file_path = file_path
+        self.key = self._get_or_create_key()
+        self.fernet = Fernet(self.key)
+
+    def _get_or_create_key(self) -> bytes:
+        """Get or create the encryption key.
+
+        Returns:
+            The encryption key as bytes.
+        """
+        key_filename: str = "secret.key"
+
+        key = self._read_secure_file(key_filename)
+        if key is not None and len(key) == _FERNET_KEY_LENGTH:
+            return key
+
+        new_key = Fernet.generate_key()
+        if self._atomic_create_secure_file(key_filename, new_key):
+            return new_key
+
+        key = self._read_secure_file(key_filename)
+        if key is not None and len(key) == _FERNET_KEY_LENGTH:
+            return key
+
+        raise RuntimeError("Failed to create or read encryption key")
+
+    def save_tokens(self, access_token: str, expires_at: int) -> None:
+        """Save the access token and its expiration time.
+
+        Args:
+            access_token: The access token to save.
+            expires_at: The UNIX timestamp of the expiration time.
+        """
+        expiration_time = datetime.fromtimestamp(expires_at)
+        data = {
+            "access_token": access_token,
+            "expiration": expiration_time.isoformat(),
+        }
+        encrypted_data = self.fernet.encrypt(json.dumps(data).encode())
+        self._atomic_write_secure_file(self.file_path, encrypted_data)
+
+    def get_token(self) -> str | None:
+        """Get the access token if it is valid and not expired.
+
+        Returns:
+            The access token if valid and not expired, otherwise None.
+        """
+        encrypted_data = self._read_secure_file(self.file_path)
+        if encrypted_data is None:
+            return None
+
+        decrypted_data = self.fernet.decrypt(encrypted_data)
+        data = json.loads(decrypted_data)
+
+        expiration = datetime.fromisoformat(data["expiration"])
+        if expiration <= datetime.now():
+            return None
+
+        return cast(str | None, data.get("access_token"))
+
+    def clear_tokens(self) -> None:
+        """Clear the stored tokens."""
+        self._delete_secure_file(self.file_path)
+
+    @staticmethod
+    def _get_secure_storage_path() -> Path:
+        """Get the secure storage path based on the operating system.
+
+        Returns:
+            The secure storage path.
+        """
+        if sys.platform == "win32":
+            base_path = os.environ.get("LOCALAPPDATA")
+        elif sys.platform == "darwin":
+            base_path = os.path.expanduser("~/Library/Application Support")
+        else:
+            base_path = os.path.expanduser("~/.local/share")
+
+        app_name = "crewai/credentials"
+        storage_path = Path(base_path) / app_name
+
+        storage_path.mkdir(parents=True, exist_ok=True)
+
+        return storage_path
+
+    def _atomic_create_secure_file(self, filename: str, content: bytes) -> bool:
+        """Create a file only if it doesn't exist.
+
+        Args:
+            filename: The name of the file.
+            content: The content to write.
+
+        Returns:
+            True if file was created, False if it already exists.
+        """
+        storage_path = self._get_secure_storage_path()
+        file_path = storage_path / filename
+
+        try:
+            fd = os.open(file_path, os.O_CREAT | os.O_EXCL | os.O_WRONLY, 0o600)
+            try:
+                os.write(fd, content)
+            finally:
+                os.close(fd)
+            return True
+        except FileExistsError:
+            return False
+
+    def _atomic_write_secure_file(self, filename: str, content: bytes) -> None:
+        """Write content to a secure file.
+
+        Args:
+            filename: The name of the file.
+            content: The content to write.
+        """
+        storage_path = self._get_secure_storage_path()
+        file_path = storage_path / filename
+
+        fd, temp_path = tempfile.mkstemp(dir=storage_path, prefix=f".{filename}.")
+        fd_closed = False
+        try:
+            os.write(fd, content)
+            os.close(fd)
+            fd_closed = True
+            os.chmod(temp_path, 0o600)
+            os.replace(temp_path, file_path)
+        except Exception:
+            if not fd_closed:
+                os.close(fd)
+            if os.path.exists(temp_path):
+                os.unlink(temp_path)
+            raise
+
+    def _read_secure_file(self, filename: str) -> bytes | None:
+        """Read the content of a secure file.
+
+        Args:
+            filename: The name of the file.
+
+        Returns:
+            The content of the file if it exists, otherwise None.
+        """
+        storage_path = self._get_secure_storage_path()
+        file_path = storage_path / filename
+
+        try:
+            with open(file_path, "rb") as f:
+                return f.read()
+        except FileNotFoundError:
+            return None
+
+    def _delete_secure_file(self, filename: str) -> None:
+        """Delete a secure file.
+
+        Args:
+            filename: The name of the file.
+        """
+        storage_path = self._get_secure_storage_path()
+        file_path = storage_path / filename
+        try:
+            file_path.unlink()
+        except FileNotFoundError:
+            pass

lib/cli/src/crewai_cli/task_outputs.py

@@ -0,0 +1,54 @@
+"""Lightweight SQLite reader for kickoff task outputs.
+
+Only used by the ``crewai log-tasks-outputs`` CLI command.  Depends solely on
+the standard library + *appdirs* so crewai-cli can read stored outputs without
+importing the full crewai framework.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+import sqlite3
+from typing import Any
+
+from crewai_cli.user_data import _db_storage_path
+
+
+logger = logging.getLogger(__name__)
+
+
+def load_task_outputs(db_path: str | None = None) -> list[dict[str, Any]]:
+    """Return all rows from the kickoff task outputs database."""
+    if db_path is None:
+        db_path = str(Path(_db_storage_path()) / "latest_kickoff_task_outputs.db")
+
+    if not Path(db_path).exists():
+        return []
+
+    try:
+        with sqlite3.connect(db_path) as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                SELECT *
+                FROM latest_kickoff_task_outputs
+                ORDER BY task_index
+            """)
+            rows = cursor.fetchall()
+            results: list[dict[str, Any]] = [
+                {
+                    "task_id": row[0],
+                    "expected_output": row[1],
+                    "output": json.loads(row[2]),
+                    "task_index": row[3],
+                    "inputs": json.loads(row[4]),
+                    "was_replayed": row[5],
+                    "timestamp": row[6],
+                }
+                for row in rows
+            ]
+            return results
+    except sqlite3.Error as e:
+        logger.error("Failed to load task outputs: %s", e)
+        return []

lib/cli/src/crewai_cli/templates/crew/.gitignore

@@ -0,0 +1,3 @@
+.env
+__pycache__/
+.DS_Store

lib/cli/src/crewai_cli/templates/crew/README.md

@@ -0,0 +1,54 @@
+# {{crew_name}} Crew
+
+Welcome to the {{crew_name}} Crew project, powered by [crewAI](https://crewai.com). This template is designed to help you set up a multi-agent AI system with ease, leveraging the powerful and flexible framework provided by crewAI. Our goal is to enable your agents to collaborate effectively on complex tasks, maximizing their collective intelligence and capabilities.
+
+## Installation
+
+Ensure you have Python >=3.10 <3.14 installed on your system. This project uses [UV](https://docs.astral.sh/uv/) for dependency management and package handling, offering a seamless setup and execution experience.
+
+First, if you haven't already, install uv:
+
+```bash
+pip install uv
+```
+
+Next, navigate to your project directory and install the dependencies:
+
+(Optional) Lock the dependencies and install them by using the CLI command:
+```bash
+crewai install
+```
+### Customizing
+
+**Add your `OPENAI_API_KEY` into the `.env` file**
+
+- Modify `src/{{folder_name}}/config/agents.yaml` to define your agents
+- Modify `src/{{folder_name}}/config/tasks.yaml` to define your tasks
+- Modify `src/{{folder_name}}/crew.py` to add your own logic, tools and specific args
+- Modify `src/{{folder_name}}/main.py` to add custom inputs for your agents and tasks
+
+## Running the Project
+
+To kickstart your crew of AI agents and begin task execution, run this from the root folder of your project:
+
+```bash
+$ crewai run
+```
+
+This command initializes the {{name}} Crew, assembling the agents and assigning them tasks as defined in your configuration.
+
+This example, unmodified, will run the create a `report.md` file with the output of a research on LLMs in the root folder.
+
+## Understanding Your Crew
+
+The {{name}} Crew is composed of multiple AI agents, each with unique roles, goals, and tools. These agents collaborate on a series of tasks, defined in `config/tasks.yaml`, leveraging their collective skills to achieve complex objectives. The `config/agents.yaml` file outlines the capabilities and configurations of each agent in your crew.
+
+## Support
+
+For support, questions, or feedback regarding the {{crew_name}} Crew or crewAI.
+- Visit our [documentation](https://docs.crewai.com)
+- Reach out to us through our [GitHub repository](https://github.com/joaomdmoura/crewai)
+- [Join our Discord](https://discord.com/invite/X4JWnZnxPb)
+- [Chat with our docs](https://chatg.pt/DWjSBZn)
+
+Let's create wonders together with the power and simplicity of crewAI.

lib/cli/src/crewai_cli/templates/crew/config/agents.yaml

@@ -0,0 +1,19 @@
+researcher:
+  role: >
+    {topic} Senior Data Researcher
+  goal: >
+    Uncover cutting-edge developments in {topic}
+  backstory: >
+    You're a seasoned researcher with a knack for uncovering the latest
+    developments in {topic}. Known for your ability to find the most relevant
+    information and present it in a clear and concise manner.
+
+reporting_analyst:
+  role: >
+    {topic} Reporting Analyst
+  goal: >
+    Create detailed reports based on {topic} data analysis and research findings
+  backstory: >
+    You're a meticulous analyst with a keen eye for detail. You're known for
+    your ability to turn complex data into clear and concise reports, making
+    it easy for others to understand and act on the information you provide.

lib/cli/src/crewai_cli/templates/crew/config/tasks.yaml

@@ -0,0 +1,17 @@
+research_task:
+  description: >
+    Conduct a thorough research about {topic}
+    Make sure you find any interesting and relevant information given
+    the current year is {current_year}.
+  expected_output: >
+    A list with 10 bullet points of the most relevant information about {topic}
+  agent: researcher
+
+reporting_task:
+  description: >
+    Review the context you got and expand each topic into a full section for a report.
+    Make sure the report is detailed and contains any and all relevant information.
+  expected_output: >
+    A fully fledged report with the main topics, each with a full section of information.
+    Formatted as markdown without '```'
+  agent: reporting_analyst

lib/cli/src/crewai_cli/templates/crew/crew.py

@@ -0,0 +1,63 @@
+from crewai import Agent, Crew, Process, Task
+from crewai.project import CrewBase, agent, crew, task
+from crewai.agents.agent_builder.base_agent import BaseAgent
+# If you want to run a snippet of code before or after the crew starts,
+# you can use the @before_kickoff and @after_kickoff decorators
+# https://docs.crewai.com/concepts/crews#example-crew-class-with-decorators
+
+@CrewBase
+class {{crew_name}}():
+    """{{crew_name}} crew"""
+
+    agents: list[BaseAgent]
+    tasks: list[Task]
+
+    # Learn more about YAML configuration files here:
+    # Agents: https://docs.crewai.com/concepts/agents#yaml-configuration-recommended
+    # Tasks: https://docs.crewai.com/concepts/tasks#yaml-configuration-recommended
+    
+    # If you would like to add tools to your agents, you can learn more about it here:
+    # https://docs.crewai.com/concepts/agents#agent-tools
+    @agent
+    def researcher(self) -> Agent:
+        return Agent(
+            config=self.agents_config['researcher'], # type: ignore[index]
+            verbose=True
+        )
+
+    @agent
+    def reporting_analyst(self) -> Agent:
+        return Agent(
+            config=self.agents_config['reporting_analyst'], # type: ignore[index]
+            verbose=True
+        )
+
+    # To learn more about structured task outputs,
+    # task dependencies, and task callbacks, check out the documentation:
+    # https://docs.crewai.com/concepts/tasks#overview-of-a-task
+    @task
+    def research_task(self) -> Task:
+        return Task(
+            config=self.tasks_config['research_task'], # type: ignore[index]
+        )
+
+    @task
+    def reporting_task(self) -> Task:
+        return Task(
+            config=self.tasks_config['reporting_task'], # type: ignore[index]
+            output_file='report.md'
+        )
+
+    @crew
+    def crew(self) -> Crew:
+        """Creates the {{crew_name}} crew"""
+        # To learn how to add knowledge sources to your crew, check out the documentation:
+        # https://docs.crewai.com/concepts/knowledge#what-is-knowledge
+
+        return Crew(
+            agents=self.agents, # Automatically created by the @agent decorator
+            tasks=self.tasks, # Automatically created by the @task decorator
+            process=Process.sequential,
+            verbose=True,
+            # process=Process.hierarchical, # In case you wanna use that instead https://docs.crewai.com/how-to/Hierarchical/
+        )

lib/cli/src/crewai_cli/templates/crew/knowledge/user_preference.txt

@@ -0,0 +1,4 @@
+User name is John Doe.
+User is an AI Engineer.
+User is interested in AI Agents.
+User is based in San Francisco, California.

lib/cli/src/crewai_cli/templates/crew/main.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python
+import sys
+import warnings
+
+from datetime import datetime
+
+from {{folder_name}}.crew import {{crew_name}}
+
+warnings.filterwarnings("ignore", category=SyntaxWarning, module="pysbd")
+
+# This main file is intended to be a way for you to run your
+# crew locally, so refrain from adding unnecessary logic into this file.
+# Replace with inputs you want to test with, it will automatically
+# interpolate any tasks and agents information
+
+def run():
+    """
+    Run the crew.
+    """
+    inputs = {
+        'topic': 'AI LLMs',
+        'current_year': str(datetime.now().year)
+    }
+
+    try:
+        {{crew_name}}().crew().kickoff(inputs=inputs)
+    except Exception as e:
+        raise Exception(f"An error occurred while running the crew: {e}")
+
+
+def train():
+    """
+    Train the crew for a given number of iterations.
+    """
+    inputs = {
+        "topic": "AI LLMs",
+        'current_year': str(datetime.now().year)
+    }
+    try:
+        {{crew_name}}().crew().train(n_iterations=int(sys.argv[1]), filename=sys.argv[2], inputs=inputs)
+
+    except Exception as e:
+        raise Exception(f"An error occurred while training the crew: {e}")
+
+def replay():
+    """
+    Replay the crew execution from a specific task.
+    """
+    try:
+        {{crew_name}}().crew().replay(task_id=sys.argv[1])
+
+    except Exception as e:
+        raise Exception(f"An error occurred while replaying the crew: {e}")
+
+def test():
+    """
+    Test the crew execution and returns the results.
+    """
+    inputs = {
+        "topic": "AI LLMs",
+        "current_year": str(datetime.now().year)
+    }
+
+    try:
+        {{crew_name}}().crew().test(n_iterations=int(sys.argv[1]), eval_llm=sys.argv[2], inputs=inputs)
+
+    except Exception as e:
+        raise Exception(f"An error occurred while testing the crew: {e}")
+
+def run_with_trigger():
+    """
+    Run the crew with trigger payload.
+    """
+    import json
+
+    if len(sys.argv) < 2:
+        raise Exception("No trigger payload provided. Please provide JSON payload as argument.")
+
+    try:
+        trigger_payload = json.loads(sys.argv[1])
+    except json.JSONDecodeError:
+        raise Exception("Invalid JSON payload provided as argument")
+
+    inputs = {
+        "crewai_trigger_payload": trigger_payload,
+        "topic": "",
+        "current_year": ""
+    }
+
+    try:
+        result = {{crew_name}}().crew().kickoff(inputs=inputs)
+        return result
+    except Exception as e:
+        raise Exception(f"An error occurred while running the crew with trigger: {e}")

lib/cli/src/crewai_cli/templates/crew/pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "{{folder_name}}"
+version = "0.1.0"
+description = "{{name}} using crewAI"
+authors = [{ name = "Your Name", email = "you@example.com" }]
+requires-python = ">=3.10,<3.14"
+dependencies = [
+    "crewai[tools]==1.10.0"
+]
+
+[project.scripts]
+{{folder_name}} = "{{folder_name}}.main:run"
+run_crew = "{{folder_name}}.main:run"
+train = "{{folder_name}}.main:train"
+replay = "{{folder_name}}.main:replay"
+test = "{{folder_name}}.main:test"
+run_with_trigger = "{{folder_name}}.main:run_with_trigger"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.crewai]
+type = "crew"

lib/cli/src/crewai_cli/templates/crew/tools/custom_tool.py

@@ -0,0 +1,19 @@
+from crewai.tools import BaseTool
+from typing import Type
+from pydantic import BaseModel, Field
+
+
+class MyCustomToolInput(BaseModel):
+    """Input schema for MyCustomTool."""
+    argument: str = Field(..., description="Description of the argument.")
+
+class MyCustomTool(BaseTool):
+    name: str = "Name of my tool"
+    description: str = (
+        "Clear description for what this tool is useful for, your agent will need this information to use it."
+    )
+    args_schema: Type[BaseModel] = MyCustomToolInput
+
+    def _run(self, argument: str) -> str:
+        # Implementation goes here
+        return "this is an example of a tool output, ignore it and move along."

lib/cli/src/crewai_cli/templates/flow/.gitignore

@@ -0,0 +1,4 @@
+.env
+__pycache__/
+lib/
+.DS_Store

lib/cli/src/crewai_cli/templates/flow/README.md

@@ -0,0 +1,56 @@
+# {{crew_name}} Crew
+
+Welcome to the {{crew_name}} Crew project, powered by [crewAI](https://crewai.com). This template is designed to help you set up a multi-agent AI system with ease, leveraging the powerful and flexible framework provided by crewAI. Our goal is to enable your agents to collaborate effectively on complex tasks, maximizing their collective intelligence and capabilities.
+
+## Installation
+
+Ensure you have Python >=3.10 <3.14 installed on your system. This project uses [UV](https://docs.astral.sh/uv/) for dependency management and package handling, offering a seamless setup and execution experience.
+
+First, if you haven't already, install uv:
+
+```bash
+pip install uv
+```
+
+Next, navigate to your project directory and install the dependencies:
+
+(Optional) Lock the dependencies and install them by using the CLI command:
+```bash
+crewai install
+```
+
+### Customizing
+
+**Add your `OPENAI_API_KEY` into the `.env` file**
+
+- Modify `src/{{folder_name}}/config/agents.yaml` to define your agents
+- Modify `src/{{folder_name}}/config/tasks.yaml` to define your tasks
+- Modify `src/{{folder_name}}/crew.py` to add your own logic, tools and specific args
+- Modify `src/{{folder_name}}/main.py` to add custom inputs for your agents and tasks
+
+## Running the Project
+
+To kickstart your flow and begin execution, run this from the root folder of your project:
+
+```bash
+crewai run
+```
+
+This command initializes the {{name}} Flow as defined in your configuration.
+
+This example, unmodified, will run the create a `report.md` file with the output of a research on LLMs in the root folder.
+
+## Understanding Your Crew
+
+The {{name}} Crew is composed of multiple AI agents, each with unique roles, goals, and tools. These agents collaborate on a series of tasks, defined in `config/tasks.yaml`, leveraging their collective skills to achieve complex objectives. The `config/agents.yaml` file outlines the capabilities and configurations of each agent in your crew.
+
+## Support
+
+For support, questions, or feedback regarding the {{crew_name}} Crew or crewAI.
+
+- Visit our [documentation](https://docs.crewai.com)
+- Reach out to us through our [GitHub repository](https://github.com/joaomdmoura/crewai)
+- [Join our Discord](https://discord.com/invite/X4JWnZnxPb)
+- [Chat with our docs](https://chatg.pt/DWjSBZn)
+
+Let's create wonders together with the power and simplicity of crewAI.

lib/cli/src/crewai_cli/templates/flow/crews/poem_crew/__init__.py

@@ -0,0 +1 @@
+"""Poem crew template."""

lib/cli/src/crewai_cli/templates/flow/crews/poem_crew/config/agents.yaml

@@ -0,0 +1,11 @@
+poem_writer:
+  role: >
+    CrewAI Poem Writer
+  goal: >
+    Generate a funny, light heartedpoem about how CrewAI 
+    is awesome with a sentence count of {sentence_count}
+  backstory: >
+    You're a creative poet with a talent for capturing the essence of any topic
+    in a beautiful and engaging way. Known for your ability to craft poems that
+    resonate with readers, you bring a unique perspective and artistic flair to
+    every piece you write.

lib/cli/src/crewai_cli/templates/flow/crews/poem_crew/config/tasks.yaml

@@ -0,0 +1,7 @@
+write_poem:
+  description: >
+    Write a poem about how CrewAI is awesome.
+    Ensure the poem is engaging and adheres to the specified sentence count of {sentence_count}.
+  expected_output: >
+    A beautifully crafted poem about CrewAI, with exactly {sentence_count} sentences.
+  agent: poem_writer

lib/cli/src/crewai_cli/templates/flow/crews/poem_crew/poem_crew.py

@@ -0,0 +1,51 @@
+from crewai import Agent, Crew, Process, Task
+from crewai.agents.agent_builder.base_agent import BaseAgent
+from crewai.project import CrewBase, agent, crew, task
+
+# If you want to run a snippet of code before or after the crew starts,
+# you can use the @before_kickoff and @after_kickoff decorators
+# https://docs.crewai.com/concepts/crews#example-crew-class-with-decorators
+
+
+@CrewBase
+class PoemCrew:
+    """Poem Crew"""
+
+    agents: list[BaseAgent]
+    tasks: list[Task]
+
+    # Learn more about YAML configuration files here:
+    # Agents: https://docs.crewai.com/concepts/agents#yaml-configuration-recommended
+    # Tasks: https://docs.crewai.com/concepts/tasks#yaml-configuration-recommended
+    agents_config = "config/agents.yaml"
+    tasks_config = "config/tasks.yaml"
+
+    # If you would lik to add tools to your crew, you can learn more about it here:
+    # https://docs.crewai.com/concepts/agents#agent-tools
+    @agent
+    def poem_writer(self) -> Agent:
+        return Agent(
+            config=self.agents_config["poem_writer"],  # type: ignore[index]
+        )
+
+    # To learn more about structured task outputs,
+    # task dependencies, and task callbacks, check out the documentation:
+    # https://docs.crewai.com/concepts/tasks#overview-of-a-task
+    @task
+    def write_poem(self) -> Task:
+        return Task(
+            config=self.tasks_config["write_poem"],  # type: ignore[index]
+        )
+
+    @crew
+    def crew(self) -> Crew:
+        """Creates the Research Crew"""
+        # To learn how to add knowledge sources to your crew, check out the documentation:
+        # https://docs.crewai.com/concepts/knowledge#what-is-knowledge
+
+        return Crew(
+            agents=self.agents,  # Automatically created by the @agent decorator
+            tasks=self.tasks,  # Automatically created by the @task decorator
+            process=Process.sequential,
+            verbose=True,
+        )

lib/cli/src/crewai_cli/templates/flow/main.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python
+from random import randint
+
+from pydantic import BaseModel
+
+from crewai.flow import Flow, listen, start
+
+from {{folder_name}}.crews.poem_crew.poem_crew import PoemCrew
+
+
+class PoemState(BaseModel):
+    sentence_count: int = 1
+    poem: str = ""
+
+
+class PoemFlow(Flow[PoemState]):
+
+    @start()
+    def generate_sentence_count(self, crewai_trigger_payload: dict = None):
+        print("Generating sentence count")
+
+        # Use trigger payload if available
+        if crewai_trigger_payload:
+            # Example: use trigger data to influence sentence count
+            self.state.sentence_count = crewai_trigger_payload.get('sentence_count', randint(1, 5))
+            print(f"Using trigger payload: {crewai_trigger_payload}")
+        else:
+            self.state.sentence_count = randint(1, 5)
+
+    @listen(generate_sentence_count)
+    def generate_poem(self):
+        print("Generating poem")
+        result = (
+            PoemCrew()
+            .crew()
+            .kickoff(inputs={"sentence_count": self.state.sentence_count})
+        )
+
+        print("Poem generated", result.raw)
+        self.state.poem = result.raw
+
+    @listen(generate_poem)
+    def save_poem(self):
+        print("Saving poem")
+        with open("poem.txt", "w") as f:
+            f.write(self.state.poem)
+
+
+def kickoff():
+    poem_flow = PoemFlow()
+    poem_flow.kickoff()
+
+
+def plot():
+    poem_flow = PoemFlow()
+    poem_flow.plot()
+
+
+def run_with_trigger():
+    """
+    Run the flow with trigger payload.
+    """
+    import json
+    import sys
+
+    # Get trigger payload from command line argument
+    if len(sys.argv) < 2:
+        raise Exception("No trigger payload provided. Please provide JSON payload as argument.")
+
+    try:
+        trigger_payload = json.loads(sys.argv[1])
+    except json.JSONDecodeError:
+        raise Exception("Invalid JSON payload provided as argument")
+
+    # Create flow and kickoff with trigger payload
+    # The @start() methods will automatically receive crewai_trigger_payload parameter
+    poem_flow = PoemFlow()
+
+    try:
+        result = poem_flow.kickoff({"crewai_trigger_payload": trigger_payload})
+        return result
+    except Exception as e:
+        raise Exception(f"An error occurred while running the flow with trigger: {e}")
+
+
+if __name__ == "__main__":
+    kickoff()

lib/cli/src/crewai_cli/templates/flow/pyproject.toml

@@ -0,0 +1,22 @@
+[project]
+name = "{{folder_name}}"
+version = "0.1.0"
+description = "{{name}} using crewAI"
+authors = [{ name = "Your Name", email = "you@example.com" }]
+requires-python = ">=3.10,<3.14"
+dependencies = [
+    "crewai[tools]==1.10.0"
+]
+
+[project.scripts]
+kickoff = "{{folder_name}}.main:kickoff"
+run_crew = "{{folder_name}}.main:kickoff"
+plot = "{{folder_name}}.main:plot"
+run_with_trigger = "{{folder_name}}.main:run_with_trigger"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.crewai]
+type = "flow"

lib/cli/src/crewai_cli/templates/flow/tools/custom_tool.py

@@ -0,0 +1,21 @@
+from typing import Type
+
+from pydantic import BaseModel, Field
+
+from crewai.tools import BaseTool
+
+
+class MyCustomToolInput(BaseModel):
+    """Input schema for MyCustomTool."""
+
+    argument: str = Field(..., description="Description of the argument.")
+
+
+class MyCustomTool(BaseTool):
+    name: str = "Name of my tool"
+    description: str = "Clear description for what this tool is useful for, your agent will need this information to use it."
+    args_schema: Type[BaseModel] = MyCustomToolInput
+
+    def _run(self, argument: str) -> str:
+        # Implementation goes here
+        return "this is an example of a tool output, ignore it and move along."

lib/cli/src/crewai_cli/templates/tool/.gitignore

@@ -0,0 +1,10 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv

lib/cli/src/crewai_cli/templates/tool/README.md

@@ -0,0 +1,48 @@
+# {{folder_name}}
+
+{{folder_name}} is a CrewAI Tool. This template is designed to help you create
+custom tools to power up your crews.
+
+## Installing
+
+Ensure you have Python >=3.10 <3.14 installed on your system. This project
+uses [UV](https://docs.astral.sh/uv/) for dependency management and package
+handling, offering a seamless setup and execution experience.
+
+First, if you haven't already, install `uv`:
+
+```bash
+pip install uv
+```
+
+Next, navigate to your project directory and install the dependencies with:
+
+```bash
+crewai install
+```
+
+## Publishing
+
+Collaborate by sharing tools within your organization, or publish them publicly
+to contribute with the community.
+
+```bash
+crewai tool publish {{tool_name}}
+```
+
+Others may install your tool in their crews running:
+
+```bash
+crewai tool install {{tool_name}}
+```
+
+## Support
+
+For support, questions, or feedback regarding the {{crew_name}} tool or CrewAI.
+
+- Visit our [documentation](https://docs.crewai.com)
+- Reach out to us through our [GitHub repository](https://github.com/joaomdmoura/crewai)
+- [Join our Discord](https://discord.com/invite/X4JWnZnxPb)
+- [Chat with our docs](https://chatg.pt/DWjSBZn)
+
+Let's create wonders together with the power and simplicity of crewAI.

lib/cli/src/crewai_cli/templates/tool/pyproject.toml

@@ -0,0 +1,12 @@
+[project]
+name = "{{folder_name}}"
+version = "0.1.0"
+description = "Power up your crews with {{folder_name}}"
+readme = "README.md"
+requires-python = ">=3.10,<3.14"
+dependencies = [
+    "crewai[tools]==1.10.0"
+]
+
+[tool.crewai]
+type = "tool"

lib/cli/src/crewai_cli/templates/tool/src/{{folder_name}}/__init__.py

@@ -0,0 +1,3 @@
+from .tool import {{class_name}}
+
+__all__ = ["{{class_name}}"]

lib/cli/src/crewai_cli/templates/tool/src/{{folder_name}}/tool.py

@@ -0,0 +1,10 @@
+from crewai.tools import BaseTool
+
+
+class {{class_name}}(BaseTool):
+    name: str = "Name of my tool"
+    description: str = "What this tool does. It's vital for effective utilization."
+
+    def _run(self, argument: str) -> str:
+        # Your tool's logic here
+        return "Tool's result"

lib/cli/src/crewai_cli/tools/main.py

@@ -0,0 +1,257 @@
+import base64
+from json import JSONDecodeError
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import tempfile
+from typing import Any
+
+import click
+from rich.console import Console
+
+from crewai_cli import git
+from crewai_cli.command import BaseCommand, PlusAPIMixin
+from crewai_cli.config import Settings
+from crewai_cli.constants import DEFAULT_CREWAI_ENTERPRISE_URL
+from crewai_cli.utils import (
+    build_env_with_tool_repository_credentials,
+    extract_available_exports,
+    get_project_description,
+    get_project_name,
+    get_project_version,
+    tree_copy,
+    tree_find_and_replace,
+)
+
+
+console = Console()
+
+
+class ToolCommand(BaseCommand, PlusAPIMixin):
+    """
+    A class to handle tool repository related operations for CrewAI projects.
+    """
+
+    def __init__(self) -> None:
+        BaseCommand.__init__(self)
+        PlusAPIMixin.__init__(self)
+
+    def create(self, handle: str) -> None:
+        self._ensure_not_in_project()
+
+        folder_name = handle.replace(" ", "_").replace("-", "_").lower()
+        class_name = handle.replace("_", " ").replace("-", " ").title().replace(" ", "")
+
+        project_root = Path(folder_name)
+        if project_root.exists():
+            click.secho(f"Folder {folder_name} already exists.", fg="red")
+            raise SystemExit
+        os.makedirs(project_root)
+
+        click.secho(f"Creating custom tool {folder_name}...", fg="green", bold=True)
+
+        template_dir = Path(__file__).parent.parent / "templates" / "tool"
+        tree_copy(template_dir, project_root)
+        tree_find_and_replace(project_root, "{{folder_name}}", folder_name)
+        tree_find_and_replace(project_root, "{{class_name}}", class_name)
+
+        # Copy AGENTS.md to project root
+        agents_md_src = Path(__file__).parent.parent / "templates" / "AGENTS.md"
+        if agents_md_src.exists():
+            shutil.copy2(agents_md_src, project_root / "AGENTS.md")
+
+        old_directory = os.getcwd()
+        os.chdir(project_root)
+        try:
+            self.login()
+            subprocess.run(["git", "init"], check=True)  # noqa: S607
+            console.print(
+                f"[green]Created custom tool [bold]{folder_name}[/bold]. Run [bold]cd {project_root}[/bold] to start working.[/green]"
+            )
+        finally:
+            os.chdir(old_directory)
+
+    def publish(self, is_public: bool, force: bool = False) -> None:
+        if not git.Repository().is_synced() and not force:
+            console.print(
+                "[bold red]Failed to publish tool.[/bold red]\n"
+                "Local changes need to be resolved before publishing. Please do the following:\n"
+                "* [bold]Commit[/bold] your changes.\n"
+                "* [bold]Push[/bold] to sync with the remote.\n"
+                "* [bold]Pull[/bold] the latest changes from the remote.\n"
+                "\nOnce your repository is up-to-date, retry publishing the tool."
+            )
+            raise SystemExit()
+
+        project_name = get_project_name(require=True)
+        assert isinstance(project_name, str)  # noqa: S101
+
+        project_version = get_project_version(require=True)
+        assert isinstance(project_version, str)  # noqa: S101
+
+        project_description = get_project_description(require=False)
+        encoded_tarball = None
+
+        console.print("[bold blue]Discovering tools from your project...[/bold blue]")
+        available_exports = extract_available_exports()
+
+        if available_exports:
+            console.print(
+                f"[green]Found these tools to publish: {', '.join([e['name'] for e in available_exports])}[/green]"
+            )
+        self._print_current_organization()
+
+        with tempfile.TemporaryDirectory() as temp_build_dir:
+            subprocess.run(  # noqa: S603
+                ["uv", "build", "--sdist", "--out-dir", temp_build_dir],  # noqa: S607
+                check=True,
+                capture_output=False,
+            )
+
+            tarball_filename = next(
+                (f for f in os.listdir(temp_build_dir) if f.endswith(".tar.gz")), None
+            )
+            if not tarball_filename:
+                console.print(
+                    "Project build failed. Please ensure that the command `uv build --sdist` completes successfully.",
+                    style="bold red",
+                )
+                raise SystemExit
+
+            tarball_path = os.path.join(temp_build_dir, tarball_filename)
+            with open(tarball_path, "rb") as file:
+                tarball_contents = file.read()
+
+            encoded_tarball = base64.b64encode(tarball_contents).decode("utf-8")
+
+        console.print("[bold blue]Publishing tool to repository...[/bold blue]")
+        publish_response = self.plus_api_client.publish_tool(
+            handle=project_name,
+            is_public=is_public,
+            version=project_version,
+            description=project_description,
+            encoded_file=f"data:application/x-gzip;base64,{encoded_tarball}",
+            available_exports=available_exports,
+        )
+
+        self._validate_response(publish_response)
+
+        published_handle = publish_response.json()["handle"]
+        settings = Settings()
+        base_url = settings.enterprise_base_url or DEFAULT_CREWAI_ENTERPRISE_URL
+
+        console.print(
+            f"Successfully published `{published_handle}` ({project_version}).\n\n"
+            + "⚠️ Security checks are running in the background. Your tool will be available once these are complete.\n"
+            + f"You can monitor the status or access your tool here:\n{base_url}/crewai_plus/tools/{published_handle}",
+            style="bold green",
+        )
+
+    def install(self, handle: str) -> None:
+        self._print_current_organization()
+        get_response = self.plus_api_client.get_tool(handle)
+
+        if get_response.status_code == 404:
+            console.print(
+                "No tool found with this name. Please ensure the tool was published and you have access to it.",
+                style="bold red",
+            )
+            raise SystemExit
+        if get_response.status_code != 200:
+            console.print(
+                "Failed to get tool details. Please try again later.", style="bold red"
+            )
+            raise SystemExit
+
+        self._add_package(get_response.json())
+
+        console.print(f"Successfully installed {handle}", style="bold green")
+
+    def login(self) -> None:
+        login_response = self.plus_api_client.login_to_tool_repository()
+
+        if login_response.status_code != 200:
+            console.print(
+                "Authentication failed. Verify if the currently active organization can access the tool repository, and run 'crewai login' again.",
+                style="bold red",
+            )
+            try:
+                console.print(
+                    f"[{login_response.status_code} error - {login_response.json().get('message', 'Unknown error')}]",
+                    style="bold red italic",
+                )
+            except JSONDecodeError:
+                console.print(
+                    f"[{login_response.status_code} error - Unknown error - Invalid JSON response]",
+                    style="bold red italic",
+                )
+            raise SystemExit
+
+        login_response_json = login_response.json()
+
+        settings = Settings()
+        settings.tool_repository_username = login_response_json["credential"][
+            "username"
+        ]
+        settings.tool_repository_password = login_response_json["credential"][
+            "password"
+        ]
+        settings.org_uuid = login_response_json["current_organization"]["uuid"]
+        settings.org_name = login_response_json["current_organization"]["name"]
+        settings.dump()
+
+    def _add_package(self, tool_details: dict[str, Any]) -> None:
+        is_from_pypi = tool_details.get("source", None) == "pypi"
+        tool_handle = tool_details["handle"]
+        repository_handle = tool_details["repository"]["handle"]
+        repository_url = tool_details["repository"]["url"]
+        index = f"{repository_handle}={repository_url}"
+
+        add_package_command = [
+            "uv",
+            "add",
+        ]
+
+        if is_from_pypi:
+            add_package_command.append(tool_handle)
+        else:
+            add_package_command.extend(["--index", index, tool_handle])
+
+        add_package_result = subprocess.run(  # noqa: S603
+            add_package_command,
+            capture_output=False,
+            env=build_env_with_tool_repository_credentials(repository_handle),
+            text=True,
+            check=True,
+        )
+
+        if add_package_result.stderr:
+            click.echo(add_package_result.stderr, err=True)
+            raise SystemExit
+
+    def _ensure_not_in_project(self) -> None:
+        if os.path.isfile("./pyproject.toml"):
+            console.print(
+                "[bold red]Oops! It looks like you're inside a project.[/bold red]"
+            )
+            console.print(
+                "You can't create a new tool while inside an existing project."
+            )
+            console.print(
+                "[bold yellow]Tip:[/bold yellow] Navigate to a different directory and try again."
+            )
+            raise SystemExit
+
+    def _print_current_organization(self) -> None:
+        settings = Settings()
+        if settings.org_uuid:
+            console.print(
+                f"Current organization: {settings.org_name} ({settings.org_uuid})",
+                style="bold blue",
+            )
+        else:
+            console.print(
+                "No organization currently set. We recommend setting one before using: `crewai org switch <org_id>` command.",
+                style="yellow",
+            )

lib/cli/src/crewai_cli/train_crew.py

@@ -0,0 +1,32 @@
+import subprocess
+
+import click
+
+
+def train_crew(n_iterations: int, filename: str) -> None:
+    """
+    Train the crew by running a command in the UV environment.
+
+    Args:
+        n_iterations (int): The number of iterations to train the crew.
+    """
+    command = ["uv", "run", "train", str(n_iterations), filename]
+
+    try:
+        if n_iterations <= 0:
+            raise ValueError("The number of iterations must be a positive integer.")
+
+        if not filename.endswith(".pkl"):
+            raise ValueError("The filename must not end with .pkl")
+
+        result = subprocess.run(command, capture_output=False, text=True, check=True)  # noqa: S603
+
+        if result.stderr:
+            click.echo(result.stderr, err=True)
+
+    except subprocess.CalledProcessError as e:
+        click.echo(f"An error occurred while training the crew: {e}", err=True)
+        click.echo(e.output, err=True)
+
+    except Exception as e:
+        click.echo(f"An unexpected error occurred: {e}", err=True)

lib/cli/src/crewai_cli/triggers/__init__.py

@@ -0,0 +1,6 @@
+"""Triggers command module for CrewAI CLI."""
+
+from crewai_cli.triggers.main import TriggersCommand
+
+
+__all__ = ["TriggersCommand"]

lib/cli/src/crewai_cli/triggers/main.py

@@ -0,0 +1,137 @@
+import json
+import subprocess
+from typing import Any
+
+from rich.console import Console
+from rich.table import Table
+
+from crewai_cli.command import BaseCommand, PlusAPIMixin
+
+
+console = Console()
+
+
+class TriggersCommand(BaseCommand, PlusAPIMixin):
+    """
+    A class to handle trigger-related operations for CrewAI projects.
+    """
+
+    def __init__(self):
+        BaseCommand.__init__(self)
+        PlusAPIMixin.__init__(self)
+
+    def list_triggers(self) -> None:
+        """List all available triggers from integrations."""
+        try:
+            console.print("[bold blue]Fetching available triggers...[/bold blue]")
+            response = self.plus_api_client.get_triggers()
+            self._validate_response(response)
+
+            triggers_data = response.json()
+            self._display_triggers(triggers_data)
+
+        except Exception as e:
+            console.print(f"[bold red]Error fetching triggers: {e}[/bold red]")
+            raise SystemExit(1) from e
+
+    def execute_with_trigger(self, trigger_path: str) -> None:
+        """Execute crew with trigger payload."""
+        try:
+            # Parse app_slug/trigger_slug
+            if "/" not in trigger_path:
+                console.print(
+                    "[bold red]Error: Trigger must be in format 'app_slug/trigger_slug'[/bold red]"
+                )
+                raise SystemExit(1)
+
+            app_slug, trigger_slug = trigger_path.split("/", 1)
+
+            console.print(
+                f"[bold blue]Fetching trigger payload for {app_slug}/{trigger_slug}...[/bold blue]"
+            )
+            response = self.plus_api_client.get_trigger_payload(app_slug, trigger_slug)
+
+            if response.status_code == 404:
+                error_data = response.json()
+                console.print(
+                    f"[bold red]Error: {error_data.get('error', 'Trigger not found')}[/bold red]"
+                )
+                raise SystemExit(1)
+
+            self._validate_response(response)
+
+            trigger_data = response.json()
+            self._display_trigger_info(trigger_data)
+
+            # Run crew with trigger payload
+            self._run_crew_with_payload(trigger_data.get("sample_payload", {}))
+
+        except Exception as e:
+            console.print(
+                f"[bold red]Error executing crew with trigger: {e}[/bold red]"
+            )
+            raise SystemExit(1) from e
+
+    def _display_triggers(self, triggers_data: dict[str, Any]) -> None:
+        """Display triggers in a formatted table."""
+        apps = triggers_data.get("apps", [])
+
+        if not apps:
+            console.print("[yellow]No triggers found.[/yellow]")
+            return
+
+        for app in apps:
+            app_name = app.get("name", "Unknown App")
+            app_slug = app.get("slug", "unknown")
+            is_connected = app.get("is_connected", False)
+            connection_status = (
+                "[green]✓ Connected[/green]"
+                if is_connected
+                else "[red]✗ Not Connected[/red]"
+            )
+
+            console.print(
+                f"\n[bold cyan]{app_name}[/bold cyan] ({app_slug}) - {connection_status}"
+            )
+            console.print(
+                f"[dim]{app.get('description', 'No description available')}[/dim]"
+            )
+
+            triggers = app.get("triggers", [])
+            if triggers:
+                table = Table(show_header=True, header_style="bold magenta")
+                table.add_column("Trigger", style="cyan")
+                table.add_column("Name", style="green")
+                table.add_column("Description", style="dim")
+
+                for trigger in triggers:
+                    trigger_path = f"{app_slug}/{trigger.get('slug', 'unknown')}"
+                    table.add_row(
+                        trigger_path,
+                        trigger.get("name", "Unknown"),
+                        trigger.get("description", "No description"),
+                    )
+
+                console.print(table)
+            else:
+                console.print("[dim]  No triggers available[/dim]")
+
+    def _display_trigger_info(self, trigger_data: dict[str, Any]) -> None:
+        """Display trigger information before execution."""
+        sample_payload = trigger_data.get("sample_payload", {})
+        if sample_payload:
+            console.print("\n[bold yellow]Sample Payload:[/bold yellow]")
+            console.print(json.dumps(sample_payload, indent=2))
+
+    def _run_crew_with_payload(self, payload: dict[str, Any]) -> None:
+        """Run the crew with the trigger payload using the run_with_trigger method."""
+        try:
+            subprocess.run(  # noqa: S603
+                ["uv", "run", "run_with_trigger", json.dumps(payload)],  # noqa: S607
+                capture_output=False,
+                text=True,
+                check=True,
+            )
+
+        except Exception as e:
+            raise SystemExit(1) from e

lib/cli/src/crewai_cli/update_crew.py

@@ -0,0 +1,122 @@
+import os
+import shutil
+
+import tomli_w
+
+from crewai_cli.utils import read_toml
+
+
+def update_crew() -> None:
+    """Update the pyproject.toml of the Crew project to use uv."""
+    migrate_pyproject("pyproject.toml", "pyproject.toml")
+
+
+def migrate_pyproject(input_file, output_file):
+    """
+    Migrate the pyproject.toml to the new format.
+
+    This function is used to migrate the pyproject.toml to the new format.
+    And it will be used to migrate the pyproject.toml to the new format when uv is used.
+    When the time comes that uv supports the new format, this function will be deprecated.
+    """
+    poetry_data = {}
+    # Read the input pyproject.toml
+    pyproject_data = read_toml()
+
+    # Initialize the new project structure
+    new_pyproject = {
+        "project": {},
+        "build-system": {"requires": ["hatchling"], "build-backend": "hatchling.build"},
+    }
+
+    # Migrate project metadata
+    if "tool" in pyproject_data and "poetry" in pyproject_data["tool"]:
+        poetry_data = pyproject_data["tool"]["poetry"]
+        new_pyproject["project"]["name"] = poetry_data.get("name")
+        new_pyproject["project"]["version"] = poetry_data.get("version")
+        new_pyproject["project"]["description"] = poetry_data.get("description")
+        new_pyproject["project"]["authors"] = [
+            {
+                "name": author.split("<")[0].strip(),
+                "email": author.split("<")[1].strip(">").strip(),
+            }
+            for author in poetry_data.get("authors", [])
+        ]
+        new_pyproject["project"]["requires-python"] = poetry_data.get("python")
+    else:
+        # If it's already in the new format, just copy the project and tool sections
+        new_pyproject["project"] = pyproject_data.get("project", {})
+        new_pyproject["tool"] = pyproject_data.get("tool", {})
+
+    # Migrate or copy dependencies
+    if "dependencies" in new_pyproject["project"]:
+        # If dependencies are already in the new format, keep them as is
+        pass
+    elif poetry_data and "dependencies" in poetry_data:
+        new_pyproject["project"]["dependencies"] = []
+        for dep, version in poetry_data["dependencies"].items():
+            if isinstance(version, dict):  # Handle extras
+                extras = ",".join(version.get("extras", []))
+                new_dep = f"{dep}[{extras}]"
+                if "version" in version:
+                    new_dep += parse_version(version["version"])
+            elif dep == "python":
+                new_pyproject["project"]["requires-python"] = version
+                continue
+            else:
+                new_dep = f"{dep}{parse_version(version)}"
+            new_pyproject["project"]["dependencies"].append(new_dep)
+
+    # Migrate or copy scripts
+    if poetry_data and "scripts" in poetry_data:
+        new_pyproject["project"]["scripts"] = poetry_data["scripts"]
+    elif pyproject_data.get("project", {}) and "scripts" in pyproject_data["project"]:
+        new_pyproject["project"]["scripts"] = pyproject_data["project"]["scripts"]
+    else:
+        new_pyproject["project"]["scripts"] = {}
+
+    if (
+        "run_crew" not in new_pyproject["project"]["scripts"]
+        and len(new_pyproject["project"]["scripts"]) > 0
+    ):
+        # Extract the module name from any existing script
+        existing_scripts = new_pyproject["project"]["scripts"]
+        module_name = next(
+            (value.split(".")[0] for value in existing_scripts.values() if "." in value)
+        )
+
+        new_pyproject["project"]["scripts"]["run_crew"] = f"{module_name}.main:run"
+
+    # Migrate optional dependencies
+    if poetry_data and "extras" in poetry_data:
+        new_pyproject["project"]["optional-dependencies"] = poetry_data["extras"]
+
+    # Backup the old pyproject.toml
+    backup_file = "pyproject-old.toml"
+    shutil.copy2(input_file, backup_file)
+
+    # Rename the poetry.lock file
+    lock_file = "poetry.lock"
+    lock_backup = "poetry-old.lock"
+    if os.path.exists(lock_file):
+        os.rename(lock_file, lock_backup)
+    else:
+        pass
+
+    # Write the new pyproject.toml
+    with open(output_file, "wb") as f:
+        tomli_w.dump(new_pyproject, f)
+
+
+def parse_version(version: str) -> str:
+    """Parse and convert version specifiers."""
+    if version.startswith("^"):
+        main_lib_version = version[1:].split(",")[0]
+        addtional_lib_version = None
+        if len(version[1:].split(",")) > 1:
+            addtional_lib_version = version[1:].split(",")[1]
+
+        return f">={main_lib_version}" + (
+            f",{addtional_lib_version}" if addtional_lib_version else ""
+        )
+    return version

lib/cli/src/crewai_cli/user_data.py

@@ -0,0 +1,66 @@
+"""Standalone user-data helpers for the CLI package.
+
+These mirror the functions in ``crewai.events.listeners.tracing.utils`` but
+depend only on the standard library + *appdirs* so that crewai-cli can work
+without importing the full crewai framework.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+from pathlib import Path
+from typing import Any, cast
+
+import appdirs
+
+
+logger = logging.getLogger(__name__)
+
+
+def _get_project_directory_name() -> str:
+    return os.environ.get("CREWAI_STORAGE_DIR", Path.cwd().name)
+
+
+def _db_storage_path() -> str:
+    app_name = _get_project_directory_name()
+    app_author = "CrewAI"
+    data_dir = Path(appdirs.user_data_dir(app_name, app_author))
+    data_dir.mkdir(parents=True, exist_ok=True)
+    return str(data_dir)
+
+
+def _user_data_file() -> Path:
+    base = Path(_db_storage_path())
+    base.mkdir(parents=True, exist_ok=True)
+    return base / ".crewai_user.json"
+
+
+def _load_user_data() -> dict[str, Any]:
+    p = _user_data_file()
+    if p.exists():
+        try:
+            return cast(dict[str, Any], json.loads(p.read_text()))
+        except (json.JSONDecodeError, OSError, PermissionError) as e:
+            logger.warning("Failed to load user data: %s", e)
+    return {}
+
+
+def _save_user_data(data: dict[str, Any]) -> None:
+    try:
+        p = _user_data_file()
+        p.write_text(json.dumps(data, indent=2))
+    except (OSError, PermissionError) as e:
+        logger.warning("Failed to save user data: %s", e)
+
+
+def is_tracing_enabled() -> bool:
+    """Check if tracing is enabled (mirrors crewai core logic)."""
+    data = _load_user_data()
+    if (
+        data.get("first_execution_done", False)
+        and data.get("trace_consent", False) is False
+    ):
+        return False
+    return os.getenv("CREWAI_TRACING_ENABLED", "false").lower() == "true"

lib/cli/src/crewai_cli/utils.py

@@ -0,0 +1,369 @@
+from __future__ import annotations
+
+from functools import reduce
+from inspect import getmro, isclass
+import os
+from pathlib import Path
+import shutil
+import sys
+from typing import Any, cast
+
+import click
+from rich.console import Console
+import tomli
+
+from crewai_cli.config import Settings
+from crewai_cli.constants import ENV_VARS
+
+
+if sys.version_info >= (3, 11):
+    import tomllib
+
+console = Console()
+
+
+def copy_template(
+    src: Path, dst: Path, name: str, class_name: str, folder_name: str
+) -> None:
+    """Copy a file from src to dst."""
+    with open(src, "r") as file:
+        content = file.read()
+
+    content = content.replace("{{name}}", name)
+    content = content.replace("{{crew_name}}", class_name)
+    content = content.replace("{{folder_name}}", folder_name)
+
+    with open(dst, "w") as file:
+        file.write(content)
+
+    click.secho(f"  - Created {dst}", fg="green")
+
+
+def read_toml(file_path: str = "pyproject.toml") -> dict[str, Any]:
+    """Read the content of a TOML file and return it as a dictionary."""
+    with open(file_path, "rb") as f:
+        return tomli.load(f)
+
+
+def parse_toml(content: str) -> dict[str, Any]:
+    if sys.version_info >= (3, 11):
+        return tomllib.loads(content)
+    return tomli.loads(content)
+
+
+def get_project_name(
+    pyproject_path: str = "pyproject.toml", require: bool = False
+) -> str | None:
+    """Get the project name from the pyproject.toml file."""
+    return _get_project_attribute(pyproject_path, ["project", "name"], require=require)
+
+
+def get_project_version(
+    pyproject_path: str = "pyproject.toml", require: bool = False
+) -> str | None:
+    """Get the project version from the pyproject.toml file."""
+    return _get_project_attribute(
+        pyproject_path, ["project", "version"], require=require
+    )
+
+
+def get_project_description(
+    pyproject_path: str = "pyproject.toml", require: bool = False
+) -> str | None:
+    """Get the project description from the pyproject.toml file."""
+    return _get_project_attribute(
+        pyproject_path, ["project", "description"], require=require
+    )
+
+
+def _get_project_attribute(
+    pyproject_path: str, keys: list[str], require: bool
+) -> Any | None:
+    """Get an attribute from the pyproject.toml file."""
+    attribute = None
+
+    try:
+        with open(pyproject_path, "r") as f:
+            pyproject_content = parse_toml(f.read())
+
+        dependencies = (
+            _get_nested_value(pyproject_content, ["project", "dependencies"]) or []
+        )
+        if not any(True for dep in dependencies if "crewai" in dep):
+            raise Exception("crewai is not in the dependencies.")
+
+        attribute = _get_nested_value(pyproject_content, keys)
+    except FileNotFoundError:
+        console.print(f"Error: {pyproject_path} not found.", style="bold red")
+    except KeyError:
+        console.print(
+            f"Error: {pyproject_path} is not a valid pyproject.toml file.",
+            style="bold red",
+        )
+    except Exception as e:
+        if sys.version_info >= (3, 11) and isinstance(e, tomllib.TOMLDecodeError):
+            console.print(
+                f"Error: {pyproject_path} is not a valid TOML file.", style="bold red"
+            )
+        else:
+            console.print(
+                f"Error reading the pyproject.toml file: {e}", style="bold red"
+            )
+
+    if require and not attribute:
+        console.print(
+            f"Unable to read '{'.'.join(keys)}' in the pyproject.toml file. Please verify that the file exists and contains the specified attribute.",
+            style="bold red",
+        )
+        raise SystemExit
+
+    return attribute
+
+
+def _get_nested_value(data: dict[str, Any], keys: list[str]) -> Any:
+    return reduce(dict.__getitem__, keys, data)
+
+
+def fetch_and_json_env_file(env_file_path: str = ".env") -> dict[str, Any]:
+    """Fetch the environment variables from a .env file and return them as a dictionary."""
+    try:
+        with open(env_file_path, "r") as f:
+            env_content = f.read()
+
+        env_dict = {}
+        for line in env_content.splitlines():
+            if line.strip() and not line.strip().startswith("#"):
+                key, value = line.split("=", 1)
+                env_dict[key.strip()] = value.strip()
+
+        return env_dict
+
+    except FileNotFoundError:
+        console.print(f"Error: {env_file_path} not found.", style="bold red")
+    except Exception as e:
+        console.print(f"Error reading the .env file: {e}", style="bold red")
+
+    return {}
+
+
+def tree_copy(source: Path, destination: Path) -> None:
+    """Copies the entire directory structure from the source to the destination."""
+    for item in os.listdir(source):
+        source_item = os.path.join(source, item)
+        destination_item = os.path.join(destination, item)
+        if os.path.isdir(source_item):
+            shutil.copytree(source_item, destination_item)
+        else:
+            shutil.copy2(source_item, destination_item)
+
+
+def tree_find_and_replace(directory: Path, find: str, replace: str) -> None:
+    """Recursively searches through a directory, replacing a target string in
+    both file contents and filenames with a specified replacement string.
+    """
+    for path, dirs, files in os.walk(os.path.abspath(directory), topdown=False):
+        for filename in files:
+            filepath = os.path.join(path, filename)
+
+            with open(filepath, "r", encoding="utf-8", errors="ignore") as file:
+                contents = file.read()
+            with open(filepath, "w") as file:
+                file.write(contents.replace(find, replace))
+
+            if find in filename:
+                new_filename = filename.replace(find, replace)
+                new_filepath = os.path.join(path, new_filename)
+                os.rename(filepath, new_filepath)
+
+        for dirname in dirs:
+            if find in dirname:
+                new_dirname = dirname.replace(find, replace)
+                new_dirpath = os.path.join(path, new_dirname)
+                old_dirpath = os.path.join(path, dirname)
+                os.rename(old_dirpath, new_dirpath)
+
+
+def load_env_vars(folder_path: Path) -> dict[str, Any]:
+    """Loads environment variables from a .env file in the specified folder path."""
+    env_file_path = folder_path / ".env"
+    env_vars = {}
+    if env_file_path.exists():
+        with open(env_file_path, "r") as file:
+            for line in file:
+                key, _, value = line.strip().partition("=")
+                if key and value:
+                    env_vars[key] = value
+    return env_vars
+
+
+def update_env_vars(
+    env_vars: dict[str, Any], provider: str, model: str
+) -> dict[str, Any] | None:
+    """Updates environment variables with the API key for the selected provider and model."""
+    provider_config = cast(
+        list[str],
+        ENV_VARS.get(
+            provider,
+            [
+                click.prompt(
+                    f"Enter the environment variable name for your {provider.capitalize()} API key",
+                    type=str,
+                )
+            ],
+        ),
+    )
+
+    api_key_var = provider_config[0]
+
+    if api_key_var not in env_vars:
+        try:
+            env_vars[api_key_var] = click.prompt(
+                f"Enter your {provider.capitalize()} API key", type=str, hide_input=True
+            )
+        except click.exceptions.Abort:
+            click.secho("Operation aborted by the user.", fg="red")
+            return None
+    else:
+        click.secho(f"API key already exists for {provider.capitalize()}.", fg="yellow")
+
+    env_vars["MODEL"] = model
+    click.secho(f"Selected model: {model}", fg="green")
+    return env_vars
+
+
+def write_env_file(folder_path: Path, env_vars: dict[str, Any]) -> None:
+    """Writes environment variables to a .env file in the specified folder."""
+    env_file_path = folder_path / ".env"
+    with open(env_file_path, "w") as file:
+        for key, value in env_vars.items():
+            file.write(f"{key.upper()}={value}\n")
+
+
+def is_valid_tool(obj: Any) -> bool:
+    """Check if an object is a valid tool class.
+
+    Works without importing crewai by checking MRO class names.
+    Falls back to crewai's ``is_valid_tool`` when available.
+    """
+    try:
+        from crewai.cli.utils import is_valid_tool as _core_is_valid_tool
+
+        return _core_is_valid_tool(obj)
+    except ImportError:
+        pass
+
+    if isclass(obj):
+        try:
+            return any(base.__name__ == "BaseTool" for base in getmro(obj))
+        except (TypeError, AttributeError):
+            return False
+    return False
+
+
+def extract_available_exports(dir_path: str = "src") -> list[dict[str, Any]]:
+    """Extract available tool classes from the project's __init__.py files."""
+    try:
+        init_files = Path(dir_path).glob("**/__init__.py")
+        available_exports: list[dict[str, Any]] = []
+
+        for init_file in init_files:
+            tools = _load_tools_from_init(init_file)
+            available_exports.extend(tools)
+
+        if not available_exports:
+            _print_no_tools_warning()
+            raise SystemExit(1)
+
+        return available_exports
+
+    except SystemExit:
+        raise
+    except Exception as e:
+        console.print(f"[red]Error: Could not extract tool classes: {e!s}[/red]")
+        console.print(
+            "Please ensure your project contains valid tools (classes inheriting from BaseTool or functions with @tool decorator)."
+        )
+        raise SystemExit(1) from e
+
+
+def _load_tools_from_init(init_file: Path) -> list[dict[str, Any]]:
+    """Load and validate tools from a given __init__.py file."""
+    import importlib.util as _importlib_util
+
+    spec = _importlib_util.spec_from_file_location("temp_module", init_file)
+
+    if not spec or not spec.loader:
+        return []
+
+    module = _importlib_util.module_from_spec(spec)
+    sys.modules["temp_module"] = module
+
+    try:
+        spec.loader.exec_module(module)
+
+        if not hasattr(module, "__all__"):
+            console.print(
+                f"Warning: No __all__ defined in {init_file}",
+                style="bold yellow",
+            )
+            raise SystemExit(1)
+
+        return [
+            {"name": name}
+            for name in module.__all__
+            if hasattr(module, name) and is_valid_tool(getattr(module, name))
+        ]
+
+    except SystemExit:
+        raise
+    except Exception as e:
+        console.print(f"[red]Warning: Could not load {init_file}: {e!s}[/red]")
+        raise SystemExit(1) from e
+
+    finally:
+        sys.modules.pop("temp_module", None)
+
+
+def _print_no_tools_warning() -> None:
+    """Display warning and usage instructions if no tools were found."""
+    console.print(
+        "\n[bold yellow]Warning: No valid tools were exposed in your __init__.py file![/bold yellow]"
+    )
+    console.print(
+        "Your __init__.py file must contain all classes that inherit from [bold]BaseTool[/bold] "
+        "or functions decorated with [bold]@tool[/bold]."
+    )
+    console.print(
+        "\nExample:\n[dim]# In your __init__.py file[/dim]\n"
+        "[green]__all__ = ['YourTool', 'your_tool_function'][/green]\n\n"
+        "[dim]# In your tool.py file[/dim]\n"
+        "[green]from crewai.tools import BaseTool, tool\n\n"
+        "# Tool class example\n"
+        "class YourTool(BaseTool):\n"
+        '    name = "your_tool"\n'
+        '    description = "Your tool description"\n'
+        "    # ... rest of implementation\n\n"
+        "# Decorated function example\n"
+        "@tool\n"
+        "def your_tool_function(text: str) -> str:\n"
+        '    """Your tool description"""\n'
+        "    # ... implementation\n"
+        "    return result\n"
+    )
+
+
+def build_env_with_tool_repository_credentials(
+    repository_handle: str,
+) -> dict[str, Any]:
+    repository_handle = repository_handle.upper().replace("-", "_")
+    settings = Settings()
+
+    env = os.environ.copy()
+    env[f"UV_INDEX_{repository_handle}_USERNAME"] = str(
+        settings.tool_repository_username or ""
+    )
+    env[f"UV_INDEX_{repository_handle}_PASSWORD"] = str(
+        settings.tool_repository_password or ""
+    )
+
+    return env

lib/cli/src/crewai_cli/version.py

@@ -0,0 +1,215 @@
+"""Version utilities for CrewAI CLI."""
+
+from collections.abc import Mapping
+from datetime import datetime, timedelta
+from functools import lru_cache
+import importlib.metadata
+import json
+from pathlib import Path
+from typing import Any
+from urllib import request
+from urllib.error import URLError
+
+import appdirs
+from packaging.version import InvalidVersion, Version, parse
+
+
+@lru_cache(maxsize=1)
+def _get_cache_file() -> Path:
+    """Get the path to the version cache file.
+
+    Cached to avoid repeated filesystem operations.
+    """
+    cache_dir = Path(appdirs.user_cache_dir("crewai"))
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    return cache_dir / "version_cache.json"
+
+
+def get_crewai_version() -> str:
+    """Get the version number of CrewAI running the CLI."""
+    return importlib.metadata.version("crewai")
+
+
+def _is_cache_valid(cache_data: Mapping[str, Any]) -> bool:
+    """Check if the cache is still valid, less than 24 hours old."""
+    if "timestamp" not in cache_data:
+        return False
+
+    try:
+        cache_time = datetime.fromisoformat(str(cache_data["timestamp"]))
+        return datetime.now() - cache_time < timedelta(hours=24)
+    except (ValueError, TypeError):
+        return False
+
+
+def _find_latest_non_yanked_version(
+    releases: Mapping[str, list[dict[str, Any]]],
+) -> str | None:
+    """Find the latest non-yanked version from PyPI releases data.
+
+    Args:
+        releases: PyPI releases dict mapping version strings to file info lists.
+
+    Returns:
+        The latest non-yanked version string, or None if all versions are yanked.
+    """
+    best_version: Version | None = None
+    best_version_str: str | None = None
+
+    for version_str, files in releases.items():
+        try:
+            v = parse(version_str)
+        except InvalidVersion:
+            continue
+
+        if v.is_prerelease or v.is_devrelease:
+            continue
+
+        if not files:
+            continue
+
+        all_yanked = all(f.get("yanked", False) for f in files)
+        if all_yanked:
+            continue
+
+        if best_version is None or v > best_version:
+            best_version = v
+            best_version_str = version_str
+
+    return best_version_str
+
+
+def _is_version_yanked(
+    version_str: str,
+    releases: Mapping[str, list[dict[str, Any]]],
+) -> tuple[bool, str]:
+    """Check if a specific version is yanked.
+
+    Args:
+        version_str: The version string to check.
+        releases: PyPI releases dict mapping version strings to file info lists.
+
+    Returns:
+        Tuple of (is_yanked, yanked_reason).
+    """
+    files = releases.get(version_str, [])
+    if not files:
+        return False, ""
+
+    all_yanked = all(f.get("yanked", False) for f in files)
+    if not all_yanked:
+        return False, ""
+
+    for f in files:
+        reason = f.get("yanked_reason", "")
+        if reason:
+            return True, str(reason)
+
+    return True, ""
+
+
+def get_latest_version_from_pypi(timeout: int = 2) -> str | None:
+    """Get the latest non-yanked version of CrewAI from PyPI.
+
+    Args:
+        timeout: Request timeout in seconds.
+
+    Returns:
+        Latest non-yanked version string or None if unable to fetch.
+    """
+    cache_file = _get_cache_file()
+    if cache_file.exists():
+        try:
+            cache_data = json.loads(cache_file.read_text())
+            if _is_cache_valid(cache_data) and "current_version" in cache_data:
+                version: str | None = cache_data.get("version")
+                return version
+        except (json.JSONDecodeError, OSError):
+            pass
+
+    try:
+        with request.urlopen(
+            "https://pypi.org/pypi/crewai/json", timeout=timeout
+        ) as response:
+            data = json.loads(response.read())
+            releases: dict[str, list[dict[str, Any]]] = data["releases"]
+            latest_version = _find_latest_non_yanked_version(releases)
+
+            current_version = get_crewai_version()
+            is_yanked, yanked_reason = _is_version_yanked(current_version, releases)
+
+            cache_data = {
+                "version": latest_version,
+                "timestamp": datetime.now().isoformat(),
+                "current_version": current_version,
+                "current_version_yanked": is_yanked,
+                "current_version_yanked_reason": yanked_reason,
+            }
+            cache_file.write_text(json.dumps(cache_data))
+
+            return latest_version
+    except (URLError, json.JSONDecodeError, KeyError, OSError):
+        return None
+
+
+def is_current_version_yanked() -> tuple[bool, str]:
+    """Check if the currently installed version has been yanked on PyPI.
+
+    Reads from cache if available, otherwise triggers a fetch.
+
+    Returns:
+        Tuple of (is_yanked, yanked_reason).
+    """
+    cache_file = _get_cache_file()
+    if cache_file.exists():
+        try:
+            cache_data = json.loads(cache_file.read_text())
+            if _is_cache_valid(cache_data) and "current_version" in cache_data:
+                current = get_crewai_version()
+                if cache_data.get("current_version") == current:
+                    return (
+                        bool(cache_data.get("current_version_yanked", False)),
+                        str(cache_data.get("current_version_yanked_reason", "")),
+                    )
+        except (json.JSONDecodeError, OSError):
+            pass
+
+    get_latest_version_from_pypi()
+
+    try:
+        cache_data = json.loads(cache_file.read_text())
+        return (
+            bool(cache_data.get("current_version_yanked", False)),
+            str(cache_data.get("current_version_yanked_reason", "")),
+        )
+    except (json.JSONDecodeError, OSError):
+        return False, ""
+
+
+def check_version() -> tuple[str, str | None]:
+    """Check current and latest versions.
+
+    Returns:
+        Tuple of (current_version, latest_version).
+        latest_version is None if unable to fetch from PyPI.
+    """
+    current = get_crewai_version()
+    latest = get_latest_version_from_pypi()
+    return current, latest
+
+
+def is_newer_version_available() -> tuple[bool, str, str | None]:
+    """Check if a newer version is available.
+
+    Returns:
+        Tuple of (is_newer, current_version, latest_version).
+    """
+    current, latest = check_version()
+
+    if latest is None:
+        return False, current, None
+
+    try:
+        return parse(latest) > parse(current), current, latest
+    except (InvalidVersion, TypeError):
+        return False, current, latest