map-mcp 0.1.0__tar.gz

map_mcp-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,27 @@
+name: release
+
+# Tag a release (e.g. `git tag v0.1.0 && git push --tags`) to build and publish to PyPI.
+# Publishing uses PyPI Trusted Publishing (OIDC) — no API token stored in the repo.
+# One-time setup on pypi.org: add a Trusted Publisher for project `map-mcp` with
+# owner `dkedar7`, repository `map-mcp`, workflow `release.yml`, environment `pypi`.
+
+on:
+  push:
+    tags: ["v*"]
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write  # required for Trusted Publishing (OIDC)
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+      - name: Run tests
+        run: uv run --with pytest pytest -q
+      - name: Build
+        run: uv build
+      - name: Publish to PyPI (Trusted Publishing)
+        run: uv publish

map_mcp-0.1.0/.github/workflows/test.yml

@@ -0,0 +1,22 @@
+name: test
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10", "3.11", "3.12"]
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Run tests
+        run: uv run --with pytest pytest -q

map_mcp-0.1.0/.gitignore

@@ -0,0 +1,9 @@
+__pycache__/
+*.pyc
+.pytest_cache/
+dist/
+build/
+*.egg-info/
+.venv/
+.uv/
+uv.lock

map_mcp-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kedar Dabhadkar
+
+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.

