Feat/cli deploy (#1240)

* feat: set basic structure deploy commands

* feat: add first iteration of CLI Deploy

* feat: some minor refactor

* feat: Add api, Deploy command and update cli

* feat: Remove test token

* feat: add auth0 lib, update cli and improve code

* feat: update code and decouple auth

* fix: parts of the code

* feat: Add token manager to encrypt access token and get and save tokens

* feat: add audience to costants

* feat: add subsystem saving credentials and remove comment of type hinting

* feat: add get crew version to send on header of request

* feat: add docstrings

* feat: add tests for authentication module

* feat: add tests for utils

* feat: add unit tests for cl

* feat: add tests

* feat: add deploy man tests

* feat: fix type checking issue

* feat: rename tests to pass ci

* feat: fix pr issues

* feat: fix get crewai versoin

* fix: add timeout for tests.yml

src/crewai/cli/authentication/__init__.py

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

src/crewai/cli/authentication/constants.py

@@ -0,0 +1,4 @@
+ALGORITHMS = ["RS256"]
+AUTH0_DOMAIN = "dev-jzsr0j8zs0atl5ha.us.auth0.com"
+AUTH0_CLIENT_ID = "CZtyRHuVW80HbLSjk4ggXNzjg4KAt7Oe"
+AUTH0_AUDIENCE = "https://dev-jzsr0j8zs0atl5ha.us.auth0.com/api/v2/"

src/crewai/cli/authentication/main.py

@@ -0,0 +1,75 @@
+import time
+import webbrowser
+from typing import Any, Dict
+
+import requests
+from rich.console import Console
+
+from .constants import AUTH0_AUDIENCE, AUTH0_CLIENT_ID, AUTH0_DOMAIN
+from .utils import TokenManager, validate_token
+
+console = Console()
+
+
+class AuthenticationCommand:
+    DEVICE_CODE_URL = f"https://{AUTH0_DOMAIN}/oauth/device/code"
+    TOKEN_URL = f"https://{AUTH0_DOMAIN}/oauth/token"
+
+    def __init__(self):
+        self.token_manager = TokenManager()
+
+    def signup(self) -> None:
+        """Sign up to CrewAI+"""
+        console.print("Signing Up to CrewAI+ \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": AUTH0_CLIENT_ID,
+            "scope": "openid",
+            "audience": AUTH0_AUDIENCE,
+        }
+        response = requests.post(url=self.DEVICE_CODE_URL, data=device_code_payload)
+        response.raise_for_status()
+        return response.json()
+
+    def _display_auth_instructions(self, device_code_data: Dict[str, str]) -> None:
+        """Display the authentication instructions to the user."""
+        console.print("1. Navigate to: ", device_code_data["verification_uri_complete"])
+        console.print("2. Enter the following code: ", device_code_data["user_code"])
+        webbrowser.open(device_code_data["verification_uri_complete"])
+
+    def _poll_for_token(self, device_code_data: Dict[str, Any]) -> None:
+        """Poll the server for the token."""
+        token_payload = {
+            "grant_type": "urn:ietf:params:oauth:grant-type:device_code",
+            "device_code": device_code_data["device_code"],
+            "client_id": AUTH0_CLIENT_ID,
+        }
+
+        attempts = 0
+        while True and attempts < 5:
+            response = requests.post(self.TOKEN_URL, data=token_payload)
+            token_data = response.json()
+
+            if response.status_code == 200:
+                validate_token(token_data["id_token"])
+                expires_in = 360000  # Token expiration time in seconds
+                self.token_manager.save_tokens(token_data["access_token"], expires_in)
+                console.print("\nWelcome to CrewAI+ !!", style="green")
+                return
+
+            if token_data["error"] not in ("authorization_pending", "slow_down"):
+                raise requests.HTTPError(token_data["error_description"])
+
+            time.sleep(device_code_data["interval"])
+            attempts += 1
+
+        console.print(
+            "Timeout: Failed to get the token. Please try again.", style="bold red"
+        )

src/crewai/cli/authentication/utils.py

@@ -0,0 +1,144 @@
+import json
+import os
+import sys
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Optional
+
+from auth0.authentication.token_verifier import (
+    AsymmetricSignatureVerifier,
+    TokenVerifier,
+)
+from cryptography.fernet import Fernet
+
+from .constants import AUTH0_CLIENT_ID, AUTH0_DOMAIN
+
+
+def validate_token(id_token: str) -> None:
+    """
+    Verify the token and its precedence
+
+    :param id_token:
+    """
+    jwks_url = f"https://{AUTH0_DOMAIN}/.well-known/jwks.json"
+    issuer = f"https://{AUTH0_DOMAIN}/"
+    signature_verifier = AsymmetricSignatureVerifier(jwks_url)
+    token_verifier = TokenVerifier(
+        signature_verifier=signature_verifier, issuer=issuer, audience=AUTH0_CLIENT_ID
+    )
+    token_verifier.verify(id_token)
+
+
+class TokenManager:
+    def __init__(self, file_path: str = "tokens.enc") -> None:
+        """
+        Initialize the TokenManager class.
+
+        :param file_path: The file path to store the encrypted tokens. Default is "tokens.enc".
+        """
+        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.
+
+        :return: The encryption key.
+        """
+        key_filename = "secret.key"
+        key = self.read_secure_file(key_filename)
+
+        if key is not None:
+            return key
+
+        new_key = Fernet.generate_key()
+        self.save_secure_file(key_filename, new_key)
+        return new_key
+
+    def save_tokens(self, access_token: str, expires_in: int) -> None:
+        """
+        Save the access token and its expiration time.
+
+        :param access_token: The access token to save.
+        :param expires_in: The expiration time of the access token in seconds.
+        """
+        expiration_time = datetime.now() + timedelta(seconds=expires_in)
+        data = {
+            "access_token": access_token,
+            "expiration": expiration_time.isoformat(),
+        }
+        encrypted_data = self.fernet.encrypt(json.dumps(data).encode())
+        self.save_secure_file(self.file_path, encrypted_data)
+
+    def get_token(self) -> Optional[str]:
+        """
+        Get the access token if it is valid and not expired.
+
+        :return: The access token if valid and not expired, otherwise None.
+        """
+        encrypted_data = self.read_secure_file(self.file_path)
+
+        decrypted_data = self.fernet.decrypt(encrypted_data)
+        data = json.loads(decrypted_data)
+
+        expiration = datetime.fromisoformat(data["expiration"])
+        if expiration <= datetime.now():
+            return None
+
+        return data["access_token"]
+
+    def get_secure_storage_path(self) -> Path:
+        """
+        Get the secure storage path based on the operating system.
+
+        :return: The secure storage path.
+        """
+        if sys.platform == "win32":
+            # Windows: Use %LOCALAPPDATA%
+            base_path = os.environ.get("LOCALAPPDATA")
+        elif sys.platform == "darwin":
+            # macOS: Use ~/Library/Application Support
+            base_path = os.path.expanduser("~/Library/Application Support")
+        else:
+            # Linux and other Unix-like: Use ~/.local/share
+            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 save_secure_file(self, filename: str, content: bytes) -> None:
+        """
+        Save the content to a secure file.
+
+        :param filename: The name of the file.
+        :param content: The content to save.
+        """
+        storage_path = self.get_secure_storage_path()
+        file_path = storage_path / filename
+
+        with open(file_path, "wb") as f:
+            f.write(content)
+
+        # Set appropriate permissions (read/write for owner only)
+        os.chmod(file_path, 0o600)
+
+    def read_secure_file(self, filename: str) -> Optional[bytes]:
+        """
+        Read the content of a secure file.
+
+        :param filename: The name of the file.
+        :return: The content of the file if it exists, otherwise None.
+        """
+        storage_path = self.get_secure_storage_path()
+        file_path = storage_path / filename
+
+        if not file_path.exists():
+            return None
+
+        with open(file_path, "rb") as f:
+            return f.read()

src/crewai/cli/cli.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 import click
 import pkg_resources
 
@@ -7,6 +9,8 @@ from crewai.memory.storage.kickoff_task_outputs_storage import (
     KickoffTaskOutputsSQLiteStorage,
 )
 
+from .authentication.main import AuthenticationCommand
+from .deploy.main import DeployCommand
 from .evaluate_crew import evaluate_crew
 from .install_crew import install_crew
 from .replay_from_task import replay_task_command
@@ -179,5 +183,70 @@ def run():
     run_crew()
 
 
+@crewai.command()
+def signup():
+    """Sign Up/Login to CrewAI+."""
+    AuthenticationCommand().signup()
+
+
+@crewai.command()
+def login():
+    """Sign Up/Login to CrewAI+."""
+    AuthenticationCommand().signup()
+
+
+# DEPLOY CREWAI+ COMMANDS
+@crewai.group()
+def deploy():
+    """Deploy the Crew CLI group."""
+    pass
+
+
+@deploy.command(name="create")
+def deploy_create():
+    """Create a Crew deployment."""
+    deploy_cmd = DeployCommand()
+    deploy_cmd.create_crew()
+
+
+@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: Optional[str]):
+    """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: Optional[str]):
+    """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: Optional[str]):
+    """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: Optional[str]):
+    """Remove a deployment."""
+    deploy_cmd = DeployCommand()
+    deploy_cmd.remove_crew(uuid=uuid)
+
+
 if __name__ == "__main__":
     crewai()

