chore: fix format (#37)

Signed-off-by: Ivan Pedrazas <ipedrazas@gmail.com>
Co-authored-by: Sergey Ivanov <sergey@shuttle.dev>

Author: ipedrazas

src/neptune_cli/cli.py

@@ -1,10 +1,6 @@
-import os
-
 import click
-from loguru import logger as log
 
 from neptune_cli.auth import serve_callback_handler
-from neptune_cli.client import Client
 from neptune_cli.config import SETTINGS
 from neptune_cli.mcp import mcp as mcp_server
 

src/neptune_cli/client.py

@@ -49,21 +49,25 @@ def get_project(self, project_name: str) -> GetProjectResponse | None:
         response = requests.get(self._mk_url(f"/project/{project_name}"), headers=self._get_headers())
         if response.status_code == 404:
             return None
+        response.raise_for_status()
         return GetProjectResponse.model_validate(response.json())
 
     def create_deployment(self, project_name: str) -> PostDeploymentResponse:
         response = requests.post(self._mk_url(f"/project/{project_name}/deploy"), headers=self._get_headers())
+        response.raise_for_status()
         return PostDeploymentResponse.model_validate(response.json())
 
     def get_deployment(self, project_name: str, revision: str | int = "latest") -> PostDeploymentResponse:
         response = requests.get(
             self._mk_url(f"/project/{project_name}/deploy/{revision}"),
             headers=self._get_headers(),
         )
+        response.raise_for_status()
         return PostDeploymentResponse.model_validate(response.json())
 
     def get_logs(self, project_name: str) -> GetLogsResponse:
         response = requests.get(self._mk_url(f"/project/{project_name}/logs"), headers=self._get_headers())
+        response.raise_for_status()
         return GetLogsResponse.model_validate(response.json())
 
     def set_secret_value(self, project_name: str, key: str, value: str) -> None:
@@ -78,13 +82,15 @@ def list_bucket_keys(self, project_name: str, bucket_name: str) -> list[str]:
             self._mk_url(f"/project/{project_name}/bucket/{bucket_name}"),
             headers=self._get_headers(),
         )
+        response.raise_for_status()
         return ListBucketKeysResponse.model_validate(response.json()).keys
 
     def get_bucket_object(self, project_name: str, bucket_name: str, key: str) -> bytes:
         response = requests.get(
             self._mk_url(f"/project/{project_name}/bucket/{bucket_name}/object/{key}"),
             headers=self._get_headers(),
         )
+        response.raise_for_status()
         return response.content
 
     def get_project_schema(self) -> dict[str, Any]:
@@ -97,4 +103,5 @@ def get_project_schema(self) -> dict[str, Any]:
             self._mk_url("/schema/project"),
             headers=self._get_headers(),
         )
+        response.raise_for_status()
         return response.json()

src/neptune_cli/mcp.py

@@ -8,6 +8,7 @@
 from neptune_common import PutProjectRequest
 
 from neptune_cli.client import Client
+from neptune_cli.config import SETTINGS
 from neptune_cli.utils import run_command
 
 
@@ -217,10 +218,12 @@ def provision_resources(neptune_json_path: str) -> dict[str, Any]:
 
     # while loop to retrieve project status, wait until ready
     project = client.get_project(project_request.name)
-    while project.provisioning_state != "Ready":
-        log.info(
-            f"Project '{project_request.name}' status: {project.provisioning_state}. Waiting for resources to be provisioned..."
-        )
+
+    while project is None or project.provisioning_state != "Ready":
+        if project is not None:
+            log.info(
+                f"Project '{project_request.name}' status: {project.provisioning_state}. Waiting for resources to be provisioned..."
+            )
         time.sleep(2)
         project = client.get_project(project_request.name)
 
@@ -303,7 +306,7 @@ def deploy_project(neptune_json_path: str) -> dict[str, Any]:
 
     This only works after the project has been provisioned using 'provision_resources'.
 
