kmcp 0.1.5.dev0__tar.gz → 0.1.7.dev0__tar.gz

{kmcp-0.1.5.dev0 → kmcp-0.1.7.dev0}/.github/workflows/release.yml

@@ -34,9 +34,6 @@ jobs:
       - name: Run integration tests
         run: python -m pytest tests/integration
 
-      - name: Lint with ruff
-        run: ruff check src/ tests/
-
   build-and-publish:
     name: Build and publish to PyPI
     needs: test

{kmcp-0.1.5.dev0 → kmcp-0.1.7.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kmcp
-Version: 0.1.5.dev0
+Version: 0.1.7.dev0
 Summary: MCP server exposing Kali Linux penetration-testing tools to AI agents
 Author: kali-mcp
 License: MIT

{kmcp-0.1.5.dev0 → kmcp-0.1.7.dev0}/src/kali_mcp/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.1.5.dev0'
-__version_tuple__ = version_tuple = (0, 1, 5, 'dev0')
+__version__ = version = '0.1.7.dev0'
+__version_tuple__ = version_tuple = (0, 1, 7, 'dev0')
 
-__commit_id__ = commit_id = 'gadbac29cb'
+__commit_id__ = commit_id = 'g5916172e7'

{kmcp-0.1.5.dev0 → kmcp-0.1.7.dev0}/src/kali_mcp/execution.py

@@ -275,7 +275,7 @@ class ExecutionEngine:
                             heartbeat_task.cancel()
                             try:
                                 await heartbeat_task
-                            except (asyncio.CancelledError, Exception): # noqa: S110, BLE001
+                            except (asyncio.CancelledError, Exception):  # noqa: S110, BLE001
                                 pass
                         if progress_cb is not None:
                             try:
@@ -313,7 +313,7 @@ class ExecutionEngine:
                         heartbeat_task.cancel()
                         try:
                             await heartbeat_task
-                        except (asyncio.CancelledError, Exception): # noqa: S110, BLE001
+                        except (asyncio.CancelledError, Exception):  # noqa: S110, BLE001
                             pass
                     return result
 

{kmcp-0.1.5.dev0 → kmcp-0.1.7.dev0}/src/kali_mcp/monitor/sse_client.py

@@ -39,28 +39,29 @@ class SseClient:
     async def _read_loop(self) -> None:
         while not self._closed:
             try:
-                async with httpx.AsyncClient(timeout=None) as http, http.stream(
-                    "GET", self.url
-                ) as response:
-                        response.raise_for_status()
-                        async for line in response.aiter_lines():
-                            if self._closed:
-                                return
-                            if line.startswith("data: "):
+                async with (
+                    httpx.AsyncClient(timeout=None) as http,
+                    http.stream("GET", self.url) as response,
+                ):
+                    response.raise_for_status()
+                    async for line in response.aiter_lines():
+                        if self._closed:
+                            return
+                        if line.startswith("data: "):
+                            try:
+                                payload = json.loads(line[len("data: ") :])
+                            except json.JSONDecodeError:
+                                continue
+                            self._snapshot = payload
+                            try:
+                                self._queue.put_nowait(payload)
+                            except asyncio.QueueFull:
+                                # Slow consumer — drop this snapshot
                                 try:
-                                    payload = json.loads(line[len("data: ") :])
-                                except json.JSONDecodeError:
-                                    continue
-                                self._snapshot = payload
-                                try:
-                                    self._queue.put_nowait(payload)
-                                except asyncio.QueueFull:
-                                    # Slow consumer — drop this snapshot
-                                    try:
-                                        self._queue.get_nowait()
-                                    except asyncio.QueueEmpty:
-                                        pass
-                                    self._queue.put_nowait(payload)
+                                    self._queue.get_nowait()
+                                except asyncio.QueueEmpty:
+                                    pass
+                                self._queue.put_nowait(payload)
             except (httpx.ConnectError, httpx.ReadError, OSError):
                 # Server went down — retry after a short pause
                 await asyncio.sleep(2.0)

{kmcp-0.1.5.dev0 → kmcp-0.1.7.dev0}/src/kali_mcp/tools/file_read.py

@@ -135,7 +135,7 @@ class FileReadTool(BaseTool):
             )
 
             return success_response(result)
