CLI for Tool Repository (#1357)

This commit adds two commands to the CLI:

- `crewai tool publish`
    - Builds the project using Poetry
    - Uploads the tarball to CrewAI's tool repository

- `crewai tool install my-tool`
    - Adds my-tool's index to Poetry and its credentials
    - Installs my-tool from the custom index

tests/cli/deploy/test_deploy_main.py

@@ -8,34 +8,34 @@ from crewai.cli.utils import parse_toml
 
 
 class TestDeployCommand(unittest.TestCase):
-    @patch("crewai.cli.deploy.main.get_auth_token")
+    @patch("crewai.cli.command.get_auth_token")
     @patch("crewai.cli.deploy.main.get_project_name")
-    @patch("crewai.cli.deploy.main.CrewAPI")
-    def setUp(self, mock_crew_api, mock_get_project_name, mock_get_auth_token):
+    @patch("crewai.cli.command.PlusAPI")
+    def setUp(self, mock_plus_api, mock_get_project_name, mock_get_auth_token):
         self.mock_get_auth_token = mock_get_auth_token
         self.mock_get_project_name = mock_get_project_name
-        self.mock_crew_api = mock_crew_api
+        self.mock_plus_api = mock_plus_api
 
         self.mock_get_auth_token.return_value = "test_token"
         self.mock_get_project_name.return_value = "test_project"
 
         self.deploy_command = DeployCommand()
-        self.mock_client = self.deploy_command.client
+        self.mock_client = self.deploy_command.plus_api_client
 
     def test_init_success(self):
         self.assertEqual(self.deploy_command.project_name, "test_project")
-        self.mock_crew_api.assert_called_once_with(api_key="test_token")
+        self.mock_plus_api.assert_called_once_with(api_key="test_token")
 
-    @patch("crewai.cli.deploy.main.get_auth_token")
+    @patch("crewai.cli.command.get_auth_token")
     def test_init_failure(self, mock_get_auth_token):
         mock_get_auth_token.side_effect = Exception("Auth failed")
 
         with self.assertRaises(SystemExit):
             DeployCommand()
 
-    def test_handle_error(self):
+    def test_handle_plus_api_error(self):
         with patch("sys.stdout", new=StringIO()) as fake_out:
-            self.deploy_command._handle_error(
+            self.deploy_command._handle_plus_api_error(
                 {"error": "Test error", "message": "Test message"}
             )
             self.assertIn("Error: Test error", fake_out.getvalue())
@@ -122,7 +122,7 @@ class TestDeployCommand(unittest.TestCase):
         mock_response = MagicMock()
         mock_response.status_code = 200
         mock_response.json.return_value = {"name": "TestCrew", "status": "active"}
-        self.mock_client.status_by_name.return_value = mock_response
+        self.mock_client.crew_status_by_name.return_value = mock_response
 
         with patch("sys.stdout", new=StringIO()) as fake_out:
             self.deploy_command.get_crew_status()
@@ -136,7 +136,7 @@ class TestDeployCommand(unittest.TestCase):
             {"timestamp": "2023-01-01", "level": "INFO", "message": "Log1"},
             {"timestamp": "2023-01-02", "level": "ERROR", "message": "Log2"},
         ]
-        self.mock_client.logs_by_name.return_value = mock_response
+        self.mock_client.crew_by_name.return_value = mock_response
 
         with patch("sys.stdout", new=StringIO()) as fake_out:
             self.deploy_command.get_crew_logs(None)
@@ -146,7 +146,7 @@ class TestDeployCommand(unittest.TestCase):
     def test_remove_crew(self):
         mock_response = MagicMock()
         mock_response.status_code = 204
-        self.mock_client.delete_by_name.return_value = mock_response
+        self.mock_client.delete_crew_by_name.return_value = mock_response
 
         with patch("sys.stdout", new=StringIO()) as fake_out:
             self.deploy_command.remove_crew(None)

tests/cli/test_plus_api.py

@@ -1,14 +1,13 @@
+import os
 import unittest
-from os import environ
 from unittest.mock import MagicMock, patch
-
-from crewai.cli.deploy.api import CrewAPI
+from crewai.cli.plus_api import PlusAPI
 
 
-class TestCrewAPI(unittest.TestCase):
+class TestPlusAPI(unittest.TestCase):
     def setUp(self):
         self.api_key = "test_api_key"
-        self.api = CrewAPI(self.api_key)
+        self.api = PlusAPI(self.api_key)
 
     def test_init(self):
         self.assertEqual(self.api.api_key, self.api_key)
@@ -22,6 +21,70 @@ class TestCrewAPI(unittest.TestCase):
             },
         )
 