-    UNDER THE HOOD: deployments are ECS tasks running on Fargate, with images stored in ECR. In particular, this tool builds an image using the Dockerfile in the current directory.
+    UNDER THE HOOD: this tool builds an image using the Dockerfile in the current directory.
 
     Note: running tasks are *not* persistent; if the task stops or is redeployed, all data stored in the container is lost. Use provisioned resources (storage buckets, etc.) for persistent data storage.
     """
@@ -319,6 +322,13 @@ def deploy_project(neptune_json_path: str) -> dict[str, Any]:
 
     project_request = PutProjectRequest.model_validate_json(project_data)
 
+    if client.get_project(project_request.name) is None:
+        log.info(f"Creating project '{project_request.name}'...")
+        client.create_project(project_request)
+    else:
+        log.info(f"Updating project '{project_request.name}'...")
+        client.update_project(project_request)
+
     log.info(f"Deploying project '{project_request.name}'...")
 
     try:
@@ -426,6 +436,7 @@ def get_deployment_status(neptune_json_path: str) -> dict[str, Any]:
 
     This will tell you about running resources the project is using, as well as the state of the service.
     """
+    log.info("Getting deployment status for project ")
     client = Client()
 
     if validation_result := validate_neptune_json(neptune_json_path):
@@ -681,6 +692,7 @@ def get_logs(neptune_json_path: str) -> dict[str, Any]:
         "next_step": "use these logs to debug your application or monitor its behavior; fix any issues and redeploy as necessary",
     }
 
+
 @mcp.tool("info")
 async def info() -> dict[str, Any]:
     """Get information about Neptune and available tools for cloud deployment management."""
@@ -697,21 +709,26 @@ async def info() -> dict[str, Any]:
 
     return {
         "status": "success",
-        "platform": "Neptune (neptune.dev)",
+        "platform": f"Neptune (neptune.dev) - API Base URL: {SETTINGS.api_base_url.rstrip('/')}",
         "description": "Neptune is a cloud deployment platform that simplifies deploying and managing containerized applications with provisioned cloud resources.",
         "available_tools": {
             "setup": {
                 "login": tools_by_name.get("login", "Authenticate with Neptune"),
                 "get_project_schema": tools_by_name.get("get_project_schema", "Get the JSON schema for neptune.json"),
             },
             "configuration": {
-                "add_new_resource": tools_by_name.get("add_new_resource", "Get info about resource types (StorageBucket, Secret, etc.) and how to configure these resources in neptune.json"),
+                "add_new_resource": tools_by_name.get(
+                    "add_new_resource",
+                    "Get info about resource types (StorageBucket, Secret, etc.) and how to configure these resources in neptune.json",
+                ),
             },
             "deployment": {
                 "provision_resources": tools_by_name.get("provision_resources", "Provision cloud infrastructure"),
                 "deploy_project": tools_by_name.get("deploy_project", "Build and deploy the application"),
                 "wait_for_deployment": tools_by_name.get("wait_for_deployment", "Wait for deployment to complete"),
-                "get_deployment_status": tools_by_name.get("get_deployment_status", "Check deployment and resource status"),
+                "get_deployment_status": tools_by_name.get(
+                    "get_deployment_status", "Check deployment and resource status"
+                ),
                 "delete_project": tools_by_name.get("delete_project", "Delete project and all resources"),
             },
             "resources": {
@@ -743,6 +760,7 @@ async def info() -> dict[str, Any]:
         "next_step": "Use 'login' to authenticate with Neptune, then 'get_project_schema' to understand how to configure your project.",
     }
 
+
 async def list_tools() -> list[dict[str, Any]]:
     """Function to return all tools provided by this MCP."""
     tools = await mcp.get_tools()
@@ -754,15 +772,17 @@ async def list_tools() -> list[dict[str, Any]]:
         for tool in tools.values()
     ]
 
+
 def check_docker_installed() -> bool:
     """Check if docker is installed and running."""
     import subprocess
+
     try:
         result = subprocess.Popen(["docker", "info"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         result.communicate()
         if result.returncode != 0:
             return False
-        return True    
+        return True
     except Exception as e:
         log.error(f"Failed to check if docker is installed and running: {e}")
         return False

src/neptune_cli/utils.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass
-from typing import List, Union
 import subprocess
+from typing import List, Union
 
 
 @dataclass