whitecapdata-dev 0.1.0__py3-none-any.whl

homelab_mcp/__init__.py

@@ -0,0 +1,12 @@
+"""homelab-mcp — operate a k3s / Kubernetes cluster from an MCP client.
+
+Exposes read and (guarded) write tools over the Kubernetes API so an agent
+(Claude Code, Claude Desktop, Cursor, …) can inspect cluster health and perform
+safe, allowlisted operations — without shelling out to kubectl.
+"""
+
+from .config import Config
+from .kube import HomelabMCPError, KubeClient
+
+__all__ = ["Config", "KubeClient", "HomelabMCPError", "__version__"]
+__version__ = "0.1.0"

homelab_mcp/config.py

@@ -0,0 +1,54 @@
+"""Environment-driven configuration for the homelab-mcp server."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+
+# Sensible homelab default: only let mutating tools touch these namespaces.
+# Override with HOMELAB_MCP_MUTABLE_NAMESPACES; set it to "*" to allow all.
+DEFAULT_MUTABLE_NAMESPACES = ("default", "apps", "monitoring", "ci")
+DEFAULT_MAX_REPLICAS = 10
+_TRUE = {"1", "true", "yes", "on"}
+
+
+@dataclass(frozen=True)
+class Config:
+    """Effective server configuration, sourced from the environment."""
+
+    context: str | None = None
+    read_only: bool = False
+    mutable_namespaces: tuple[str, ...] = DEFAULT_MUTABLE_NAMESPACES
+    max_replicas: int = DEFAULT_MAX_REPLICAS
+
+    @classmethod
+    def from_env(cls, env: dict[str, str] | None = None) -> Config:
+        src = os.environ if env is None else env
+        raw_ns = src.get("HOMELAB_MCP_MUTABLE_NAMESPACES")
+        if raw_ns is None:
+            namespaces = DEFAULT_MUTABLE_NAMESPACES
+        elif raw_ns.strip() == "*":
+            namespaces = ()  # empty tuple == every namespace allowed
+        else:
+            namespaces = tuple(n.strip() for n in raw_ns.split(",") if n.strip())
+        return cls(
+            context=src.get("HOMELAB_MCP_CONTEXT") or None,
+            read_only=src.get("HOMELAB_MCP_READONLY", "").lower() in _TRUE,
+            mutable_namespaces=namespaces,
+            max_replicas=int(src.get("HOMELAB_MCP_MAX_REPLICAS", str(DEFAULT_MAX_REPLICAS))),
+        )
+
+    def namespace_allowed(self, namespace: str) -> bool:
+        """True if mutating tools may act on ``namespace``.
+
+        An empty allowlist means "all namespaces" (the operator opted in via ``*``).
+        """
+        return not self.mutable_namespaces or namespace in self.mutable_namespaces
+
+    def as_dict(self) -> dict[str, object]:
+        return {
+            "context": self.context or "(current-context)",
+            "read_only": self.read_only,
+            "mutable_namespaces": list(self.mutable_namespaces) or ["*"],
+            "max_replicas": self.max_replicas,
+        }

homelab_mcp/format.py

@@ -0,0 +1,125 @@
+"""Pure mappers from Kubernetes API objects to plain JSON-able structures.
+
+These take any object that exposes the same attributes as the official
+``kubernetes`` client models, so they're unit-testable with lightweight fakes
+(e.g. ``types.SimpleNamespace``) — no cluster required.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def _attr(obj: Any, *path: str, default: Any = None) -> Any:
+    """Safely walk a chain of attributes, returning ``default`` on any miss."""
+    cur = obj
+    for name in path:
+        if cur is None:
+            return default
+        cur = getattr(cur, name, None)
+    return cur if cur is not None else default
+
+
+def pod_is_healthy(pod: Any) -> bool:
+    """A pod is healthy if it's Running/Succeeded and all containers are ready."""
+    phase = _attr(pod, "status", "phase", default="")
+    if phase == "Succeeded":
+        return True
+    if phase != "Running":
+        return False
+    statuses = _attr(pod, "status", "container_statuses", default=[]) or []
+    return all(getattr(cs, "ready", False) for cs in statuses)
+
+
+def pod_row(pod: Any) -> dict[str, Any]:
+    statuses = _attr(pod, "status", "container_statuses", default=[]) or []
+    restarts = sum(getattr(cs, "restart_count", 0) or 0 for cs in statuses)
+    return {
+        "namespace": _attr(pod, "metadata", "namespace", default=""),
+        "name": _attr(pod, "metadata", "name", default=""),
+        "phase": _attr(pod, "status", "phase", default=""),
+        "ready": pod_is_healthy(pod),
+        "restarts": restarts,
+        "node": _attr(pod, "spec", "node_name", default=""),
+    }
+
+
+def pod_rows(pods: list[Any]) -> list[dict[str, Any]]:
+    """Rows for a pod list, unhealthy first then by namespace/name."""
+    rows = [pod_row(p) for p in pods]
+    rows.sort(key=lambda r: (r["ready"], r["namespace"], r["name"]))
+    return rows
+
+
+def deployment_row(dep: Any) -> dict[str, Any]:
+    desired = _attr(dep, "spec", "replicas", default=0) or 0
+    ready = _attr(dep, "status", "ready_replicas", default=0) or 0
+    return {
+        "namespace": _attr(dep, "metadata", "namespace", default=""),
+        "name": _attr(dep, "metadata", "name", default=""),
+        "ready_replicas": ready,
+        "desired_replicas": desired,
+        "available": ready >= desired and desired > 0,
+    }
+
+
+def deployment_rows(deps: list[Any]) -> list[dict[str, Any]]:
+    rows = [deployment_row(d) for d in deps]
+    rows.sort(key=lambda r: (r["available"], r["namespace"], r["name"]))
+    return rows
+
+
+def node_row(node: Any) -> dict[str, Any]:
+    conditions = _attr(node, "status", "conditions", default=[]) or []
+    ready = any(getattr(c, "type", "") == "Ready" and getattr(c, "status", "") == "True" for c in conditions)
+    # Pressure conditions are healthy when "False".
+    pressures = {
+        getattr(c, "type", ""): getattr(c, "status", "")
+        for c in conditions
+        if getattr(c, "type", "").endswith("Pressure")
+    }
+    cap = _attr(node, "status", "capacity", default={}) or {}
+    return {
+        "name": _attr(node, "metadata", "name", default=""),
+        "ready": ready,
+        "kubelet": _attr(node, "status", "node_info", "kubelet_version", default=""),
+        "cpu": cap.get("cpu", ""),
+        "memory": cap.get("memory", ""),
+        "pressure": [k for k, v in pressures.items() if v == "True"],
+    }
+
+
+def node_rows(nodes: list[Any]) -> list[dict[str, Any]]:
+    return [node_row(n) for n in nodes]
+
+
+def cluster_summary(nodes: list[Any], pods: list[Any]) -> dict[str, Any]:
+    node_data = node_rows(nodes)
+    pod_data = pod_rows(pods)
+    unhealthy = [p for p in pod_data if not p["ready"]]
+    phases: dict[str, int] = {}
+    for p in pod_data:
+        phases[p["phase"]] = phases.get(p["phase"], 0) + 1
+    return {
+        "nodes": {"total": len(node_data), "ready": sum(1 for n in node_data if n["ready"])},
+        "pods": {"total": len(pod_data), "by_phase": phases, "unhealthy": len(unhealthy)},
+        "unhealthy_pods": unhealthy,
+    }
+
+
+def event_row(ev: Any) -> dict[str, Any]:
+    return {
+        "type": _attr(ev, "type", default=""),
+        "reason": _attr(ev, "reason", default=""),
+        "object": f"{_attr(ev, 'involved_object', 'kind', default='')}/"
+        f"{_attr(ev, 'involved_object', 'name', default='')}",
+        "namespace": _attr(ev, "metadata", "namespace", default=""),
+        "message": _attr(ev, "message", default=""),
+    }
+
+
+def event_rows(events: list[Any], limit: int) -> list[dict[str, Any]]:
+    rows = [event_row(e) for e in events]
+    # Warnings first so problems surface at the top.
+    rows.sort(key=lambda r: r["type"] != "Warning")
+    return rows[:limit]

