multipass-mcp 0.1.1__tar.gz

multipass_mcp-0.1.1/.github/workflows/release.yaml

@@ -0,0 +1,24 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - v*
+  workflow_dispatch:
+
+jobs:
+  pypi:
+    name: Publish to PyPI
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+      attestations: write
+      id-token: write
+    environment:
+      name: release
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v3
+      - run: uv build
+      - run: uv publish --trusted-publishing always

multipass_mcp-0.1.1/.gitignore

@@ -0,0 +1,216 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#   Usually these files are written by a python script from a template
+#   before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+# Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+# uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+# poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+# pdm.lock
+# pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+# pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# Redis
+*.rdb
+*.aof
+*.pid
+
+# RabbitMQ
+mnesia/
+rabbitmq/
+rabbitmq-data/
+
+# ActiveMQ
+activemq-data/
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#   JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#   be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#   and can be added to the global gitignore or merged into this file.  For a more nuclear
+#   option (not recommended) you can uncomment the following to ignore the entire idea folder.
+# .idea/
+
+# Abstra
+#   Abstra is an AI-powered process automation framework.
+#   Ignore directories containing user credentials, local state, and settings.
+#   Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#   Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore
+#   that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#   and can be added to the global gitignore or merged into this file. However, if you prefer,
+#   you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Streamlit
+.streamlit/secrets.toml

multipass_mcp-0.1.1/.pre-commit-config.yaml

@@ -0,0 +1,57 @@
+repos:
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+    -   id: trailing-whitespace
+    -   id: end-of-file-fixer
+    -   id: check-yaml
+    -   id: debug-statements
+    -   id: double-quote-string-fixer
+    -   id: name-tests-test
+    -   id: requirements-txt-fixer
+    -   id: check-json
+    -   id: pretty-format-json
+        args: [--autofix, --indent=4]
+-   repo: https://github.com/asottile/setup-cfg-fmt
+    rev: v2.8.0
+    hooks:
+    -   id: setup-cfg-fmt
+-   repo: https://github.com/asottile/reorder-python-imports
+    rev: v3.15.0
+    hooks:
+    -   id: reorder-python-imports
+        exclude: ^(pre_commit/resources/|testing/resources/python3_hooks_repo/)
+        args: [--py312-plus]
+-   repo: https://github.com/asottile/add-trailing-comma
+    rev: v3.2.0
+    hooks:
+    -   id: add-trailing-comma
+-   repo: https://github.com/asottile/pyupgrade
+    rev: v3.20.0
+    hooks:
+    -   id: pyupgrade
+        args: [--py312-plus]
+-   repo: https://github.com/hhatto/autopep8
+    rev: v2.3.2
+    hooks:
+    -   id: autopep8
+-   repo: https://github.com/PyCQA/flake8
+    rev: 7.3.0
+    hooks:
+    -   id: flake8
+        args: ['--ignore=E501,W504']
+-   repo: https://github.com/PyCQA/autoflake
+    rev: v2.3.1
+    hooks:
+    -   id: autoflake
+        args: [--remove-all-unused-imports, --in-place]
+-   repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v1.17.1
+    hooks:
+    -   id: mypy
+        additional_dependencies:
+            - types-pyyaml
+            - types-requests
+            - pandas-stubs
+            - sqlmodel
+        exclude: ^(testing/resources/|benchmarks/)

multipass_mcp-0.1.1/.python-version

@@ -0,0 +1 @@
+3.12