src/crewai/cli/deploy/api.py

@@ -0,0 +1,63 @@
+from os import getenv
+
+import requests
+
+
+class CrewAPI:
+    """
+    CrewAPI class to interact with the crewAI+ API.
+    """
+
+    def __init__(self, api_key: str) -> None:
+        self.api_key = api_key
+        self.headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+        }
+        self.base_url = getenv(
+            "CREWAI_BASE_URL", "https://dev.crewai.com/crewai_plus/api/v1/crews"
+        )
+
+    def _make_request(self, method: str, endpoint: str, **kwargs) -> requests.Response:
+        url = f"{self.base_url}/{endpoint}"
+        return requests.request(method, url, headers=self.headers, **kwargs)
+
+    # Deploy
+    def deploy_by_name(self, project_name: str) -> requests.Response:
+        return self._make_request("POST", f"by-name/{project_name}/deploy")
+
+    def deploy_by_uuid(self, uuid: str) -> requests.Response:
+        return self._make_request("POST", f"{uuid}/deploy")
+
+    # Status
+    def status_by_name(self, project_name: str) -> requests.Response:
+        return self._make_request("GET", f"by-name/{project_name}/status")
+
+    def status_by_uuid(self, uuid: str) -> requests.Response:
+        return self._make_request("GET", f"{uuid}/status")
+
+    # Logs
+    def logs_by_name(
+        self, project_name: str, log_type: str = "deployment"
+    ) -> requests.Response:
+        return self._make_request("GET", f"by-name/{project_name}/logs/{log_type}")
+
+    def logs_by_uuid(
+        self, uuid: str, log_type: str = "deployment"
+    ) -> requests.Response:
+        return self._make_request("GET", f"{uuid}/logs/{log_type}")
+
+    # Delete
+    def delete_by_name(self, project_name: str) -> requests.Response:
+        return self._make_request("DELETE", f"by-name/{project_name}")
+
+    def delete_by_uuid(self, uuid: str) -> requests.Response:
+        return self._make_request("DELETE", f"{uuid}")
+
+    # List
+    def list_crews(self) -> requests.Response:
+        return self._make_request("GET", "")
+
+    # Create
+    def create_crew(self, payload) -> requests.Response:
+        return self._make_request("POST", "", json=payload)