homelab_mcp/kube.py

@@ -0,0 +1,118 @@
+"""Kubernetes API wrapper used by the MCP tools.
+
+Reads happen through the CoreV1/AppsV1 APIs and are shaped by :mod:`format`.
+Mutations are gated on the operator's config (read-only switch + namespace
+allowlist) *before* any API call, so a misbehaving agent can't scale or delete
+outside the sandbox the operator allowed.
+
+The official ``kubernetes`` client is imported lazily so the pure logic (and
+its tests) don't require it to be installed or a cluster to be reachable.
+"""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from typing import Any
+
+from . import format as fmt
+from .config import Config
+
+RESTART_ANNOTATION = "kubectl.kubernetes.io/restartedAt"
+
+
+class HomelabMCPError(RuntimeError):
+    """A user-facing error (bad config, blocked mutation, or API failure)."""
+
+
+def _load_apis(config: Config) -> tuple[Any, Any]:
+    """Load kube config (in-cluster, else kubeconfig) and return (core, apps)."""
+    try:
+        from kubernetes import client  # noqa: PLC0415
+        from kubernetes import config as kube_config  # noqa: PLC0415
+    except ImportError as exc:  # pragma: no cover - import guard
+        raise HomelabMCPError(
+            "The 'kubernetes' package is required. Install with: pip install homelab-mcp"
+        ) from exc
+    try:
+        kube_config.load_incluster_config()
+    except kube_config.ConfigException:
+        kube_config.load_kube_config(context=config.context)
+    return client.CoreV1Api(), client.AppsV1Api()
+
+
+class KubeClient:
+    """Thin, testable facade over the parts of the Kubernetes API we expose."""
+
+    def __init__(self, config: Config, core_v1: Any = None, apps_v1: Any = None) -> None:
+        self._config = config
+        if core_v1 is None or apps_v1 is None:
+            core_v1, apps_v1 = _load_apis(config)
+        self._core = core_v1
+        self._apps = apps_v1
+
+    @property
+    def config(self) -> Config:
+        return self._config
+
+    # -- reads ---------------------------------------------------------------
+
+    def _pods(self, namespace: str = "") -> list[Any]:
+        if namespace:
+            return self._core.list_namespaced_pod(namespace).items
+        return self._core.list_pod_for_all_namespaces().items
+
+    def cluster_summary(self) -> dict[str, Any]:
+        nodes = self._core.list_node().items
+        return fmt.cluster_summary(nodes, self._pods())
+
+    def list_pods(self, namespace: str = "") -> list[dict[str, Any]]:
+        return fmt.pod_rows(self._pods(namespace))
+
+    def list_deployments(self, namespace: str = "") -> list[dict[str, Any]]:
+        if namespace:
+            deps = self._apps.list_namespaced_deployment(namespace).items
+        else:
+            deps = self._apps.list_deployment_for_all_namespaces().items
+        return fmt.deployment_rows(deps)
+
+    def list_events(self, limit: int = 30) -> list[dict[str, Any]]:
+        events = self._core.list_event_for_all_namespaces().items
+        return fmt.event_rows(events, limit)
+
+    def pod_logs(self, namespace: str, pod: str, tail: int = 200) -> str:
+        return self._core.read_namespaced_pod_log(name=pod, namespace=namespace, tail_lines=tail)
+
+    def node_health(self) -> list[dict[str, Any]]:
+        return fmt.node_rows(self._core.list_node().items)
+
+    # -- mutations (guarded) -------------------------------------------------
+
+    def _guard(self, namespace: str) -> None:
+        if self._config.read_only:
+            raise HomelabMCPError("Server is in read-only mode; mutations are disabled.")
+        if not self._config.namespace_allowed(namespace):
+            allowed = ", ".join(self._config.mutable_namespaces) or "*"
+            raise HomelabMCPError(
+                f"Namespace '{namespace}' is not in the mutable allowlist ({allowed})."
+            )
+
+    def restart_deployment(self, namespace: str, name: str) -> str:
+        self._guard(namespace)
+        stamp = datetime.now(UTC).isoformat()
+        body = {"spec": {"template": {"metadata": {"annotations": {RESTART_ANNOTATION: stamp}}}}}
+        self._apps.patch_namespaced_deployment(name=name, namespace=namespace, body=body)
+        return f"restarted deployment {namespace}/{name} at {stamp}"
+
+    def scale_deployment(self, namespace: str, name: str, replicas: int) -> str:
+        self._guard(namespace)
+        if not 0 <= replicas <= self._config.max_replicas:
+            raise HomelabMCPError(f"replicas must be between 0 and {self._config.max_replicas}.")
+        self._apps.patch_namespaced_deployment_scale(
+            name=name, namespace=namespace, body={"spec": {"replicas": replicas}}
+        )
+        return f"scaled deployment {namespace}/{name} to {replicas} replicas"
+
+    def delete_pod(self, namespace: str, name: str) -> str:
+        self._guard(namespace)
+        self._core.delete_namespaced_pod(name=name, namespace=namespace)
+        return f"deleted pod {namespace}/{name} (its controller will recreate it)"