map_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,132 @@
+Metadata-Version: 2.4
+Name: map-mcp
+Version: 0.1.0
+Summary: Drive and perceive an existing live MapLibre GL map from an AI agent (MCP) or a human CLI — no test code, no browser automation.
+Project-URL: Homepage, https://github.com/dkedar7/map-mcp
+Project-URL: Source, https://github.com/dkedar7/map-mcp
+Project-URL: Bug Tracker, https://github.com/dkedar7/map-mcp/issues
+Author: Kedar Dabhadkar
+License: MIT License
+        
+        Copyright (c) 2026 Kedar Dabhadkar
+        
+        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.
+License-File: LICENSE
+Keywords: agent,geospatial,llm,map,maplibre,mcp,model-context-protocol
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: GIS
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Requires-Dist: fastmcp<4,>=3
+Requires-Dist: websockets>=12
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# map-mcp
+
+Drive and perceive an **existing, live MapLibre GL map** from an AI agent (over MCP) or a human
+CLI — query the rendered features, read the viewport, click and read popups, navigate, toggle
+layers. The agent and the CLI act on the **same map a person is looking at**, with parity by
+construction.
+
+It does **not** generate maps. Other geo-MCP servers (gis-mcp, Mapbox, CARTO) create maps or
+call GIS operations; map-mcp reaches into a map that's *already on screen*. Think of it as the
+agent-native counterpart to [MapGrab](https://github.com/maxlapides/mapgrab): same live-map
+access, but conversational over MCP instead of written as test code.
+
+> **Status:** v1, MapLibre GL only. Cooperation-required (your app adds a one-line hook). A
+> no-cooperation path and other map libraries are future work.
+
+## Install
+
+```
+uvx map-mcp --help          # or: pip install map-mcp
+```
+
+## Quickstart
+
+1. **Start the bridge + MCP server.** It prints a WebSocket URL and a per-session token.
+   ```
+   map-mcp serve
+   ```
+2. **Add the hook to your MapLibre page** (`map` is your existing `maplibregl.Map`):
+   ```html
+   <script src="map-mcp-hook.js"></script>
+   <script>
+     mapMcp.register(map, { url: "ws://127.0.0.1:8765", token: "PASTE_TOKEN" });
+   </script>
+   ```
+3. **Point your agent at the MCP server** (stdio by default; `--transport http` for HTTP/SSE).
+   Or drive it yourself from the terminal:
+   ```
+   map-mcp call get_viewport
+   map-mcp call query_rendered_features --params '{"point":[12.5,41.9]}'
+   ```
+
+There's a runnable example in [`examples/sample_app/`](examples/sample_app/).
+
+## Tools (the operation surface)
+
+The agent's MCP tools and the CLI's `call` operations are exactly the same set:
+
+| Operation | What it does |
+|---|---|
+| `get_viewport` | center `[lng,lat]`, zoom, bearing, pitch, bounds |
+| `query_rendered_features` | features currently rendered (optionally at a point or within a bbox) |
+| `get_features_at` | features rendered at a `[lng,lat]` point |
+| `click_at` | fire the map's click at a point (runs your popup handlers), return features + popup |
+| `read_popup` | text of any open popup(s) |
+| `set_view` | center+zoom (and bearing/pitch), or fit a bbox |
+| `list_layers` | the style's layers + visibility |
+| `set_layer_visibility` | show/hide a layer |
+| `screenshot` | a PNG data URL of the current map* |
+
+Perception returns **structured feature properties** (GeoJSON-shaped) — agents reason over
+properties, not pixels. `screenshot` is optional.
+
+\* needs the map created with `preserveDrawingBuffer: true` (see [`hook/snippet.md`](hook/snippet.md)).
+
+## How it works
+
+The hook connects *out* to a loopback WebSocket the `map-mcp` process runs. The MCP tools and
+the CLI are thin frontends over one shared core-operations layer, so any operation one can do,
+the other can too.
+
+**Security model (local-only).** The bridge binds `127.0.0.1` only, so nothing off your machine
+can reach it. Browsers do *not* apply same-origin policy to WebSocket connections, so the
+**per-session token is the security boundary**: only a page that presents it can drive your map.
+Treat the token like a secret — the convenience `?token=` pattern in the example leaks it via
+browser history and server logs, so for anything sensitive paste the token into the page rather
+than the URL. A hardened Origin allowlist is future work.
+
+## Scope (v1)
+
+- **In:** MapLibre GL; the operations above; stdio + HTTP/SSE; a human CLI with parity.
+- **Out:** generating maps; a hosted service; non-map visualizations; other map libraries
+  (Leaflet/deck.gl) and a no-cooperation (Playwright) path are future work.
+
+## License
+
+MIT

map_mcp-0.1.0/README.md

@@ -0,0 +1,86 @@
+# map-mcp
+
+Drive and perceive an **existing, live MapLibre GL map** from an AI agent (over MCP) or a human
+CLI — query the rendered features, read the viewport, click and read popups, navigate, toggle
+layers. The agent and the CLI act on the **same map a person is looking at**, with parity by
+construction.
+
+It does **not** generate maps. Other geo-MCP servers (gis-mcp, Mapbox, CARTO) create maps or
+call GIS operations; map-mcp reaches into a map that's *already on screen*. Think of it as the
+agent-native counterpart to [MapGrab](https://github.com/maxlapides/mapgrab): same live-map
+access, but conversational over MCP instead of written as test code.
+
+> **Status:** v1, MapLibre GL only. Cooperation-required (your app adds a one-line hook). A
+> no-cooperation path and other map libraries are future work.
+
+## Install
+
+```
+uvx map-mcp --help          # or: pip install map-mcp
+```
+
+## Quickstart
+
+1. **Start the bridge + MCP server.** It prints a WebSocket URL and a per-session token.
+   ```
+   map-mcp serve
+   ```
+2. **Add the hook to your MapLibre page** (`map` is your existing `maplibregl.Map`):
+   ```html
+   <script src="map-mcp-hook.js"></script>
+   <script>
+     mapMcp.register(map, { url: "ws://127.0.0.1:8765", token: "PASTE_TOKEN" });
+   </script>
+   ```
+3. **Point your agent at the MCP server** (stdio by default; `--transport http` for HTTP/SSE).
+   Or drive it yourself from the terminal:
+   ```
+   map-mcp call get_viewport
+   map-mcp call query_rendered_features --params '{"point":[12.5,41.9]}'
+   ```
+
+There's a runnable example in [`examples/sample_app/`](examples/sample_app/).
+
+## Tools (the operation surface)
+
+The agent's MCP tools and the CLI's `call` operations are exactly the same set:
+
+| Operation | What it does |
+|---|---|
+| `get_viewport` | center `[lng,lat]`, zoom, bearing, pitch, bounds |
+| `query_rendered_features` | features currently rendered (optionally at a point or within a bbox) |
+| `get_features_at` | features rendered at a `[lng,lat]` point |
+| `click_at` | fire the map's click at a point (runs your popup handlers), return features + popup |
+| `read_popup` | text of any open popup(s) |
+| `set_view` | center+zoom (and bearing/pitch), or fit a bbox |
+| `list_layers` | the style's layers + visibility |
+| `set_layer_visibility` | show/hide a layer |
+| `screenshot` | a PNG data URL of the current map* |
+
+Perception returns **structured feature properties** (GeoJSON-shaped) — agents reason over
+properties, not pixels. `screenshot` is optional.
+
+\* needs the map created with `preserveDrawingBuffer: true` (see [`hook/snippet.md`](hook/snippet.md)).
+
+## How it works
+
+The hook connects *out* to a loopback WebSocket the `map-mcp` process runs. The MCP tools and
+the CLI are thin frontends over one shared core-operations layer, so any operation one can do,
+the other can too.
+
+**Security model (local-only).** The bridge binds `127.0.0.1` only, so nothing off your machine
+can reach it. Browsers do *not* apply same-origin policy to WebSocket connections, so the
+**per-session token is the security boundary**: only a page that presents it can drive your map.
+Treat the token like a secret — the convenience `?token=` pattern in the example leaks it via
+browser history and server logs, so for anything sensitive paste the token into the page rather
+than the URL. A hardened Origin allowlist is future work.
+
+## Scope (v1)
+
+- **In:** MapLibre GL; the operations above; stdio + HTTP/SSE; a human CLI with parity.
+- **Out:** generating maps; a hosted service; non-map visualizations; other map libraries
+  (Leaflet/deck.gl) and a no-cooperation (Playwright) path are future work.
+
+## License
+
+MIT

map_mcp-0.1.0/examples/sample_app/index.html

@@ -0,0 +1,64 @@
+<!DOCTYPE html>
+<!--
+  map-mcp sample app — a minimal hooked MapLibre GL map for the first validated scenario.
+
+  Run:
+    1) map-mcp serve            # prints ws url + token
+    2) serve this folder:  python -m http.server 8080
+    3) open http://localhost:8080/?token=PASTE_TOKEN
+       (the page reads ?token= and registers the live map with the bridge)
+
+  It shows a basemap + a points layer with clickable popups, created with
+  preserveDrawingBuffer:true so the screenshot tool works.
+-->
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title>map-mcp sample</title>
+    <script src="https://unpkg.com/maplibre-gl@4/dist/maplibre-gl.js"></script>
+    <link href="https://unpkg.com/maplibre-gl@4/dist/maplibre-gl.css" rel="stylesheet" />
+    <script src="../../hook/map-mcp-hook.js"></script>
+    <style>html, body, #map { height: 100%; margin: 0; }</style>
+  </head>
+  <body>
+    <div id="map"></div>
+    <script>
+      const map = new maplibregl.Map({
+        container: "map",
+        style: "https://demotiles.maplibre.org/style.json",
+        center: [12.5, 41.9],
+        zoom: 4,
+        preserveDrawingBuffer: true, // required for the screenshot tool
+      });
+
+      const cities = {
+        type: "FeatureCollection",
+        features: [
+          { type: "Feature", properties: { name: "Rome", pop: 2800000 },
+            geometry: { type: "Point", coordinates: [12.5, 41.9] } },
+          { type: "Feature", properties: { name: "Berlin", pop: 3600000 },
+            geometry: { type: "Point", coordinates: [13.4, 52.5] } },
+        ],
+      };
+
+      map.on("load", () => {
+        map.addSource("cities", { type: "geojson", data: cities });
+        map.addLayer({
+          id: "cities", type: "circle", source: "cities",
+          paint: { "circle-radius": 7, "circle-color": "#c33" },
+        });
+        map.on("click", "cities", (e) => {
+          const f = e.features[0];
+          new maplibregl.Popup()
+            .setLngLat(f.geometry.coordinates)
+            .setHTML(`<b>${f.properties.name}</b><br/>pop ${f.properties.pop}`)
+            .addTo(map);
+        });
+
+        // Register the live map with the bridge (token from ?token=).
+        const token = new URLSearchParams(location.search).get("token") || "";
+        mapMcp.register(map, { url: "ws://127.0.0.1:8765", token });
+      });
+    </script>
+  </body>
+</html>