src/crewai/cli/deploy/main.py

@@ -0,0 +1,289 @@
+from typing import Any, Dict, List, Optional
+
+from rich.console import Console
+
+from .api import CrewAPI
+from .utils import (
+    fetch_and_json_env_file,
+    get_auth_token,
+    get_git_remote_url,
+    get_project_name,
+)
+
+console = Console()
+
+
+class DeployCommand:
+    """
+    A class to handle deployment-related operations for CrewAI projects.
+    """
+
+    def __init__(self):
+        """
+        Initialize the DeployCommand with project name and API client.
+        """
+        try:
+            access_token = get_auth_token()
+        except Exception:
+            console.print(
+                "Please sign up/login to CrewAI+ before using the CLI.",
+                style="bold red",
+            )
+            console.print("Run 'crewai signup' to sign up/login.", style="bold green")
+            raise SystemExit
+
+        self.project_name = get_project_name()
+        self.client = CrewAPI(api_key=access_token)
+
+    def _handle_error(self, json_response: Dict[str, Any]) -> None:
+        """
+        Handle and display error messages from API responses.
+
+        Args:
+            json_response (Dict[str, Any]): The JSON response containing error information.
+        """
+        error = json_response.get("error", "Unknown error")
+        message = json_response.get("message", "No message provided")
+        console.print(f"Error: {error}", style="bold red")
+        console.print(f"Message: {message}", style="bold red")
+
+    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: Optional[str] = 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.client.deploy_by_uuid(uuid)
+        elif self.project_name:
+            response = self.client.deploy_by_name(self.project_name)
+        else:
+            self._standard_no_param_error_message()
+            return
+
+        json_response = response.json()
+        if response.status_code == 200:
+            self._display_deployment_info(json_response)
+        else:
+            self._handle_error(json_response)
+
+    def create_crew(self) -> None:
+        """
+        Create a new crew deployment.
+        """
+        console.print("Creating deployment...", style="bold blue")
+        env_vars = fetch_and_json_env_file()
+        remote_repo_url = get_git_remote_url()
+
+        self._confirm_input(env_vars, remote_repo_url)
+        payload = self._create_payload(env_vars, remote_repo_url)
+
+        response = self.client.create_crew(payload)
+        if response.status_code == 201:
+            self._display_creation_success(response.json())
+        else:
+            self._handle_error(response.json())
+
+    def _confirm_input(self, env_vars: Dict[str, str], remote_repo_url: str) -> None:
+        """
+        Confirm input parameters with the user.
+
+        Args:
+            env_vars (Dict[str, str]): Environment variables.
+            remote_repo_url (str): Remote repository URL.
+        """
+        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.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: Optional[str] = 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.client.status_by_uuid(uuid)
+        elif self.project_name:
+            response = self.client.status_by_name(self.project_name)
+        else:
+            self._standard_no_param_error_message()
+            return
+
+        json_response = response.json()
+        if response.status_code == 200:
+            self._display_crew_status(json_response)
+        else:
+            self._handle_error(json_response)
+
+    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: Optional[str], 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.client.logs_by_uuid(uuid, log_type)
+        elif self.project_name:
+            response = self.client.logs_by_name(self.project_name, log_type)
+        else:
+            self._standard_no_param_error_message()
+            return
+
+        if response.status_code == 200:
+            self._display_logs(response.json())
+        else:
+            self._handle_error(response.json())
+
+    def remove_crew(self, uuid: Optional[str]) -> 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.client.delete_by_uuid(uuid)
+        elif self.project_name:
+            response = self.client.delete_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"
+            )