homelab_mcp/server.py

@@ -0,0 +1,113 @@
+"""The homelab-mcp MCP server.
+
+Tools return JSON strings so the calling agent gets structured, compact data.
+Reads are always available; mutations are gated by the operator's config
+(read-only switch + namespace allowlist) enforced in :class:`KubeClient`.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from mcp.server.fastmcp import FastMCP
+
+from .config import Config
+from .kube import KubeClient
+
+mcp = FastMCP("homelab")
+
+_client: KubeClient | None = None
+
+
+def get_client() -> KubeClient:
+    """Lazily build the cluster client (so import never touches a cluster)."""
+    global _client
+    if _client is None:
+        _client = KubeClient(Config.from_env())
+    return _client
+
+
+def set_client(client: KubeClient) -> None:
+    """Replace the module-level client (used by tests)."""
+    global _client
+    _client = client
+
+
+def _json(data: Any) -> str:
+    return json.dumps(data, indent=2, default=str)
+
+
+# -- reads -------------------------------------------------------------------
+
+
+@mcp.tool()
+def cluster_summary() -> str:
+    """Node and pod health totals plus the list of unhealthy pods. Start here."""
+    return _json(get_client().cluster_summary())
+
+
+@mcp.tool()
+def list_pods(namespace: str = "") -> str:
+    """List pods (optionally one namespace). Unhealthy pods sort first."""
+    return _json(get_client().list_pods(namespace))
+
+
+@mcp.tool()
+def list_deployments(namespace: str = "") -> str:
+    """List deployments with ready/desired replica counts."""
+    return _json(get_client().list_deployments(namespace))
+
+
+@mcp.tool()
+def list_events(limit: int = 30) -> str:
+    """Recent cluster events; Warning-type events sort first."""
+    return _json(get_client().list_events(limit))
+
+
+@mcp.tool()
+def pod_logs(namespace: str, pod: str, tail: int = 200) -> str:
+    """Tail a pod's logs."""
+    return get_client().pod_logs(namespace, pod, tail)
+
+
+@mcp.tool()
+def node_health() -> str:
+    """Per-node readiness, kubelet version, capacity, and pressure conditions."""
+    return _json(get_client().node_health())
+
+
+# -- mutations (guarded by read-only + namespace allowlist) ------------------
+
+
+@mcp.tool()
+def restart_deployment(namespace: str, name: str) -> str:
+    """Rollout-restart a deployment (subject to the mutable-namespace allowlist)."""
+    return get_client().restart_deployment(namespace, name)
+
+
+@mcp.tool()
+def scale_deployment(namespace: str, name: str, replicas: int) -> str:
+    """Scale a deployment to N replicas (0..max), subject to the allowlist."""
+    return get_client().scale_deployment(namespace, name, replicas)
+
+
+@mcp.tool()
+def delete_pod(namespace: str, name: str) -> str:
+    """Delete a pod so its controller recreates it (subject to the allowlist)."""
+    return get_client().delete_pod(namespace, name)
+
+
+@mcp.tool()
+def server_info() -> str:
+    """Report the effective configuration (context, read-only, allowlist)."""
+    return _json(get_client().config.as_dict())
+
+
+def main() -> None:
+    """Console-script entry point: run the server over stdio."""
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

