awslabs.finch-mcp-server 0.1.1__py3-none-any.whl

awslabs/finch_mcp_server/utils/vm.py

@@ -0,0 +1,417 @@
+"""Utility functions for managing the Finch VM.
+
+This module provides functions to check, initialize, start, stop, and configure
+the Finch virtual machine that runs containers.
+
+Note: These tools are intended for development and prototyping purposes only
+and are not meant for production use cases.
+"""
+
+import os
+import subprocess
+import sys
+import yaml
+from ..consts import (
+    FINCH_YAML_PATH,
+    STATUS_ERROR,
+    STATUS_SUCCESS,
+    VM_STATE_NONEXISTENT,
+    VM_STATE_RUNNING,
+    VM_STATE_STOPPED,
+    VM_STATE_UNKNOWN,
+)
+from .common import execute_command, format_result
+from loguru import logger
+from shutil import which
+from typing import Dict, Literal
+
+
+def get_vm_status() -> subprocess.CompletedProcess:
+    """Get the current status of the Finch VM.
+
+    This function executes 'finch vm status' and returns the raw result.
+    It's a wrapper around execute_command that simplifies checking
+    the VM status, which is a common operation used by multiple tools.
+
+    Returns:
+        CompletedProcess with the status command result, containing:
+        - returncode: The exit code of the command
+        - stdout: Standard output containing status information
+        - stderr: Standard error output, may also contain status information
+
+    """
+    return execute_command(['finch', 'vm', 'status'])
+
+
+def is_vm_nonexistent(status_result: subprocess.CompletedProcess) -> bool:
+    """Check if the Finch VM is nonexistent based on status result.
+
+    This function analyzes the output of 'finch vm status' to determine
+    if the VM has not been created yet.
+
+    Args:
+        status_result: CompletedProcess object from running 'finch vm status'
+
+    Returns:
+        bool: True if the VM is nonexistent, False otherwise
+
+    """
+    return (
+        'nonexistent' in status_result.stderr.lower()
+        or 'nonexistent' in status_result.stdout.lower()
+    )
+
+
+def is_vm_stopped(status_result: subprocess.CompletedProcess) -> bool:
+    """Check if the Finch VM is stopped based on status result.
+
+    This function analyzes the output of 'finch vm status' to determine
+    if the VM exists but is not currently running.
+
+    Args:
+        status_result: CompletedProcess object from running 'finch vm status'
+
+    Returns:
+        bool: True if the VM is stopped, False otherwise
+
+    """
+    return 'stopped' in status_result.stderr.lower() or 'stopped' in status_result.stdout.lower()
+
+
+def is_vm_running(status_result: subprocess.CompletedProcess) -> bool:
+    """Check if the Finch VM is running based on status result.
+
+    This function analyzes the output of 'finch vm status' to determine
+    if the VM is currently active and operational.
+
+    Args:
+        status_result: CompletedProcess object from running 'finch vm status'
+
+    Returns:
+        bool: True if the VM is running, False otherwise
+
+    """
+    return 'running' in status_result.stdout.lower() or 'running' in status_result.stderr.lower()
+
+
+def initialize_vm() -> Dict[str, str]:
+    """Initialize a new Finch VM.
+
+    This function runs 'finch vm init' to create a new Finch VM instance.
+    It's used when the VM doesn't exist yet and needs to be created.
+
+    Returns:
+        Dict[str, Any]: Result dictionary with:
+            - status: "success" if initialization succeeded, "error" otherwise
+            - message: Details about the initialization result
+
+    """
+    if sys.platform == 'linux':
+        logger.debug('Linux OS detected. Finch does not use a VM on Linux...')
+        return format_result(STATUS_SUCCESS, 'Finch does not use a VM on Linux..')
+
+    logger.warning('Finch VM non existent, Initializing a new vm instance...')
+    init_result = execute_command(['finch', 'vm', 'init'])
+
+    if init_result.returncode == 0:
+        return format_result(STATUS_SUCCESS, 'Finch VM was initialized successfully.')
+    else:
+        return format_result(STATUS_ERROR, f'Failed to initialize Finch VM: {init_result.stderr}')
+
+
+def start_stopped_vm() -> Dict[str, str]:
+    """Start a stopped Finch VM.
+
+    This function runs 'finch vm start' to start a VM that exists but is
+    currently stopped. It's used to make the VM operational when it's not running.
+
+    Returns:
+        Dict[str, Any]: Result dictionary with:
+            - status: "success" if the VM was started successfully, "error" otherwise
+            - message: Details about the start operation result
+
+    """
+    if sys.platform == 'linux':
+        logger.debug('Linux OS detected. Finch does not use a VM on Linux...')
+        return format_result(STATUS_SUCCESS, 'Finch does not use a VM on Linux..')
+
+    logger.info('Finch VM is stopped. Starting it...')
+    start_result = execute_command(['finch', 'vm', 'start'])
+
+    if start_result.returncode == 0:
+        return format_result(
+            STATUS_SUCCESS, 'Finch VM was stopped and has been started successfully.'
+        )
+    else:
+        return format_result(STATUS_ERROR, f'Failed to start Finch VM: {start_result.stderr}')
+
+
+def stop_vm(force: bool = False) -> Dict[str, str]:
+    """Stop a running Finch VM.
+
+    This function runs 'finch vm stop' to shut down a running VM.
+    If force is True, it adds the '--force' flag to forcefully terminate
+    the VM even if it's in use.
+
+    Args:
+        force: Whether to force stop the VM. Use this when the VM might be
+               in an inconsistent state or when normal shutdown fails.
+
+    Returns:
+        Dict[str, Any]: Result dictionary with:
+            - status: "success" if the VM was stopped successfully, "error" otherwise
+            - message: Details about the stop operation result
+
+    """
+    if sys.platform == 'linux':
+        logger.debug('Linux OS detected. Finch does not use a VM on Linux...')
+        return format_result(STATUS_SUCCESS, 'Finch does not use a VM on Linux..')
+
+    command = ['finch', 'vm', 'stop']
+    if force:
+        command.append('--force')
+
+    stop_result = execute_command(command)
+
+    if stop_result.returncode == 0:
+        return format_result(STATUS_SUCCESS, 'Finch VM has been stopped successfully.')
+    else:
+        return format_result(STATUS_ERROR, f'Failed to stop Finch VM: {stop_result.stderr}')
+
+
+def remove_vm(force: bool = False) -> Dict[str, str]:
+    """Remove the Finch VM.
+
+    This function runs 'finch vm rm' to remove the VM.
+    If force is True, it adds the '--force' flag to forcefully remove
+    the VM even if it's in use.
+
+    Args:
+        force: Whether to force remove the VM. Use this when the VM might be
+               in an inconsistent state or when normal removal fails.
+
+    Returns:
+        Dict[str, Any]: Result dictionary with:
+            - status: "success" if the VM was removed successfully, "error" otherwise
+            - message: Details about the remove operation result
+
+    """
+    if sys.platform == 'linux':
+        logger.debug('Linux OS detected. Finch does not use a VM on Linux...')
+        return format_result(STATUS_SUCCESS, 'Finch does not use a VM on Linux..')
+
+    command = ['finch', 'vm', 'rm']
+    if force:
+        command.append('--force')
+
+    remove_result = execute_command(command)
+
+    if remove_result.returncode == 0:
+        return format_result(STATUS_SUCCESS, 'Finch VM has been removed successfully.')
+    else:
+        return format_result(STATUS_ERROR, f'Failed to remove Finch VM: {remove_result.stderr}')
+
+
+def restart_running_vm() -> Dict[str, str]:
+    """Restart a running Finch VM (stop then start).
+
+    This function performs a full restart of the VM by first stopping it
+    (with force=True to ensure it stops) and then starting it again.
+    It's useful when you need to refresh the VM state completely.
+
+    Returns:
+        Dict[str, Any]: Result dictionary with:
+            - status: "success" if the VM was restarted successfully, "error" otherwise
+            - message: Details about the restart operation result
+
+    """
+    if sys.platform == 'linux':
+        logger.debug('Linux OS detected. Finch does not use a VM on Linux...')
+        return format_result(STATUS_SUCCESS, 'Finch does not use a VM on Linux..')
+
+    logger.info('Finch VM is running. Restarting it...')
+
+    stop_result = stop_vm(force=True)
+    if stop_result['status'] == STATUS_ERROR:
+        return stop_result
+
+    start_result = start_stopped_vm()
+
+    return start_result
+
+
+def check_finch_installation() -> Dict[str, str]:
+    """Check if the Finch CLI tool is installed on the system.
+
+    This function uses 'which finch' on macOS/Linux to determine if the
+    Finch command-line tool is available in the system PATH. It's a
+    prerequisite check before attempting to use any Finch functionality.
+
+    Returns:
+        Dict[str, Any]: Result dictionary with:
+            - status: "success" if Finch is installed, "error" otherwise
+            - message: Details about the installation status
+
+    """
+    try:
+        if which('finch') is not None:
+            return format_result(STATUS_SUCCESS, 'Finch is installed.')
+        else:
+            return format_result(STATUS_ERROR, 'Finch is not installed.')
+    except Exception as e:
+        return format_result(STATUS_ERROR, f'Error checking Finch installation: {str(e)}')
+
+
+def configure_ecr() -> tuple[Dict[str, str], bool]:
+    r"""Configure Finch to use ECR (Amazon Elastic Container Registry).
+
+    This function updates the Finch YAML configuration file:
+    - macOS: ~/.finch/finch.yaml
+    - Windows: %LocalAppData%\.finch\finch.yaml
+
+    It adds 'ecr-login' to the creds_helpers list while preserving other settings.
+
+    This enables Finch to authenticate with Amazon ECR. The config.json file is not modified
+    as it is automatically handled when adding the ecr-login credential helper in finch.yaml.
+
+    Returns:
+        tuple[Dict[str, str], bool]: A tuple containing:
+            - Result dictionary with:
+                - status: "success" if the configuration was updated successfully, "error" otherwise
+                - message: Details about the configuration result
+            - Boolean indicating if the configuration was changed (True if changed, False otherwise)
+
+    """
+    try:
+        if sys.platform == 'linux':
+            (
+                logger.info(
+                    'Linux OS detected. config.json set in DOCKER_CONFIG is used for credentials'
+                ),
+                False,
+            )
+            return format_result(
+                'success', 'config.json set in DOCKER_CONFIG is used for credentials'
+            ), False
+
+        changed_yaml = False
+        # For Windows, FINCH_YAML_PATH is already an absolute path
+        # For macOS, we need to expand the ~ in the path
+        finch_yaml_path = FINCH_YAML_PATH
+        if sys.platform != 'win32':
+            finch_yaml_path = os.path.expanduser(FINCH_YAML_PATH)
+
+        if os.path.exists(finch_yaml_path):
+            try:
+                with open(finch_yaml_path, 'r') as f:
+                    yaml_content = yaml.safe_load(f) or {}
+
+                if 'creds_helpers' in yaml_content:
+                    if not isinstance(yaml_content['creds_helpers'], list):
+                        yaml_content['creds_helpers'] = (
+                            [yaml_content['creds_helpers']]
+                            if yaml_content['creds_helpers']
+                            else []
+                        )
+
+                    if 'ecr-login' not in yaml_content['creds_helpers']:
+                        yaml_content['creds_helpers'].append('ecr-login')
+                        changed_yaml = True
+                else:
+                    yaml_content['creds_helpers'] = ['ecr-login']
+                    changed_yaml = True
+
+                if changed_yaml:
+                    with open(finch_yaml_path, 'w') as f:
+                        yaml.dump(yaml_content, f, default_flow_style=False)
+
+            except Exception as e:
+                logger.warning(f'Error updating {finch_yaml_path} with PyYAML: {str(e)}')
+                return format_result(
+                    STATUS_ERROR, f'Failed to update finch YAML file: {str(e)}'
+                ), False
+        else:
+            if sys.platform == 'win32':
+                error_msg = f'finch yaml file not found at {finch_yaml_path}'
+            else:
+                error_msg = 'finch yaml file not found in finch.yaml'
+            return format_result(STATUS_ERROR, error_msg), False
+
+        if changed_yaml:
+            # Log the change status
+            logger.debug('ECR configuration was updated in finch.yaml')
+            result = format_result(
+                STATUS_SUCCESS,
+                'ECR configuration updated successfully in finch.yaml.',
+            )
+        else:
+            # Log that no changes were needed
+            logger.debug('ECR was already configured correctly in finch.yaml')
+            result = format_result(
+                STATUS_SUCCESS,
+                'ECR was already configured correctly in finch.yaml.',
+            )
+
+        return result, changed_yaml
+
+    except Exception as e:
+        return format_result(STATUS_ERROR, f'Failed to configure ECR: {str(e)}'), False
+
+
+def validate_vm_state(
+    expected_state: Literal['running', 'stopped', 'nonexistent'],
+) -> Dict[str, str]:
+    """Validate that the Finch VM is in the expected state.
+
+    This function checks the current state of the VM and compares it to the expected state.
+    It's used to verify that operations like start, stop, and remove have the desired effect.
+
+    Args:
+        expected_state: The state the VM should be in ("running", "stopped", or "nonexistent")
+
+    Returns:
+        Dict[str, str]: Result dictionary with:
+            - status: "success" if the VM is in the expected state, "error" otherwise
+            - message: Details about the validation result
+
+    """
+    try:
+        status_result = get_vm_status()
+
+        if expected_state == VM_STATE_RUNNING and is_vm_running(status_result):
+            logger.debug('VM state validation passed: running')
+            return format_result(
+                STATUS_SUCCESS,
+                'Validation passed: Finch VM is running as expected.',
+            )
+        elif expected_state == VM_STATE_STOPPED and is_vm_stopped(status_result):
+            logger.debug('VM state validation passed: stopped')
+            return format_result(
+                STATUS_SUCCESS,
+                'Validation passed: Finch VM is stopped as expected.',
+            )
+        elif expected_state == VM_STATE_NONEXISTENT and is_vm_nonexistent(status_result):
+            logger.debug('VM state validation passed: nonexistent')
+            return format_result(
+                STATUS_SUCCESS,
+                'Validation passed: Finch VM is nonexistent as expected.',
+            )
+        else:
+            actual_state = VM_STATE_UNKNOWN
+            if is_vm_running(status_result):
+                actual_state = VM_STATE_RUNNING
+            elif is_vm_stopped(status_result):
+                actual_state = VM_STATE_STOPPED
+            elif is_vm_nonexistent(status_result):
+                actual_state = VM_STATE_NONEXISTENT
+
+            logger.debug(
+                f'VM state validation failed: expected={expected_state}, actual={actual_state}'
+            )
+            return format_result(
+                STATUS_ERROR,
+                f'Validation failed: Expected Finch VM to be {expected_state}, but it is {actual_state}.',
+            )
+    except Exception as e:
+        logger.error(f'Error during VM state validation: {str(e)}')
+        return format_result(STATUS_ERROR, f'Error validating VM state: {str(e)}')