+    @patch("crewai.cli.plus_api.PlusAPI._make_request")
+    def test_get_tool(self, mock_make_request):
+        mock_response = MagicMock()
+        mock_make_request.return_value = mock_response
+
+        response = self.api.get_tool("test_tool_handle")
+
+        mock_make_request.assert_called_once_with(
+            "GET", "/crewai_plus/api/v1/tools/test_tool_handle"
+        )
+        self.assertEqual(response, mock_response)
+
+    @patch("crewai.cli.plus_api.PlusAPI._make_request")
+    def test_publish_tool(self, mock_make_request):
+        mock_response = MagicMock()
+        mock_make_request.return_value = mock_response
+        handle = "test_tool_handle"
+        public = True
+        version = "1.0.0"
+        description = "Test tool description"
+        encoded_file = "encoded_test_file"
+
+        response = self.api.publish_tool(
+            handle, public, version, description, encoded_file
+        )
+
+        params = {
+            "handle": handle,
+            "public": public,
+            "version": version,
+            "file": encoded_file,
+            "description": description,
+        }
+        mock_make_request.assert_called_once_with(
+            "POST", "/crewai_plus/api/v1/tools", json=params
+        )
+        self.assertEqual(response, mock_response)
+
+    @patch("crewai.cli.plus_api.PlusAPI._make_request")
+    def test_publish_tool_without_description(self, mock_make_request):
+        mock_response = MagicMock()
+        mock_make_request.return_value = mock_response
+        handle = "test_tool_handle"
+        public = False
+        version = "2.0.0"
+        description = None
+        encoded_file = "encoded_test_file"
+
+        response = self.api.publish_tool(
+            handle, public, version, description, encoded_file
+        )
+
+        params = {
+            "handle": handle,
+            "public": public,
+            "version": version,
+            "file": encoded_file,
+            "description": description,
+        }
+        mock_make_request.assert_called_once_with(
+            "POST", "/crewai_plus/api/v1/tools", json=params
+        )
+        self.assertEqual(response, mock_response)
+
     @patch("crewai.cli.plus_api.requests.request")
     def test_make_request(self, mock_request):
         mock_response = MagicMock()
@@ -49,53 +112,53 @@ class TestCrewAPI(unittest.TestCase):
         )
 
     @patch("crewai.cli.plus_api.PlusAPI._make_request")
-    def test_status_by_name(self, mock_make_request):
-        self.api.status_by_name("test_project")
+    def test_crew_status_by_name(self, mock_make_request):
+        self.api.crew_status_by_name("test_project")
         mock_make_request.assert_called_once_with(
             "GET", "/crewai_plus/api/v1/crews/by-name/test_project/status"
         )
 
     @patch("crewai.cli.plus_api.PlusAPI._make_request")
-    def test_status_by_uuid(self, mock_make_request):
-        self.api.status_by_uuid("test_uuid")
+    def test_crew_status_by_uuid(self, mock_make_request):
+        self.api.crew_status_by_uuid("test_uuid")
         mock_make_request.assert_called_once_with(
             "GET", "/crewai_plus/api/v1/crews/test_uuid/status"
         )
 
     @patch("crewai.cli.plus_api.PlusAPI._make_request")
-    def test_logs_by_name(self, mock_make_request):
-        self.api.logs_by_name("test_project")
+    def test_crew_by_name(self, mock_make_request):
+        self.api.crew_by_name("test_project")
         mock_make_request.assert_called_once_with(
             "GET", "/crewai_plus/api/v1/crews/by-name/test_project/logs/deployment"
         )
 
-        self.api.logs_by_name("test_project", "custom_log")
+        self.api.crew_by_name("test_project", "custom_log")
         mock_make_request.assert_called_with(
             "GET", "/crewai_plus/api/v1/crews/by-name/test_project/logs/custom_log"
         )
 
     @patch("crewai.cli.plus_api.PlusAPI._make_request")
-    def test_logs_by_uuid(self, mock_make_request):
-        self.api.logs_by_uuid("test_uuid")
+    def test_crew_by_uuid(self, mock_make_request):
+        self.api.crew_by_uuid("test_uuid")
         mock_make_request.assert_called_once_with(
             "GET", "/crewai_plus/api/v1/crews/test_uuid/logs/deployment"
         )
 