-        except Exception as e: # noqa: BLE001
+        except Exception as e:  # noqa: BLE001
             return error_response(
                 ToolError(
                     error="Read failed",

{kmcp-0.1.5.dev0 → kmcp-0.1.7.dev0}/src/kali_mcp/utils/process.py

@@ -32,5 +32,5 @@ async def kill_process_tree(proc: asyncio.subprocess.Process) -> None:
         except TimeoutError:
             pass
 
-    except Exception as e: # noqa: BLE001
+    except Exception as e:  # noqa: BLE001
         logger.warning("Error killing process %s: %s", getattr(proc, "pid", "?"), e)

{kmcp-0.1.5.dev0 → kmcp-0.1.7.dev0}/src/kmcp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kmcp
-Version: 0.1.5.dev0
+Version: 0.1.7.dev0
 Summary: MCP server exposing Kali Linux penetration-testing tools to AI agents
 Author: kali-mcp
 License: MIT

kmcp-0.1.7.dev0/src/kmcp.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.1.6",
+  "distance": 0,
+  "node": "g5916172e78bcfd8484f6e1853bfae1518828a77f",
+  "dirty": true,
+  "branch": "HEAD",
+  "node_date": "2026-11-03"
+}

kmcp-0.1.7.dev0/tests/e2e/test_mcp_prompts_resources.py

@@ -0,0 +1,142 @@
+"""E2E: MCP prompts and resources over the live protocol (server spawned for real)."""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+import httpx
+import pytest
+from mcp.client.session import ClientSession
+from mcp.client.streamable_http import streamable_http_client
+
+REPO_ROOT = Path(__file__).resolve().parent.parent.parent
+
+
+@pytest.fixture(scope="module")
+def server_url():
+    import os
+    import socket
+
+    with socket.socket() as s:
+        s.bind(("127.0.0.1", 0))
+        port = s.getsockname()[1]
+    env = {
+        **os.environ,
+        "MCP_HOST": "127.0.0.1",
+        "MCP_PORT": str(port),
+        "MCP_TRANSPORT": "streamable-http",
+        "MCP_DEBUG": "false",
+        "MCP_DB_ENABLED": "false",
+    }
+    proc = subprocess.Popen(
+        [sys.executable, str(REPO_ROOT / "src" / "kali_mcp" / "server.py")],
+        cwd=REPO_ROOT,
+        env=env,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+    base = f"http://127.0.0.1:{port}"
+    try:
+        last_err = None
+        for _ in range(60):
+            if proc.poll() is not None:
+                raise RuntimeError("server exited early")
+            try:
+                httpx.get(f"{base}/mcp", timeout=1)
+                last_err = None
+                break
+            except Exception as exc:  # noqa: BLE001
+                last_err = exc
+                import time
+
+                time.sleep(0.5)
+        if last_err is not None:
+            raise RuntimeError(f"server not ready: {last_err}")
+        yield f"{base}/mcp"
+    finally:
+        proc.terminate()
+        try:
+            proc.wait(timeout=10)
+        except subprocess.TimeoutExpired:
+            proc.kill()
+
+
+@pytest.mark.e2e
+async def test_prompts_listed_and_rendered(server_url):
+    async with (
+        streamable_http_client(server_url) as (read, write, _sid),
+        ClientSession(read, write) as session,
+    ):
+        await session.initialize()
+
+        prompts = await session.list_prompts()
+        names = {p.name for p in prompts.prompts}
+        assert {
+            "recon_workflow",
+            "webapp_assessment",
+            "ad_assessment",
+            "osint_harvest",
+            "quick_scan",
+            "report_template",
+        } <= names
+
+        result = await session.get_prompt("recon_workflow", {"target": "example.com"})
+        assert len(result.messages) == 2
+        assert "example.com" in result.messages[0].content.text
+
+
+@pytest.mark.e2e
+async def test_resources_listed_and_read(server_url):
+    async with (
+        streamable_http_client(server_url) as (read, write, _sid),
+        ClientSession(read, write) as session,
+    ):
+        await session.initialize()
+
+        resources = await session.list_resources()
+        uris = {str(r.uri) for r in resources.resources}
+        assert {
+            "kali://config",
+            "kali://tools",
+            "kali://health",
+            "kali://db/stats",
+            "kali://vault/index",
+            "kali://artifacts",
+        } <= uris
+
+        # Read config + health resources
+        config_res = await session.read_resource("kali://config")
+        assert config_res.contents[0].mimeType == "application/json"
+        import json
+
+        cfg = json.loads(config_res.contents[0].text)
+        # The server runs on a random port — config must reflect reality
+        assert cfg["port"] == int(server_url.split(":")[2].split("/")[0])
+
+        health_res = await session.read_resource("kali://health")
+        health = json.loads(health_res.contents[0].text)
+        assert len(health) > 0
+
+
+@pytest.mark.e2e
+async def test_orchestration_tools_callable_via_mcp(server_url):
+    """playbook_list / playbook_status / parallel_status must round-trip."""
+    import json
+
+    async with (
+        streamable_http_client(server_url) as (read, write, _sid),
+        ClientSession(read, write) as session,
+    ):
+        await session.initialize()
+
+        result = await session.call_tool("playbook_list", {})
+        assert result.isError is False
+        payload = json.loads(result.content[0].text)
+        assert payload["success"] is False or payload  # ExecutionResult or error dict
+
+        result = await session.call_tool("playbook_status", {"name": "nope"})
+        payload = json.loads(result.content[0].text)
+        assert payload["success"] is False
+        assert "Unknown playbook" in payload["error"]

{kmcp-0.1.5.dev0 → kmcp-0.1.7.dev0}/tests/unit/test_db_manager_extended.py

@@ -92,9 +92,7 @@ class TestDBManagerEdgeCases:
                 mock_config.db_enabled = True
                 import tempfile
 
-                mock_config.db_path = (
-                    str(tempfile.mkdtemp()) + "/singleton.sqlite"
-                )
+                mock_config.db_path = str(tempfile.mkdtemp()) + "/singleton.sqlite"
                 db1 = get_db()
                 db2 = get_db()
                 assert db1 is db2

{kmcp-0.1.5.dev0 → kmcp-0.1.7.dev0}/tests/unit/test_vault_extended.py

@@ -153,7 +153,5 @@ class TestVaultRowSizeLimit:
             from kali_mcp import config as cfg
 
             small_cfg = replace(cfg.config, vault_max_row_bytes=100)
-            with patch("kali_mcp.utils.vault.config", small_cfg), pytest.raises(
-                ValueError
-            ):
+            with patch("kali_mcp.utils.vault.config", small_cfg), pytest.raises(ValueError):
                 vault_write("runs/big", "big", {"data": "x" * 1000})

kmcp-0.1.5.dev0/src/kmcp.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "0.1.4",
-  "distance": 0,
-  "node": "gadbac29cb12034dc9eb7716640a7156ffd90536f",
-  "dirty": true,
-  "branch": "master",
-  "node_date": "2026-11-03"
-}

kmcp-0.1.5.dev0/tests/e2e/test_mcp_prompts_resources.py

@@ -1,139 +0,0 @@
-"""E2E: MCP prompts and resources over the live protocol (server spawned for real)."""
-
-from __future__ import annotations
-
-import subprocess
-import sys
-from pathlib import Path
-
-import httpx
-import pytest
-from mcp.client.session import ClientSession
-from mcp.client.streamable_http import streamable_http_client
-
-REPO_ROOT = Path(__file__).resolve().parent.parent.parent
-
-
-@pytest.fixture(scope="module")
-def server_url():
-    import os
-    import socket
-
-    with socket.socket() as s:
-        s.bind(("127.0.0.1", 0))
-        port = s.getsockname()[1]
-    env = {
-        **os.environ,
-        "MCP_HOST": "127.0.0.1",
-        "MCP_PORT": str(port),
-        "MCP_TRANSPORT": "streamable-http",
-        "MCP_DEBUG": "false",
-        "MCP_DB_ENABLED": "false",
-    }
-    proc = subprocess.Popen(
-        [sys.executable, str(REPO_ROOT / "src" / "kali_mcp" / "server.py")],
-        cwd=REPO_ROOT,
-        env=env,
-        stdout=subprocess.DEVNULL,
-        stderr=subprocess.DEVNULL,
-    )
-    base = f"http://127.0.0.1:{port}"
-    try:
-        last_err = None
-        for _ in range(60):
-            if proc.poll() is not None:
-                raise RuntimeError("server exited early")
-            try:
-                httpx.get(f"{base}/mcp", timeout=1)
-                last_err = None
-                break
-            except Exception as exc:  # noqa: BLE001
-                last_err = exc
-                import time
-
-                time.sleep(0.5)
-        if last_err is not None:
-            raise RuntimeError(f"server not ready: {last_err}")
-        yield f"{base}/mcp"
-    finally:
-        proc.terminate()
-        try:
-            proc.wait(timeout=10)
-        except subprocess.TimeoutExpired:
-            proc.kill()
-
-
-@pytest.mark.e2e
-async def test_prompts_listed_and_rendered(server_url):
-    async with streamable_http_client(server_url) as (read, write, _sid), ClientSession(
-        read, write
-    ) as session:
-            await session.initialize()
-
-            prompts = await session.list_prompts()
-            names = {p.name for p in prompts.prompts}
-            assert {
-                "recon_workflow",
-                "webapp_assessment",
-                "ad_assessment",
-                "osint_harvest",
-                "quick_scan",
-                "report_template",
-            } <= names
-
-            result = await session.get_prompt("recon_workflow", {"target": "example.com"})
-            assert len(result.messages) == 2
-            assert "example.com" in result.messages[0].content.text
-
-
-@pytest.mark.e2e
-async def test_resources_listed_and_read(server_url):
-    async with streamable_http_client(server_url) as (read, write, _sid), ClientSession(
-        read, write
-    ) as session:
-            await session.initialize()
-
-            resources = await session.list_resources()
-            uris = {str(r.uri) for r in resources.resources}
-            assert {
-                "kali://config",
-                "kali://tools",
-                "kali://health",
-                "kali://db/stats",
-                "kali://vault/index",
-                "kali://artifacts",
-            } <= uris
-
-            # Read config + health resources
-            config_res = await session.read_resource("kali://config")
-            assert config_res.contents[0].mimeType == "application/json"
-            import json
-
-            cfg = json.loads(config_res.contents[0].text)
-            # The server runs on a random port — config must reflect reality
-            assert cfg["port"] == int(server_url.split(":")[2].split("/")[0])
-
-            health_res = await session.read_resource("kali://health")
-            health = json.loads(health_res.contents[0].text)
-            assert len(health) > 0
-
-
-@pytest.mark.e2e
-async def test_orchestration_tools_callable_via_mcp(server_url):
-    """playbook_list / playbook_status / parallel_status must round-trip."""
-    import json
-
-    async with streamable_http_client(server_url) as (read, write, _sid), ClientSession(
-        read, write
-    ) as session:
-            await session.initialize()
-
-            result = await session.call_tool("playbook_list", {})
-            assert result.isError is False
-            payload = json.loads(result.content[0].text)
-            assert payload["success"] is False or payload  # ExecutionResult or error dict
-
-            result = await session.call_tool("playbook_status", {"name": "nope"})
-            payload = json.loads(result.content[0].text)
-            assert payload["success"] is False
-            assert "Unknown playbook" in payload["error"]