awslabs_finch_mcp_server-0.1.1.dist-info/METADATA

@@ -0,0 +1,212 @@
+Metadata-Version: 2.4
+Name: awslabs.finch-mcp-server
+Version: 0.1.1
+Summary: A Model Context Protocol server for Finch to build and push container images
+Project-URL: Homepage, https://awslabs.github.io/mcp/
+Project-URL: Documentation, https://awslabs.github.io/mcp/servers/finch-mcp-server/
+Project-URL: Source, https://github.com/awslabs/mcp.git
+Project-URL: Bug Tracker, https://github.com/awslabs/mcp/issues
+Project-URL: Changelog, https://github.com/awslabs/mcp/blob/main/src/finch-mcp-server/CHANGELOG.md
+Author: Amazon Web Services
+Author-email: AWSLabs MCP <203918161+awslabs-mcp@users.noreply.github.com>
+License: Apache-2.0
+License-File: LICENSE
+License-File: NOTICE
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Requires-Dist: boto3>=1.28.0
+Requires-Dist: loguru>=0.7.0
+Requires-Dist: mcp[cli]>=1.6.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pyyaml>=6.0
+Description-Content-Type: text/markdown
+
+# Finch MCP Server
+
+A Model Context Protocol (MCP) server for Finch that enables generative AI models to build and push container images through finch cli leveraged MCP tools.
+
+## Features
+
+This MCP server acts as a bridge between MCP clients and Finch, allowing generative AI models to build and push container images to repositories, and create ECR repositories as needed. The server provides a secure way to interact with Finch, ensuring that the Finch VM is properly initialized and running before performing operations.
+
+## Key Capabilities
+
+- Build container images using Finch
+- Push container images to repositories, including Amazon ECR
+- Check if ECR repositories exist and create them if needed
+- Automatic management of the Finch VM on macos and windows (initialization, starting, etc.)
+- Automatic configuration of ECR credential helpers when needed (only modifies finch.yaml as config.json is automatically handled)
+
+## Prerequisites
+
+1. Install `uv` from [Astral](https://docs.astral.sh/uv/getting-started/installation/) or the [GitHub README](https://github.com/astral-sh/uv#installation)
+2. Install Python using `uv python install 3.10`
+3. Install [Finch](https://github.com/runfinch/finch) on your system
+4. For ECR operations, AWS credentials with permissions to push to ECR repositories and create/describe ECR repositories
+
+## Setup
+
+### Installation
+
+Configure the MCP server in your MCP client configuration:
+
+#### Default Mode (Read-only AWS Resources)
+
+By default, the server runs in a mode that prevents the creation of new AWS resources. This is useful for environments where you want to limit resource creation or for users who should only be able to build and push to existing repositories.
+
+```json
+{
+  "mcpServers": {
+    "awslabs.finch-mcp-server": {
+      "command": "uvx",
+      "args": ["awslabs.finch-mcp-server@latest"],
+      "env": {
+        "AWS_PROFILE": "default",
+        "AWS_REGION": "us-west-2",
+        "FASTMCP_LOG_LEVEL": "INFO"
+      },
+      "transportType": "stdio",
+      "disabled": false,
+      "autoApprove": []
+    }
+  }
+}
+```
+
+In this default mode:
+- The `finch_build_container_image` tools will work normally
+- The `finch_create_ecr_repo` and `finch_push_image` tool will return an error and will not create or modify AWS resources.
+
+#### AWS Resource Write Mode
+
+The server can also be set to enable AWS resource creation and modification by using the `--enable-aws-resource-write` flag.
+
+```json
+{
+  "mcpServers": {
+    "awslabs.finch-mcp-server": {
+      "command": "uvx",
+      "args": [
+        "awslabs.finch-mcp-server@latest",
+        "--enable-aws-resource-write"
+      ],
+      "env": {
+        "AWS_PROFILE": "default",
+        "AWS_REGION": "us-west-2",
+        "FASTMCP_LOG_LEVEL": "INFO"
+      },
+      "transportType": "stdio",
+      "disabled": false,
+      "autoApprove": []
+    }
+  }
+}
+```
+
+## Available Tools
+
+### `finch_build_container_image`
+
+Build a container image using Finch.
+
+The tool builds a Docker image using the specified Dockerfile and context directory. It supports a range of build options including tags, platforms, and more.
+
+Arguments:
+- `dockerfile_path` (str): Absolute path to the Dockerfile
+- `context_path` (str): Absolute path to the build context directory
+- `tags` (List[str], optional): List of tags to apply to the image (e.g., ["myimage:latest", "myimage:v1"])
+- `platforms` (List[str], optional): List of target platforms (e.g., ["linux/amd64", "linux/arm64"])
+- `target` (str, optional): Target build stage to build
+- `no_cache` (bool, optional): Whether to disable cache. Defaults to False.
+- `pull` (bool, optional): Whether to always pull base images. Defaults to False.
+- `build_contexts` (List[str], optional): List of additional build contexts
+- `outputs` (str, optional): Output destination
+- `cache_from` (List[str], optional): List of external cache sources
+- `quiet` (bool, optional): Whether to suppress build output. Defaults to False.
+- `progress` (str, optional): Type of progress output. Defaults to "auto".
+
+### `finch_push_image`
+
+Push a container image to a repository using Finch, replacing the tag with the image hash.
+
+If the image URL is an ECR repository, it verifies that ECR login credential helper is configured. This tool gets the image hash, creates a new tag using the hash, and pushes the image with the hash tag to the repository.
+
+The workflow is:
+1. Get the image hash using `finch image inspect`
+2. Create a new tag for the image using the short form of the hash (first 12 characters)
+3. Push the hash-tagged image to the repository
+
+Arguments:
+- `image` (str): The full image name to push, including the repository URL and tag. For ECR repositories, it must follow the format: `<aws_account_id>.dkr.ecr.<region>.amazonaws.com/<repository_name>:<tag>`
+
+Example:
+```
+# Original image: myrepo/myimage:latest
+# After processing: myrepo/myimage:1a2b3c4d5e6f (where 1a2b3c4d5e6f is the short hash)
+```
+
+### `finch_create_ecr_repo`
+
+Check if an ECR repository exists and create it if it doesn't.
+
+This tool checks if the specified ECR repository exists using boto3. If the repository doesn't exist, it creates a new one with the given name with scan on push enabled and immutable tags for enhanced security. The tool requires appropriate AWS credentials configured.
+
+**Note:** When the server is running in readonly mode, this tool will return an error and will not create any AWS resources.
+
+Arguments:
+- `app_name` (str): The name of the application/repository to check or create in ECR
+- `region` (str, optional): AWS region for the ECR repository. If not provided, uses the default region from AWS configuration
+
+Example:
+```
+# Check if 'my-app' repository exists in us-west-2 region, create it if it doesn't
+{
+  "app_name": "my-app",
+  "region": "us-west-2"
+}
+
+# Response if repository already exists:
+{
+  "status": "success",
+  "message": "ECR repository 'my-app' already exists.",
+}
+
+# Response if repository was created:
+{
+  "status": "success",
+  "message": "Successfully created ECR repository 'my-app'.",
+}
+
+# Response if server is in readonly mode:
+{
+  "status": "error",
+  "message": "Server running in read-only mode, unable to perform the action"
+}
+```
+
+## Best Practices
+
+- **Development and Prototyping Only**: The tools provided by this MCP server are intended for development and prototyping purposes only. They are not meant for production use cases.
+- **Security Considerations**: Always review the Dockerfiles and container configurations before building and pushing images.
+- **Resource Management**: Regularly clean up unused images and containers to free up disk space.
+- **Version Control**: Keep track of image versions and tags to ensure reproducibility.
+- **Error Handling**: Implement proper error handling in your applications when using these tools.
+
+
+## Troubleshooting
+
+- If you encounter permission errors with ECR, verify your AWS credentials and boto3 configuration are properly set up
+- For Finch VM issues, try running `finch vm stop` and then `finch vm start` manually
+- If the build fails with errors about missing files, check that your context path is correct
+- For general Finch issues, consult the [Finch documentation](https://github.com/runfinch/finch)
+
+## Version
+
+Current MCP server version: 0.1.0

awslabs_finch_mcp_server-0.1.1.dist-info/RECORD

@@ -0,0 +1,17 @@
+awslabs/__init__.py,sha256=bfTactAnM5TLDj8DEa7bm8LM2Vq5MeYeTevjwbmnkR4,598
+awslabs/finch_mcp_server/__init__.py,sha256=x5tDHoZMLCDVZzVBHKWcT2a5BIWpYqSvs4PdYTRjeek,613
+awslabs/finch_mcp_server/consts.py,sha256=jzmhiSIq6_AkRtelWFBp3Wa8DE1m-RVWEsVNZtmHWGk,1040
+awslabs/finch_mcp_server/models.py,sha256=LZ-KSea6dvLk_8eo6q3nYR0kT_l-Qqh7Ib0E5F1uyX0,678
+awslabs/finch_mcp_server/server.py,sha256=jZt5e8ind0R9YzZVr9T2PkHlcya54Q1xI26MYt7HOSk,16783
+awslabs/finch_mcp_server/utils/__init__.py,sha256=CWQ6u4iR80Z_gP2SxEMl4TIkrQTTeA_xj9Nc_29l5FE,689
+awslabs/finch_mcp_server/utils/build.py,sha256=2uEZMrVZR5c-00LLzivWjGDAU1PouHpel5bFN0e11g4,4644
+awslabs/finch_mcp_server/utils/common.py,sha256=GG0lU6rLvZmjLshzDcD_McejtQSEZaMK3AKjPm-XeHo,5609
+awslabs/finch_mcp_server/utils/ecr.py,sha256=Ca7ncv8IhVnL3H-kDUZmxiWqZpNSs49ZCNffeRaFDC0,3251
+awslabs/finch_mcp_server/utils/push.py,sha256=PNKEMhrf37ferdfxNjcBMdEn9Wbt_eES18HauLtiPf4,4064
+awslabs/finch_mcp_server/utils/vm.py,sha256=3Zh95RWjU-59EmqKEvoRuza8sTGw9xaR6dcjxY_fOSE,15572
+awslabs_finch_mcp_server-0.1.1.dist-info/METADATA,sha256=g--kJ7vhs0T6kDAQcXCZL9jcGV9Ph__EdfxNOOQvZ68,8578
+awslabs_finch_mcp_server-0.1.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+awslabs_finch_mcp_server-0.1.1.dist-info/entry_points.txt,sha256=4fJNznnCPk2jY2ztTYAvEpLeYXcS3wDkgx2gAYdezPY,82
+awslabs_finch_mcp_server-0.1.1.dist-info/licenses/LICENSE,sha256=UOZ1F5fFDe3XXvG4oNnkL1-Ecun7zpHzRxjp-XsMeAo,11324
+awslabs_finch_mcp_server-0.1.1.dist-info/licenses/NOTICE,sha256=W4rmEHanXgUYNeoEh6oB-pfuI1RtX4XIvX067GmL-i0,92
+awslabs_finch_mcp_server-0.1.1.dist-info/RECORD,,

awslabs_finch_mcp_server-0.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

awslabs_finch_mcp_server-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+awslabs.finch-mcp-server = awslabs.finch_mcp_server.server:main