-        self.api.logs_by_uuid("test_uuid", "custom_log")
+        self.api.crew_by_uuid("test_uuid", "custom_log")
         mock_make_request.assert_called_with(
             "GET", "/crewai_plus/api/v1/crews/test_uuid/logs/custom_log"
         )
 
     @patch("crewai.cli.plus_api.PlusAPI._make_request")
-    def test_delete_by_name(self, mock_make_request):
-        self.api.delete_by_name("test_project")
+    def test_delete_crew_by_name(self, mock_make_request):
+        self.api.delete_crew_by_name("test_project")
         mock_make_request.assert_called_once_with(
             "DELETE", "/crewai_plus/api/v1/crews/by-name/test_project"
         )
 
     @patch("crewai.cli.plus_api.PlusAPI._make_request")
-    def test_delete_by_uuid(self, mock_make_request):
-        self.api.delete_by_uuid("test_uuid")
+    def test_delete_crew_by_uuid(self, mock_make_request):
+        self.api.delete_crew_by_uuid("test_uuid")
         mock_make_request.assert_called_once_with(
             "DELETE", "/crewai_plus/api/v1/crews/test_uuid"
         )
@@ -105,7 +168,7 @@ class TestCrewAPI(unittest.TestCase):
         self.api.list_crews()
         mock_make_request.assert_called_once_with("GET", "/crewai_plus/api/v1/crews")
 
-    @patch("crewai.cli.deploy.api.CrewAPI._make_request")
+    @patch("crewai.cli.plus_api.PlusAPI._make_request")
     def test_create_crew(self, mock_make_request):
         payload = {"name": "test_crew"}
         self.api.create_crew(payload)
@@ -113,9 +176,9 @@ class TestCrewAPI(unittest.TestCase):
             "POST", "/crewai_plus/api/v1/crews", json=payload
         )
 
-    @patch.dict(environ, {"CREWAI_BASE_URL": "https://custom-url.com/api"})
+    @patch.dict(os.environ, {"CREWAI_BASE_URL": "https://custom-url.com/api"})
     def test_custom_base_url(self):