whitecapdata_dev-0.1.0.dist-info/METADATA

@@ -0,0 +1,136 @@
+Metadata-Version: 2.4
+Name: whitecapdata-dev
+Version: 0.1.0
+Summary: WhiteCapData-Dev — an MCP server to operate a k3s / Kubernetes cluster (health, logs, and guarded restart/scale/delete) straight from your AI agent.
+Project-URL: Homepage, https://github.com/Michael-WhiteCapData/WhiteCapData-Dev
+Project-URL: Repository, https://github.com/Michael-WhiteCapData/WhiteCapData-Dev
+Project-URL: Issues, https://github.com/Michael-WhiteCapData/WhiteCapData-Dev/issues
+Author: Michael Tierney
+License: MIT
+License-File: LICENSE
+Keywords: claude,devops,homelab,k3s,k8s,kubernetes,mcp,model-context-protocol
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: System :: Systems Administration
+Requires-Python: >=3.11
+Requires-Dist: kubernetes>=29
+Requires-Dist: mcp>=1.2
+Provides-Extra: dev
+Requires-Dist: pytest-cov>=5; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# WhiteCapData-Dev
+
+**Operate a k3s / Kubernetes cluster straight from your AI agent — safe by default.**
+
+[![CI](https://github.com/Michael-WhiteCapData/WhiteCapData-Dev/actions/workflows/ci.yml/badge.svg)](https://github.com/Michael-WhiteCapData/WhiteCapData-Dev/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/whitecapdata-dev?color=3775A9&logo=pypi&logoColor=white)](https://pypi.org/project/whitecapdata-dev/)
+[![Python](https://img.shields.io/badge/python-3.11%2B-3776AB?logo=python&logoColor=white)](https://www.python.org/)
+[![MCP](https://img.shields.io/badge/MCP-server-D97757)](https://modelcontextprotocol.io/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
+
+An [MCP](https://modelcontextprotocol.io/) server that lets an agent (Claude Code, Claude Desktop, Cursor, …) inspect and operate a **Kubernetes / k3s** cluster — your homelab box, a dev cluster, whatever your kubeconfig points at — **without shelling out to `kubectl`**. It talks to the Kubernetes API directly using your existing kubeconfig (or an in-cluster service account).
+
+The design goal is **safe by default**: reads are always on; every mutating action (restart / scale / delete) is gated *before the API call* by a read-only switch and a namespace allowlist, so an over-eager agent can't touch `kube-system` or nuke a deployment you didn't sandbox.
+
+> **Name note:** the PyPI package is `whitecapdata-dev` (the `homelab-k8s`-style name was taken); the import package and tools are k8s/homelab-focused as described here.
+
+---
+
+## Why you'd want this
+
+- 🩺 **One-call health.** `cluster_summary` gives node + pod totals and the unhealthy pods, so the agent starts triage with real data.
+- 🔒 **Safe by default.** Mutations are blocked unless the namespace is on your allowlist; flip `HOMELAB_MCP_READONLY=1` to make the whole server read-only.
+- 🧰 **The operations you actually do.** Pods, deployments, events, logs, node health, rollout-restart, scale, delete-pod.
+- 🪶 **No bespoke backend.** Uses the standard Kubernetes API + your kubeconfig — nothing to deploy server-side.
+- ✅ **Tested.** Pure logic is unit-tested with fakes; guard logic is tested against a mocked API. No cluster needed to run the suite.
+
+## Requirements
+
+- A reachable cluster and a working **kubeconfig** (the same one `kubectl` uses), or run it in-cluster with a service account.
+- Python 3.11+ (or just `uvx`).
+
+## Install
+
+```bash
+uvx whitecapdata-dev          # run directly
+# or
+pip install whitecapdata-dev  # then run: whitecapdata-dev
+```
+
+### Claude Code
+
+```bash
+claude mcp add homelab -- uvx whitecapdata-dev
+```
+
+### Claude Desktop / Cursor
+
+```jsonc
+{
+  "mcpServers": {
+    "homelab": {
+      "command": "uvx",
+      "args": ["whitecapdata-dev"],
+      "env": {
+        "HOMELAB_MCP_MUTABLE_NAMESPACES": "default,apps,monitoring",
+        "HOMELAB_MCP_READONLY": "0"
+      }
+    }
+  }
+}
+```
+
+## Tools
+
+| Tool | Kind | Description |
+| --- | --- | --- |
+| `cluster_summary` | read | Node/pod health totals + unhealthy pods |
+| `list_pods` | read | Pods (optionally one namespace), unhealthy first |
+| `list_deployments` | read | Deployments with ready/desired replicas |
+| `list_events` | read | Recent events, Warnings first |
+| `pod_logs` | read | Tail a pod's logs |
+| `node_health` | read | Per-node readiness, kubelet, capacity, pressure |
+| `restart_deployment` | **write** | Rollout-restart (allowlisted namespaces) |
+| `scale_deployment` | **write** | Scale to N replicas (0..max, allowlisted) |
+| `delete_pod` | **write** | Delete a pod; its controller recreates it (allowlisted) |
+| `server_info` | read | Effective config (context, read-only, allowlist) |
+
+## Configuration
+
+| Variable | Default | Description |
+| --- | --- | --- |
+| `HOMELAB_MCP_CONTEXT` | current-context | kubeconfig context to use |
+| `HOMELAB_MCP_READONLY` | `0` | `1`/`true` disables all mutating tools |
+| `HOMELAB_MCP_MUTABLE_NAMESPACES` | `default,apps,monitoring,ci` | Namespaces mutations may touch; `*` = all |
+| `HOMELAB_MCP_MAX_REPLICAS` | `10` | Upper bound for `scale_deployment` |
+
+## Safety model
+
+1. **Read-only switch** — `HOMELAB_MCP_READONLY=1` rejects every mutating tool up front.
+2. **Namespace allowlist** — mutating tools refuse any namespace not in `HOMELAB_MCP_MUTABLE_NAMESPACES` (default a homelab-friendly set; `*` opts into all).
+3. **Bounded scale** — `scale_deployment` clamps to `0..HOMELAB_MCP_MAX_REPLICAS`.
+
+The cluster's own RBAC still applies on top — this server can only do what the kubeconfig identity is permitted to do.
+
+## Development
+
+```bash
+git clone https://github.com/Michael-WhiteCapData/WhiteCapData-Dev
+cd WhiteCapData-Dev
+uv pip install -e ".[dev]"
+ruff check .
+pytest          # no cluster required — APIs are faked/mocked
+```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## License
+
+[MIT](LICENSE) © Michael Tierney

whitecapdata_dev-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+homelab_mcp/__init__.py,sha256=nYcCY6IHWd9AiTvbYryXTPSH2ehII6m8X2Gwt_TNKmY,468
+homelab_mcp/config.py,sha256=f-h5nm7sn0T4--0jGcF6qjZukee4VDZDVsnNV_-40WA,2088
+homelab_mcp/format.py,sha256=dQuDyBHWKU-g6FrzCZ-JOKlAgL-UEI30zY7V7r4b-Ug,4662
+homelab_mcp/kube.py,sha256=KPNsGcMAJMu8xcw__6uNbdl_qzwY-RC3jY-u1XdCU_s,4925
+homelab_mcp/server.py,sha256=oX7DR5rln6Q5XaLLd-Eo9z3fDR4FcSGd8oZJWXXDwTg,3100
+whitecapdata_dev-0.1.0.dist-info/METADATA,sha256=Xg598St0ZJ93lsrx_pV3Azvnk1tQ_xOWWznC7ovwUDU,6117
+whitecapdata_dev-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+whitecapdata_dev-0.1.0.dist-info/entry_points.txt,sha256=3kAnizcfuUcuUaoK5_kPU9jF0I7lqEone9sO5Mabssc,61
+whitecapdata_dev-0.1.0.dist-info/licenses/LICENSE,sha256=CY7xjvDIH4rbWyhYFOZZaAfXsrsdo5apgxDnsY-xq8g,1072
+whitecapdata_dev-0.1.0.dist-info/RECORD,,

whitecapdata_dev-0.1.0.dist-info/WHEEL

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

whitecapdata_dev-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+whitecapdata-dev = homelab_mcp.server:main

whitecapdata_dev-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Michael Tierney
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.