multipass_mcp-0.1.1/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: multipass-mcp
+Version: 0.1.1
+Summary: Multipass MCP Server
+Requires-Python: >=3.12
+Requires-Dist: fastmcp>=3.1.0
+Description-Content-Type: text/markdown
+
+# Multipass MCP Server
+
+A Model Context Protocol (MCP) server to manage [Multipass](https://multipass.run/) instances.
+
+## Usage
+
+```bash
+claude mcp add --transport stdio multipass -- uvx multipass-mcp
+```
+
+## Available Tools
+
+- `list_instances`: List all instances.
+- `launch_instance`: Create a new instance.
+- `start_instance` / `stop_instance` / `delete_instance`: Manage state.
+- `execute_command`: Run commands inside an instance.
+- `get_instance_info`: Get detailed specs (CPU, Memory, Disk).
+- `purge_instances`: Cleanup deleted instances.

multipass_mcp-0.1.1/README.md

@@ -0,0 +1,18 @@
+# Multipass MCP Server
+
+A Model Context Protocol (MCP) server to manage [Multipass](https://multipass.run/) instances.
+
+## Usage
+
+```bash
+claude mcp add --transport stdio multipass -- uvx multipass-mcp
+```
+
+## Available Tools
+
+- `list_instances`: List all instances.
+- `launch_instance`: Create a new instance.
+- `start_instance` / `stop_instance` / `delete_instance`: Manage state.
+- `execute_command`: Run commands inside an instance.
+- `get_instance_info`: Get detailed specs (CPU, Memory, Disk).
+- `purge_instances`: Cleanup deleted instances.

multipass_mcp-0.1.1/multipass_mcp/__init__.py

@@ -0,0 +1,3 @@
+from .server import mcp
+
+__all__ = ['mcp']

multipass_mcp-0.1.1/multipass_mcp/multipass.py

@@ -0,0 +1,113 @@
+import asyncio
+import json
+from dataclasses import dataclass
+from dataclasses import field
+from typing import Any
+
+
+@dataclass
+class MultipassInstance:
+    name: str
+    state: str
+    ipv4: list[str]
+    release: str
+
+
+@dataclass
+class MultipassInfo:
+    name: str
+    state: str
+    ipv4: list[str]
+    release: str
+    image_hash: str = ''
+    load: list[float] = field(default_factory=list)
+    disk_usage: dict[str, str] = field(default_factory=dict)
+    memory_usage: dict[str, str] = field(default_factory=dict)
+    mounts: dict[str, Any] = field(default_factory=dict)
+
+
+class MultipassCLI:
+    async def _run(self, *args: str) -> str:
+        process = await asyncio.create_subprocess_exec(
+            'multipass',
+            *args,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, stderr = await process.communicate()
+        if process.returncode != 0:
+            raise Exception(f"Multipass error: {stderr.decode().strip()}")
+        return stdout.decode().strip()
+
+    async def list_instances(self) -> list[MultipassInstance]:
+        output = await self._run('list', '--format', 'json')
+        data = json.loads(output)
+        instances = []
+        for item in data.get('list', []):
+            instances.append(
+                MultipassInstance(
+                    name=item['name'],
+                    state=item['state'],
+                    ipv4=item['ipv4'],
+                    release=item['release'],
+                ),
+            )
+        return instances
+
+    async def start_instance(self, name: str) -> str:
+        return await self._run('start', name)
+
+    async def stop_instance(self, name: str) -> str:
+        return await self._run('stop', name)
+
+    async def delete_instance(self, name: str, purge: bool = False) -> str:
+        args = ['delete', name]
+        if purge:
+            args.append('--purge')
+        return await self._run(*args)
+
+    async def purge_instances(self) -> str:
+        return await self._run('purge')
+
+    async def execute_command(self, name: str, command: str) -> str:
+        return await self._run('exec', name, '--', *command.split())
+
+    async def get_info(self, name: str) -> MultipassInfo:
+        output = await self._run('info', name, '--format', 'json')
+        data = json.loads(output)
+        info = data.get('info', {}).get(name, {})
+        if not info:
+            raise Exception(f"Instance {name} not found")
+
+        return MultipassInfo(
+            name=name,
+            state=info.get('state', ''),
+            ipv4=info.get('ipv4', []),
+            release=info.get('release', ''),
+            image_hash=info.get('image_hash', ''),
+            load=info.get('load', []),
+            disk_usage=info.get('disks', {}),
+            memory_usage=info.get('memory', {}),
+            mounts=info.get('mounts', {}),
+        )
+
+    async def launch_instance(
+        self,
+        name: str | None = None,
+        image: str | None = None,
+        cpus: int | None = None,
+        memory: str | None = None,
+        disk: str | None = None,
+    ) -> str:
+        args = ['launch']
+        if name:
+            args.extend(['--name', name])
+        if image:
+            args.append(image)
+        if cpus:
+            args.extend(['--cpus', str(cpus)])
+        if memory:
+            args.extend(['--memory', memory])
+        if disk:
+            args.extend(['--disk', disk])
+        return await self._run(*args)

multipass_mcp-0.1.1/multipass_mcp/server.py

@@ -0,0 +1,66 @@
+from fastmcp import FastMCP
+
+from .multipass import MultipassCLI
+from .multipass import MultipassInfo
+from .multipass import MultipassInstance
+
+# Initialize MCP server
+mcp = FastMCP('Multipass')
+cli = MultipassCLI()
+
+
+@mcp.tool()
+async def list_instances() -> list[MultipassInstance]:
+    """List all Multipass instances."""
+    return await cli.list_instances()
+
+
+@mcp.tool()
+async def launch_instance(
+    name: str | None = None,
+    image: str | None = None,
+    cpus: int | None = None,
+    memory: str | None = None,
+    disk: str | None = None,
+) -> str:
+    """Launch a new Multipass instance."""
+    return await cli.launch_instance(name, image, cpus, memory, disk)
+
+
+@mcp.tool()
+async def start_instance(name: str) -> str:
+    """Start a Multipass instance."""
+    return await cli.start_instance(name)
+
+
+@mcp.tool()
+async def stop_instance(name: str) -> str:
+    """Stop a Multipass instance."""
+    return await cli.stop_instance(name)
+
+
+@mcp.tool()
+async def delete_instance(name: str, purge: bool = False) -> str:
+    """Delete a Multipass instance."""
+    return await cli.delete_instance(name, purge)
+
+
+@mcp.tool()
+async def purge_instances() -> str:
+    """Purge all deleted Multipass instances."""
+    return await cli.purge_instances()
+
+
+@mcp.tool()
+async def execute_command(name: str, command: str) -> str:
+    """Execute a command in a Multipass instance."""
+    return await cli.execute_command(name, command)
+
+
+@mcp.tool()
+async def get_instance_info(name: str) -> MultipassInfo:
+    """Get detailed information about a Multipass instance."""
+    return await cli.get_info(name)
+
+if __name__ == '__main__':
+    mcp.run()

multipass_mcp-0.1.1/pyproject.toml

@@ -0,0 +1,48 @@
+[project]
+name = "multipass-mcp"
+version = "0.1.1"
+description = "Multipass MCP Server"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "fastmcp>=3.1.0",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=9.0.2",
+    "pytest-asyncio>=1.3.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project.scripts]
+multipass-mcp = "multipass_mcp.server:mcp.run"
+
+[tool.bumpversion]
+parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
+serialize = ["{major}.{minor}.{patch}"]
+search = "{current_version}"
+replace = "{new_version}"
+regex = false
+ignore_missing_version = false
+ignore_missing_files = false
+tag = false
+sign_tags = false
+tag_name = "v{new_version}"
+tag_message = "Bump version: {current_version} → {new_version}"
+allow_dirty = false
+commit = false
+message = "Bump version: {current_version} → {new_version}"
+moveable_tags = []
+commit_args = ""
+setup_hooks = []
+pre_commit_hooks = []
+post_commit_hooks = []
+
+[tool.bump-my-version.files]
+"pyproject.toml" = [
+    'project.version'
+]

multipass_mcp-0.1.1/tests/multipass_test.py

@@ -0,0 +1,94 @@
+import json
+from unittest.mock import AsyncMock
+from unittest.mock import patch
+
+import pytest
+
+from multipass_mcp.multipass import MultipassCLI
+from multipass_mcp.multipass import MultipassInfo
+from multipass_mcp.multipass import MultipassInstance
+
+
+@pytest.fixture
+def cli():
+    return MultipassCLI()
+
+
+@pytest.mark.asyncio
+async def test_list_instances(cli):
+    mock_output = json.dumps({
+        'list': [
+            {
+                'name': 'test-vm', 'state': 'Running',
+                'ipv4': ['192.168.64.2'], 'release': 'Ubuntu 22.04 LTS',
+            },
+        ],
+    })
+
+    with patch('asyncio.create_subprocess_exec') as mock_exec:
+        mock_process = AsyncMock()
+        mock_process.communicate.return_value = (mock_output.encode(), b'')
+        mock_process.returncode = 0
+        mock_exec.return_value = mock_process
+
+        result = await cli.list_instances()
+        assert len(result) == 1
+        assert isinstance(result[0], MultipassInstance)
+        assert result[0].name == 'test-vm'
+        mock_exec.assert_called_with(
+            'multipass', 'list', '--format', 'json',
+            stdout=-1, stderr=-1,
+        )
+
+
+@pytest.mark.asyncio
+async def test_get_info(cli):
+    mock_output = json.dumps({
+        'info': {
+            'test-vm': {
+                'state': 'Running',
+                'ipv4': ['192.168.64.2'],
+                'release': 'Ubuntu 22.04 LTS',
+                'image_hash': 'hash123',
+            },
+        },
+    })
+
+    with patch('asyncio.create_subprocess_exec') as mock_exec:
+        mock_process = AsyncMock()
+        mock_process.communicate.return_value = (mock_output.encode(), b'')
+        mock_process.returncode = 0
+        mock_exec.return_value = mock_process
+
+        result = await cli.get_info('test-vm')
+        assert isinstance(result, MultipassInfo)
+        assert result.name == 'test-vm'
+        assert result.image_hash == 'hash123'
+
+
+@pytest.mark.asyncio
+async def test_start_instance(cli):
+    with patch('asyncio.create_subprocess_exec') as mock_exec:
+        mock_process = AsyncMock()
+        mock_process.communicate.return_value = (b'', b'')
+        mock_process.returncode = 0
+        mock_exec.return_value = mock_process
+
+        await cli.start_instance('test-vm')
+        mock_exec.assert_called_with(
+            'multipass', 'start', 'test-vm',
+            stdout=-1, stderr=-1,
+        )
+
+
+@pytest.mark.asyncio
+async def test_error_handling(cli):
+    with patch('asyncio.create_subprocess_exec') as mock_exec:
+        mock_process = AsyncMock()
+        mock_process.communicate.return_value = (b'', b'Error message')
+        mock_process.returncode = 1
+        mock_exec.return_value = mock_process
+
+        with pytest.raises(Exception) as excinfo:
+            await cli.list_instances()
+        assert 'Multipass error: Error message' in str(excinfo.value)