src/crewai/cli/deploy/utils.py

@@ -0,0 +1,117 @@
+import re
+import subprocess
+
+import tomllib
+
+from ..authentication.utils import TokenManager
+
+
+def get_git_remote_url() -> str:
+    """Get the Git repository's remote URL."""
+    try:
+        # Run the git remote -v command
+        result = subprocess.run(
+            ["git", "remote", "-v"], capture_output=True, text=True, check=True
+        )
+
+        # Get the output
+        output = result.stdout
+
+        # Parse the output to find the origin URL
+        matches = re.findall(r"origin\s+(.*?)\s+\(fetch\)", output)
+
+        if matches:
+            return matches[0]  # Return the first match (origin URL)
+        else:
+            print("No origin remote found.")
+            return "No remote URL found"
+
+    except subprocess.CalledProcessError as e:
+        return f"Error running trying to fetch the Git Repository: {e}"
+    except FileNotFoundError:
+        return "Git command not found. Make sure Git is installed and in your PATH."
+
+
+def get_project_name(pyproject_path: str = "pyproject.toml"):
+    """Get the project name from the pyproject.toml file."""
+    try:
+        # Read the pyproject.toml file
+        with open(pyproject_path, "rb") as f:
+            pyproject_content = tomllib.load(f)
+
+        # Extract the project name
+        project_name = pyproject_content["tool"]["poetry"]["name"]
+
+        if "crewai" not in pyproject_content["tool"]["poetry"]["dependencies"]:
+            raise Exception("crewai is not in the dependencies.")
+
+        return project_name
+
+    except FileNotFoundError:
+        print(f"Error: {pyproject_path} not found.")
+    except KeyError:
+        print(f"Error: {pyproject_path} is not a valid pyproject.toml file.")
+    except tomllib.TOMLDecodeError:
+        print(f"Error: {pyproject_path} is not a valid TOML file.")
+    except Exception as e:
+        print(f"Error reading the pyproject.toml file: {e}")
+
+    return None
+
+
+def get_crewai_version(pyproject_path: str = "pyproject.toml") -> str:
+    """Get the version number of crewai from the pyproject.toml file."""
+    try:
+        # Read the pyproject.toml file
+        with open("pyproject.toml", "rb") as f:
+            pyproject_content = tomllib.load(f)
+
+        # Extract the version number of crewai
+        crewai_version = pyproject_content["tool"]["poetry"]["dependencies"]["crewai"][
+            "version"
+        ]
+
+        return crewai_version
+
+    except FileNotFoundError:
+        print(f"Error: {pyproject_path} not found.")
+    except KeyError:
+        print(f"Error: {pyproject_path} is not a valid pyproject.toml file.")
+    except tomllib.TOMLDecodeError:
+        print(f"Error: {pyproject_path} is not a valid TOML file.")
+    except Exception as e:
+        print(f"Error reading the pyproject.toml file: {e}")
+
+    return "no-version-found"
+
+
+def fetch_and_json_env_file(env_file_path: str = ".env") -> dict:
+    """Fetch the environment variables from a .env file and return them as a dictionary."""
+    try:
+        # Read the .env file
+        with open(env_file_path, "r") as f:
+            env_content = f.read()
+
+        # Parse the .env file content to a dictionary
+        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:
+        print(f"Error: {env_file_path} not found.")
+    except Exception as e:
+        print(f"Error reading the .env file: {e}")
+
+    return {}
+
+
+def get_auth_token() -> str:
+    """Get the authentication token."""
+    access_token = TokenManager().get_token()
+    if not access_token:
+        raise Exception()
+    return access_token

src/crewai/memory/memory.py

@@ -21,7 +21,7 @@ class Memory:
         if agent:
             metadata["agent"] = agent
 
-        self.storage.save(value, metadata)  # type: ignore # Maybe BUG? Should be self.storage.save(key, value, metadata)
+        self.storage.save(value, metadata)
 
     def search(self, query: str) -> Dict[str, Any]:
         return self.storage.search(query)