map_mcp-0.1.0/hook/map-mcp-hook.js

@@ -0,0 +1,176 @@
+/*
+ * map-mcp hook — expose a live MapLibre GL map to the local map-mcp bridge.
+ *
+ * Add this file to your page and register your map:
+ *
+ *   <script src="map-mcp-hook.js"></script>
+ *   <script>
+ *     mapMcp.register(map, { url: "ws://127.0.0.1:8765", token: "PASTE_TOKEN" });
+ *   </script>
+ *
+ * The hook connects out to the bridge, presents the token (see snippet.md), and answers
+ * requests by calling the map's own JS API. Vanilla JS, no build step. Drives an EXISTING
+ * map — it never creates one. An unknown method returns an error reply; the hook never throws
+ * across the socket.
+ *
+ * Note: `screenshot` needs the map created with `preserveDrawingBuffer: true`, or a WebGL
+ * canvas reads back blank. See snippet.md.
+ */
+(function (global) {
+  "use strict";
+
+  // --- method -> MapLibre operation ----------------------------------------
+  var HANDLERS = {
+    get_viewport: function (map) {
+      var c = map.getCenter();
+      var b = map.getBounds();
+      return {
+        center: [c.lng, c.lat],
+        zoom: map.getZoom(),
+        bearing: map.getBearing(),
+        pitch: map.getPitch(),
+        bounds: b ? b.toArray() : null, // [[swLng,swLat],[neLng,neLat]]
+      };
+    },
+
+    query_rendered_features: function (map, p) {
+      p = p || {};
+      var geom = _geometry(map, p); // undefined => whole viewport
+      var opts = p.layers ? { layers: p.layers } : undefined;
+      var feats = map.queryRenderedFeatures(geom, opts) || [];
+      var limit = p.limit || 200;
+      return { features: feats.slice(0, limit).map(_serializeFeature), truncated: feats.length > limit };
+    },
+
+    get_features_at: function (map, p) {
+      var pt = map.project(_lngLat(p)); // geographic -> pixel
+      var feats = map.queryRenderedFeatures(pt, p.layers ? { layers: p.layers } : undefined) || [];
+      return { features: feats.map(_serializeFeature) };
+    },
+
+    click_at: function (map, p) {
+      var lngLat = _lngLat(p);
+      var pt = map.project(lngLat);
+      // fire the map's own click so app handlers (popups, selection) run
+      map.fire("click", { lngLat: lngLat, point: pt, originalEvent: {} });
+      var feats = map.queryRenderedFeatures(pt, p.layers ? { layers: p.layers } : undefined) || [];
+      return { features: feats.map(_serializeFeature), popup: _readPopup() };
+    },
+
+    read_popup: function () {
+      return { popups: _readPopup() };
+    },
+
+    set_view: function (map, p) {
+      p = p || {};
+      if (p.bbox) {
+        map.fitBounds(p.bbox, { animate: false });
+      } else {
+        var to = {};
+        if (p.center) to.center = p.center;
+        if (p.zoom != null) to.zoom = p.zoom;
+        if (p.bearing != null) to.bearing = p.bearing;
+        if (p.pitch != null) to.pitch = p.pitch;
+        map.jumpTo(to);
+      }
+      return HANDLERS.get_viewport(map);
+    },
+
+    list_layers: function (map) {
+      var layers = (map.getStyle() && map.getStyle().layers) || [];
+      return {
+        layers: layers.map(function (l) {
+          var vis;
+          try { vis = map.getLayoutProperty(l.id, "visibility"); } catch (e) { vis = undefined; }
+          return { id: l.id, type: l.type, source: l.source, visibility: vis || "visible" };
+        }),
+      };
+    },
+
+    set_layer_visibility: function (map, p) {
+      var vis = p.visible ? "visible" : "none";
+      map.setLayoutProperty(p.layer, "visibility", vis);
+      return { layer: p.layer, visibility: vis };
+    },
+
+    screenshot: function (map) {
+      var canvas = map.getCanvas();
+      var data;
+      try { data = canvas.toDataURL("image/png"); } catch (e) { data = null; }
+      if (!data || data.length < 64) {
+        throw new Error("screenshot unavailable — create the map with preserveDrawingBuffer:true");
+      }
+      return { image: data, width: canvas.width, height: canvas.height };
+    },
+  };
+
+  // --- helpers --------------------------------------------------------------
+  function _lngLat(p) {
+    if (!p || !p.point) throw new Error("expected params.point as [lng, lat]");
+    return { lng: p.point[0], lat: p.point[1] };
+  }
+
+  function _geometry(map, p) {
+    if (p.point) return map.project(_lngLat(p));
+    if (p.bbox) {
+      var sw = map.project({ lng: p.bbox[0][0], lat: p.bbox[0][1] });
+      var ne = map.project({ lng: p.bbox[1][0], lat: p.bbox[1][1] });
+      return [sw, ne];
+    }
+    return undefined;
+  }
+
+  function _serializeFeature(f) {
+    return {
+      id: f.id != null ? f.id : null,
+      layer: f.layer ? f.layer.id : null,
+      source: f.source != null ? f.source : null,
+      sourceLayer: f.sourceLayer != null ? f.sourceLayer : null,
+      properties: f.properties || {},
+      geometryType: f.geometry ? f.geometry.type : null,
+    };
+  }
+
+  function _readPopup() {
+    var nodes = document.querySelectorAll(".maplibregl-popup-content, .mapboxgl-popup-content");
+    return Array.prototype.map.call(nodes, function (n) {
+      return (n.textContent || "").trim();
+    });
+  }
+
+  // --- transport ------------------------------------------------------------
+  function register(map, opts) {
+    opts = opts || {};
+    var url = opts.url || "ws://127.0.0.1:8765";
+    var ws = new WebSocket(url);
+
+    ws.onopen = function () {
+      // U6: present the per-session token before commands are accepted.
+      if (opts.token) ws.send(JSON.stringify({ type: "hello", token: opts.token }));
+    };
+
+    ws.onmessage = function (ev) {
+      var req;
+      try { req = JSON.parse(ev.data); } catch (e) { return; }
+      if (!req || req.id == null) return;
+      var reply = { id: req.id, ok: true, result: null };
+      try {
+        var handler = HANDLERS[req.method];
+        if (!handler) {
+          reply.ok = false;
+          reply.error = "unknown method: " + req.method;
+        } else {
+          reply.result = handler(map, req.params || {});
+        }
+      } catch (e) {
+        reply.ok = false;
+        reply.error = String(e && e.message ? e.message : e);
+      }
+      ws.send(JSON.stringify(reply));
+    };
+
+    return ws;
+  }
+
+  global.mapMcp = { register: register, _handlers: HANDLERS };
+})(typeof window !== "undefined" ? window : this);