-        custom_api = CrewAPI("test_key")
+        custom_api = PlusAPI("test_key")
         self.assertEqual(
             custom_api.base_url,
             "https://custom-url.com/api",

tests/cli/tools/test_api.py

@@ -1,69 +0,0 @@
-import unittest
-from unittest.mock import MagicMock, patch
-from crewai.cli.tools.api import ToolsAPI
-
-
-class TestToolsAPI(unittest.TestCase):
-    def setUp(self):
-        self.api_key = "test_api_key"
-        self.api = ToolsAPI(self.api_key)
-
-    @patch("crewai.cli.plus_api.PlusAPI._make_request")
-    def test_get_tool(self, mock_make_request):
-        mock_response = MagicMock()
-        mock_make_request.return_value = mock_response
-
-        response = self.api.get("test_tool_handle")
-
-        mock_make_request.assert_called_once_with(
-            "GET", "/crewai_plus/api/v1/tools/test_tool_handle"
-        )
-        self.assertEqual(response, mock_response)
-
-    @patch("crewai.cli.plus_api.PlusAPI._make_request")
-    def test_publish_tool(self, mock_make_request):
-        mock_response = MagicMock()
-        mock_make_request.return_value = mock_response
-        handle = "test_tool_handle"
-        public = True
-        version = "1.0.0"
-        description = "Test tool description"
-        encoded_file = "encoded_test_file"
-
-        response = self.api.publish(handle, public, version, description, encoded_file)
-
-        params = {
-            "handle": handle,
-            "public": public,
-            "version": version,
-            "file": encoded_file,
-            "description": description,
-        }
-        mock_make_request.assert_called_once_with(
-            "POST", "/crewai_plus/api/v1/tools", json=params
-        )
-        self.assertEqual(response, mock_response)
-
-    @patch("crewai.cli.plus_api.PlusAPI._make_request")
-    def test_publish_tool_without_description(self, mock_make_request):
-        mock_response = MagicMock()
-        mock_make_request.return_value = mock_response
-        handle = "test_tool_handle"
-        public = False
-        version = "2.0.0"
-        description = None
-        encoded_file = "encoded_test_file"
-
-        response = self.api.publish(handle, public, version, description, encoded_file)
-
-        params = {
-            "handle": handle,
-            "public": public,
-            "version": version,
-            "file": encoded_file,
-            "description": description,
-        }
-        mock_make_request.assert_called_once_with(
-            "POST", "/crewai_plus/api/v1/tools", json=params
-        )
-        self.assertEqual(response, mock_response)

tests/cli/tools/test_main.py

@@ -0,0 +1,229 @@
+import unittest
+import unittest.mock
+from crewai.cli.tools.main import ToolCommand
+from io import StringIO
+from unittest.mock import patch, MagicMock
+
+
+class TestToolCommand(unittest.TestCase):
+    @patch("crewai.cli.tools.main.subprocess.run")
+    @patch("crewai.cli.plus_api.PlusAPI.get_tool")
+    def test_install_success(self, mock_get, mock_subprocess_run):
+        mock_get_response = MagicMock()
+        mock_get_response.status_code = 200
+        mock_get_response.json.return_value = {
+            "handle": "sample-tool",
+            "repository": {
+                "handle": "sample-repo",
+                "url": "https://example.com/repo",
+                "credentials": "my_very_secret",
+            },
+        }
+        mock_get.return_value = mock_get_response
+        mock_subprocess_run.return_value = MagicMock(stderr=None)
+
+        tool_command = ToolCommand()
+
+        with patch("sys.stdout", new=StringIO()) as fake_out:
+            tool_command.install("sample-tool")
+            output = fake_out.getvalue()
+
+        mock_get.assert_called_once_with("sample-tool")
+        mock_subprocess_run.assert_any_call(
+            [
+                "poetry",
+                "source",
+                "add",
+                "--priority=explicit",
+                "crewai-sample-repo",
+                "https://example.com/repo",
+            ],
+            text=True,
+            check=True,
+        )
+        mock_subprocess_run.assert_any_call(
+            [
+                "poetry",
+                "config",
+                "http-basic.crewai-sample-repo",
+                "my_very_secret",
+                '""',
+            ],
+            capture_output=False,
+            text=True,
+            check=True,
+        )
+        mock_subprocess_run.assert_any_call(
+            ["poetry", "add", "--source", "crewai-sample-repo", "sample-tool"],
+            capture_output=False,
+            text=True,
+            check=True,
+        )
+
+        self.assertIn("Succesfully installed sample-tool", output)
+
+    @patch("crewai.cli.plus_api.PlusAPI.get_tool")
+    def test_install_tool_not_found(self, mock_get):
+        mock_get_response = MagicMock()
+        mock_get_response.status_code = 404
+        mock_get.return_value = mock_get_response
+
+        tool_command = ToolCommand()
+
+        with patch("sys.stdout", new=StringIO()) as fake_out:
+            with self.assertRaises(SystemExit):
+                tool_command.install("non-existent-tool")
+            output = fake_out.getvalue()
+
+        mock_get.assert_called_once_with("non-existent-tool")
+        self.assertIn("No tool found with this name", output)
+
+    @patch("crewai.cli.plus_api.PlusAPI.get_tool")
+    def test_install_api_error(self, mock_get):
+        mock_get_response = MagicMock()
+        mock_get_response.status_code = 500
+        mock_get.return_value = mock_get_response
+
+        tool_command = ToolCommand()
+
+        with patch("sys.stdout", new=StringIO()) as fake_out:
+            with self.assertRaises(SystemExit):
+                tool_command.install("error-tool")
+            output = fake_out.getvalue()
+
+        mock_get.assert_called_once_with("error-tool")
+        self.assertIn("Failed to get tool details", output)
+
+    @patch("crewai.cli.tools.main.get_project_name", return_value="sample-tool")
+    @patch("crewai.cli.tools.main.get_project_version", return_value="1.0.0")
+    @patch(
+        "crewai.cli.tools.main.get_project_description", return_value="A sample tool"
+    )
+    @patch("crewai.cli.tools.main.subprocess.run")
+    @patch(
+        "crewai.cli.tools.main.os.listdir", return_value=["sample-tool-1.0.0.tar.gz"]
+    )
+    @patch(
+        "crewai.cli.tools.main.open",
+        new_callable=unittest.mock.mock_open,
+        read_data=b"sample tarball content",
+    )
+    @patch("crewai.cli.plus_api.PlusAPI.publish_tool")
+    def test_publish_success(
+        self,
+        mock_publish,
+        mock_open,
+        mock_listdir,
+        mock_subprocess_run,
+        mock_get_project_description,
+        mock_get_project_version,
+        mock_get_project_name,
+    ):
+        mock_publish_response = MagicMock()
+        mock_publish_response.status_code = 200
+        mock_publish_response.json.return_value = {"handle": "sample-tool"}
+        mock_publish.return_value = mock_publish_response
+
+        tool_command = ToolCommand()
+        tool_command.publish(is_public=True)
+
+        mock_get_project_name.assert_called_once_with(require=True)
+        mock_get_project_version.assert_called_once_with(require=True)
+        mock_get_project_description.assert_called_once_with(require=False)
+        mock_subprocess_run.assert_called_once_with(
+            ["poetry", "build", "-f", "sdist", "--output", unittest.mock.ANY],
+            check=True,
+            capture_output=False,
+        )
+        mock_open.assert_called_once_with(unittest.mock.ANY, "rb")
+        mock_publish.assert_called_once_with(
+            handle="sample-tool",
+            is_public=True,
+            version="1.0.0",
+            description="A sample tool",
+            encoded_file=unittest.mock.ANY,
+        )
+
+    @patch("crewai.cli.tools.main.get_project_name", return_value="sample-tool")
+    @patch("crewai.cli.tools.main.get_project_version", return_value="1.0.0")
+    @patch(
+        "crewai.cli.tools.main.get_project_description", return_value="A sample tool"
+    )
+    @patch("crewai.cli.tools.main.subprocess.run")
+    @patch(
+        "crewai.cli.tools.main.os.listdir", return_value=["sample-tool-1.0.0.tar.gz"]
+    )
+    @patch(
+        "crewai.cli.tools.main.open",
+        new_callable=unittest.mock.mock_open,
+        read_data=b"sample tarball content",
+    )
+    @patch("crewai.cli.plus_api.PlusAPI.publish_tool")
+    def test_publish_failure(
+        self,
+        mock_publish,
+        mock_open,
+        mock_listdir,
+        mock_subprocess_run,
+        mock_get_project_description,
+        mock_get_project_version,
+        mock_get_project_name,
+    ):
+        mock_publish_response = MagicMock()
+        mock_publish_response.status_code = 422
+        mock_publish_response.json.return_value = {"name": ["is already taken"]}
+        mock_publish.return_value = mock_publish_response
+
+        tool_command = ToolCommand()
+
+        with patch("sys.stdout", new=StringIO()) as fake_out:
+            with self.assertRaises(SystemExit):
+                tool_command.publish(is_public=True)
+            output = fake_out.getvalue()
+
+        mock_publish.assert_called_once()
+        self.assertIn("Failed to publish tool", output)
+        self.assertIn("Name is already taken", output)
+
+    @patch("crewai.cli.tools.main.get_project_name", return_value="sample-tool")
+    @patch("crewai.cli.tools.main.get_project_version", return_value="1.0.0")
+    @patch(
+        "crewai.cli.tools.main.get_project_description", return_value="A sample tool"
+    )
+    @patch("crewai.cli.tools.main.subprocess.run")
+    @patch(
+        "crewai.cli.tools.main.os.listdir", return_value=["sample-tool-1.0.0.tar.gz"]
+    )
+    @patch(
+        "crewai.cli.tools.main.open",
+        new_callable=unittest.mock.mock_open,
+        read_data=b"sample tarball content",
+    )
+    @patch("crewai.cli.plus_api.PlusAPI.publish_tool")
+    def test_publish_api_error(
+        self,
+        mock_publish,
+        mock_open,
+        mock_listdir,
+        mock_subprocess_run,
+        mock_get_project_description,
+        mock_get_project_version,
+        mock_get_project_name,
+    ):
+        mock_publish_response = MagicMock()
+        mock_publish_response.status_code = 500
+        mock_publish.return_value = mock_publish_response
+
+        tool_command = ToolCommand()
+
+        with patch("sys.stdout", new=StringIO()) as fake_out:
+            with self.assertRaises(SystemExit):
+                tool_command.publish(is_public=True)
+            output = fake_out.getvalue()
+
+        mock_publish.assert_called_once()
+        self.assertIn("Failed to publish tool", output)
+
+
+if __name__ == "__main__":
+    unittest.main()