py-mcpdock-cli 1.0.13__py3-none-any.whl → 1.0.18__py3-none-any.whl

cli/commands/install.py

@@ -77,84 +77,81 @@ async def install_mcp_server(
     target_client = target_client or "claude"  # Default to Claude if no client specified
     verbose(f"Initiating installation of {package_identifier} for {target_client}")
 
-    console = Console()
-
     # Create and start spinner for package resolution
-    with console.status(f"Resolving {package_identifier}...", spinner="dots") as status:
-        try:
-            # Resolve the package (fetch server metadata)
-            verbose(f"Resolving package: {package_identifier}")
-            server_data = await resolve_package(package_identifier)
-            verbose(f"Package resolved successfully: {server_data.qualifiedName}")
-
-            # Choose the appropriate connection type
-            verbose("Choosing connection type...")
-            connection = choose_connection(server_data)
-            verbose(f"Selected connection type: {connection.type}")
-
-            # Check for required runtimes and install if needed
-            # Commented out as these are specific to JS environment
-            # await ensure_uv_installed(connection)
-            # await ensure_bun_installed(connection)
-
-            # Inform users of remote server installation if applicable
-            is_remote = check_and_notify_remote_server(server_data)
-            if is_remote:
-                verbose("Remote server detected, notification displayed")
-
-            # Get the validated config values, no prompting
-            status.update(f"Validating configuration for {package_identifier}...")
-            collected_config_values = await validate_config_values(connection, initial_config)
-
-            # Determine if we need to pass config flag
-            config_flag_needed = initial_config is not None
-
-            verbose(f"Config values validated: {json.dumps(collected_config_values, indent=2)}")
-            verbose(f"Using config flag: {config_flag_needed}")
-
-            # Format the server configuration
-            verbose("Formatting server configuration...")
-            server_config = format_server_config(
-                package_identifier,
-                collected_config_values,
-                api_key,
-                config_flag_needed,
-            )
-            verbose(f"Formatted server config: {json.dumps(server_config.__dict__, indent=2)}")
-
-            # Read existing config from client
-            status.update(f"Installing for {target_client}...")
-            verbose(f"Reading configuration for client: {target_client}")
-            client_config = read_config(target_client)
-
-            # Get normalized server name to use as key
-            server_name = get_server_name(package_identifier)
-            verbose(f"Normalized server ID: {server_name}")
-
-            # Update client configuration with new server
-            verbose("Updating client configuration...")
-            if not isinstance(client_config.mcpServers, dict):
-                # Initialize if needed
-                client_config.mcpServers = {}
-
-            # Add the new server config
-            client_config.mcpServers[server_name] = server_config
-
-            # Write updated configuration
-            verbose("Writing updated configuration...")
-            write_config(client_config, target_client)
-            verbose("Configuration successfully written")
-
-            rprint(f"[green]{package_identifier} successfully installed for {target_client}[/green]")
-
-            # No prompt for client restart
-            verbose("Installation completed successfully")
-
-        except Exception as e:
-            verbose(f"Installation error: {str(e)}")
-            rprint(f"[red]Failed to install {package_identifier}[/red]")
-            rprint(f"[red]Error: {str(e)}[/red]")
-            raise
+    try:
+        # Resolve the package (fetch server metadata)
+        verbose(f"Resolving package: {package_identifier}")
+        server_data = await resolve_package(package_identifier)
+        verbose(f"Package resolved successfully: {server_data.qualifiedName}")
+
+        # Choose the appropriate connection type
+        verbose("Choosing connection type...")
+        connection = choose_connection(server_data)
+        verbose(f"Selected connection type: {connection.type}")
+
+        # Check for required runtimes and install if needed
+        # Commented out as these are specific to JS environment
+        # await ensure_uv_installed(connection)
+        # await ensure_bun_installed(connection)
+
+        # Inform users of remote server installation if applicable
+        is_remote = check_and_notify_remote_server(server_data)
+        if is_remote:
+            verbose("Remote server detected, notification displayed")
+
+        # Get the validated config values, no prompting
+        verbose(f"Validating configuration for {package_identifier}...")
+        collected_config_values = await validate_config_values(connection, initial_config)
+
+        # Determine if we need to pass config flag
+        config_flag_needed = initial_config is not None
+
+        verbose(f"Config values validated: {json.dumps(collected_config_values, indent=2)}")
+        verbose(f"Using config flag: {config_flag_needed}")
+
+        # Format the server configuration
+        verbose("Formatting server configuration...")
+        server_config = format_server_config(
+            package_identifier,
+            collected_config_values,
+            api_key,
+            config_flag_needed,
+        )
+        verbose(f"Formatted server config: {json.dumps(server_config.__dict__, indent=2)}")
+
+        # Read existing config from client
+        verbose(f"Installing for {target_client}...")
+        verbose(f"Reading configuration for client: {target_client}")
+        client_config = read_config(target_client)
+
+        # Get normalized server name to use as key
+        server_name = get_server_name(package_identifier)
+        verbose(f"Normalized server ID: {server_name}")
+
+        # Update client configuration with new server
+        verbose("Updating client configuration...")
+        if not isinstance(client_config.mcpServers, dict):
+            # Initialize if needed
+            client_config.mcpServers = {}
+
+        # Add the new server config
+        client_config.mcpServers[server_name] = server_config
+
+        # Write updated configuration
+        verbose("Writing updated configuration...")
+        write_config(client_config, target_client)
+        verbose("Configuration successfully written")
+
+        rprint(f"[green]{package_identifier} successfully installed for {target_client}[/green]")
+
+        # No prompt for client restart
+        verbose("Installation completed successfully")
+
+    except Exception as e:
+        verbose(f"Installation error: {str(e)}")
+        rprint(f"[red]Failed to install {package_identifier}[/red]")
+        rprint(f"[red]Error: {str(e)}[/red]")
+        raise
 
 
 @click.command("install")
@@ -164,19 +161,19 @@ async def install_mcp_server(
 @click.option("--api-key", type=click.STRING, help="Provide an API key for fetching saved configurations")
 def install(mcp_server: str, client: Optional[str], env_json: Optional[str], api_key: Optional[str]):
     """Install an AI mcp-server with optional configuration."""
-    click.echo(f"Attempting to install {mcp_server}...")
+    verbose(f"Attempting to install {mcp_server}...")
     user_config = None
     if env_json:
         try:
             user_config = json.loads(env_json)
-            click.echo(f"Using provided config: {user_config}")
+            verbose(f"Using provided config: {user_config}")
         except json.JSONDecodeError as e:
-            click.echo(f"Error: Invalid JSON provided for --config: {e}", err=True)
+            verbose(f"Error: Invalid JSON provided for --config: {e}", err=True)
             return
 
     try:
         # Run the async installation process
         asyncio.run(install_mcp_server(mcp_server, client, user_config, api_key))
     except Exception as e:
-        click.echo(f"Installation failed: {str(e)}", err=True)
+        verbose(f"Installation failed: {str(e)}", err=True)
         return 1

cli/commands/query_pid.py

@@ -0,0 +1,36 @@
+from cli.utils.logger import verbose
+import click
+import json
+import sys
+from ..utils.run_query_pid_by_packagename import query_pid_by_packagename
+
+
+@click.command("query-pid")
+@click.argument("package_names", type=click.STRING, nargs=-1, required=True)
+@click.option("--json-output", is_flag=True, help="Output results in JSON format")
+def query_pid(package_names, json_output):
+    """
+    Check if the processes for the specified package names are running.
+
+    PACKAGE_NAMES: One or more package names to check.
+    Returns the running status for each package name. If the --json-output option is used, outputs the result in JSON format.
+    """
+    try:
+        # Get the running status for each package name
+        status_dict = query_pid_by_packagename(list(package_names))
+
+        if json_output:
+            # Output results in JSON format
+            print(json.dumps(status_dict))
+        else:
+            # Output results in plain text format
+            for package_name, is_running in status_dict.items():
+                status = "Running" if is_running else "Not running"
+                verbose(f"Package name '{package_name}': {status}")
+
+        # Check if any process is running
+        any_running = any(status_dict.values())
+        exit(0 if any_running else 1)
+    except Exception as e:
+        print(f"Error occurred while executing query-pid command: {e}", file=sys.stderr)
+        exit(1)  # Return 1 to indicate an error

cli/commands/run.py

@@ -3,7 +3,7 @@ import json
 import asyncio
 from typing import Dict, Any, Optional
 
-from rich import print as rprint
+from rich import print as verbose
 from rich.console import Console
 
 from ..utils.logger import verbose
@@ -91,8 +91,8 @@ async def run_server(
         # Inform about remote server if applicable
         # check_and_notify_remote_server(resolved_server)
 
-        rprint(f"[blue][Runner] Connecting to server:[/blue] {resolved_server.qualifiedName}")
-        rprint(f"Connection types: {[c.type for c in resolved_server.connections]}")
+        verbose(f"[blue][Runner] Connecting to server:[/blue] {resolved_server.qualifiedName}")
+        verbose(f"Connection types: {[c.type for c in resolved_server.connections]}")
 
         # Assume analytics is disabled for now
         analytics_enabled = False
@@ -105,7 +105,7 @@ async def run_server(
             analytics_enabled
         )
     except Exception as e:
-        rprint(f"[red][Runner] Fatal error:[/red] {str(e)}")
+        verbose(f"[red][Runner] Fatal error:[/red] {str(e)}")
         raise
 
 
@@ -115,18 +115,18 @@ async def run_server(
 @click.option("--api-key", type=click.STRING, help="API key for retrieving saved configuration")
 def run(mcp_server: str, config_json: Optional[str], api_key: Optional[str]):
     """Run an AI MCP server."""
-    click.echo(f"Attempting to run {mcp_server}...")
+    verbose(f"Attempting to run {mcp_server}...")
     server_config = None
 
     # Parse command line provided configuration
     if config_json:
         try:
+            verbose(config_json)
             server_config = json.loads(config_json)
-            click.echo(f"Using provided config: {server_config}")
+            verbose(f"Using provided config: {server_config}")
         except json.JSONDecodeError as e:
-            click.echo(f"Error: Invalid JSON provided for --config: {e}", err=True)
+            verbose(f"Error: Invalid JSON provided for --config: {e}")
             return 1
-
     # If no config provided, use empty dict
     if server_config is None:
         verbose("No config provided, running with empty config")
@@ -135,8 +135,6 @@ def run(mcp_server: str, config_json: Optional[str], api_key: Optional[str]):
     if api_key:
         verbose(f"API key provided: {'*' * len(api_key)}")
 
-    console = Console()
-
     try:
         # with console.status(f"Starting {mcp_server}...", spinner="dots") as status:
         # Run the server asynchronously
@@ -144,5 +142,5 @@ def run(mcp_server: str, config_json: Optional[str], api_key: Optional[str]):
         asyncio.run(run_server(mcp_server, server_config, api_key))
         # status.update(f"Successfully started {mcp_server}")
     except Exception as e:
-        click.echo(f"Run failed: {str(e)}", err=True)
+        verbose(f"Run failed: {str(e)}")
         return 1

cli/main.py

@@ -1,12 +1,16 @@
 import click
 from .commands.install import install
 from .commands.run import run
+from .commands.query_pid import query_pid
+
 
 @click.group()
-@click.version_option(version="1.0.0", package_name="py-cli") # Corresponds to program.version("1.0.0")
+@click.version_option(version="1.0.0", package_name="py-cli")  # Corresponds to program.version("1.0.0")
 def cli():
     """A custom CLI tool translated to Python."""
     pass
 
+
 cli.add_command(install)
-cli.add_command(run)
+cli.add_command(run)
+cli.add_command(query_pid)