map_mcp-0.1.0/hook/snippet.md

@@ -0,0 +1,37 @@
+# Adding the map-mcp hook to your MapLibre app
+
+map-mcp drives an **existing** map — you add one snippet so it can reach your live map
+instance. Cooperation is required (v1); a no-cooperation path is deferred.
+
+## 1. Start the bridge
+
+```
+map-mcp serve
+```
+
+It prints a `ws://127.0.0.1:<port>` URL and a **per-session token** (the token gate is
+local-only security — only a page presenting it can drive your map).
+
+## 2. Add the hook to your page
+
+```html
+<script src="map-mcp-hook.js"></script>
+<script>
+  // `map` is your existing maplibregl.Map instance.
+  mapMcp.register(map, { url: "ws://127.0.0.1:8765", token: "PASTE_TOKEN_FROM_SERVE" });
+</script>
+```
+
+That's it. The agent (over MCP) and the `map-mcp` CLI now act on the same map you're looking at.
+
+## Notes
+
+- **Screenshots** need the map created with `preserveDrawingBuffer: true`:
+  ```js
+  const map = new maplibregl.Map({ /* ... */, preserveDrawingBuffer: true });
+  ```
+  Without it, a WebGL canvas reads back blank and the `screenshot` tool returns an error.
+- Geographic inputs (`point`, `bbox`, `center`) are `[lng, lat]`. The hook projects them to
+  pixels for `queryRenderedFeatures` itself.
+- The hook never creates a map and never posts anywhere — it answers read/drive requests on the
+  loopback socket only.

map_mcp-0.1.0/pyproject.toml

@@ -0,0 +1,45 @@
+[project]
+name = "map-mcp"
+version = "0.1.0"
+description = "Drive and perceive an existing live MapLibre GL map from an AI agent (MCP) or a human CLI — no test code, no browser automation."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { file = "LICENSE" }
+authors = [{ name = "Kedar Dabhadkar" }]
+keywords = ["maplibre", "map", "mcp", "model-context-protocol", "agent", "llm", "geospatial"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: GIS",
+    "Topic :: Software Development :: Libraries",
+]
+dependencies = [
+    "fastmcp>=3,<4",
+    "websockets>=12",
+]
+
+[project.urls]
+Homepage = "https://github.com/dkedar7/map-mcp"
+Source = "https://github.com/dkedar7/map-mcp"
+"Bug Tracker" = "https://github.com/dkedar7/map-mcp/issues"
+
+[project.scripts]
+map-mcp = "map_mcp.cli:_cli"
+
+[project.optional-dependencies]
+dev = ["pytest>=7"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/map_mcp"]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+testpaths = ["tests"]

map_mcp-0.1.0/src/map_mcp/__init__.py

@@ -0,0 +1,10 @@
+"""map-mcp — drive and perceive an existing live MapLibre GL map from an agent or a human CLI.
+
+A map app opts in with a small JS hook that registers its live map and connects out to a
+local WebSocket this process runs. The MCP tools (for agents) and the CLI (for humans) are
+thin frontends over one shared core-operations layer, so any operation one can do, the other
+can too (parity by construction). v1 is MapLibre-only and drives *existing* maps — it does not
+generate maps.
+"""
+
+__version__ = "0.1.0"