@kepler.gl/mcp 0.0.0-stage → 3.3.0-alpha.20

package/dist/esm/commands/view-mode-command.js

@@ -0,0 +1,86 @@
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import { z } from 'zod';
+import { MapViewMode } from '@kepler.gl/constants';
+import { setMapViewMode } from '@kepler.gl/actions';
+export var viewModeCommandId = 'map.set-view-mode';
+
+/** Agent-facing names for the three camera modes. */
+var VIEW_MODE_BY_INPUT = {
+  '2d': MapViewMode.MODE_2D,
+  '3d': MapViewMode.MODE_3D,
+  globe: MapViewMode.MODE_GLOBE
+};
+
+/**
+ * Accept the short names (`2d`, `3d`, `globe`) as well as the enum values
+ * (`MODE_2D`, …) — the bridge and WebMCP callers reach execute without zod
+ * parsing, so the runtime guard must understand both.
+ */
+function resolveViewMode(input) {
+  if (typeof input !== 'string') return null;
+  var _short = input.toLowerCase();
+  if (VIEW_MODE_BY_INPUT[_short]) return VIEW_MODE_BY_INPUT[_short];
+  return Object.values(MapViewMode).includes(input) ? input : null;
+}
+export function getViewModeCommand(ctx) {
+  return {
+    id: viewModeCommandId,
+    name: 'Set map view mode',
+    group: 'Map',
+    description: "Switch the map between the flat 2D map, the tilted 3D map and the 3D globe.\n- '2d': flat map, no tilt.\n- '3d': flat map tilted (pitch 50), for extruded/3D layers.\n- 'globe': the 3D globe \u2014 use it when the data spans the world and the user is looking at global patterns.\nGlobe support: point, arc, line, trip, cluster, hexagon, grid, geojson and vector-tile layers render on the globe. The 'flow' and 'flowField' layers are NOT supported there yet (flow arrows collapse edge-on; flow field clipping is mercator-only), so keep those on the 2d/3d map.",
+    metadata: {
+      readOnly: false,
+      riskLevel: 'low',
+      idempotent: true
+    },
+    inputSchema: z.object({
+      mode: z["enum"](['2d', '3d', 'globe'])
+    }),
+    execute: function () {
+      var _execute = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(_execCtx, input) {
+        var _ref, mode, viewMode, label;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _ref = input !== null && input !== void 0 ? input : {}, mode = _ref.mode;
+              viewMode = resolveViewMode(mode);
+              if (viewMode) {
+                _context.next = 4;
+                break;
+              }
+              return _context.abrupt("return", {
+                success: false,
+                commandId: viewModeCommandId,
+                error: "Invalid view mode: ".concat(String(mode), ". Use \"2d\", \"3d\" or \"globe\"."),
+                data: {
+                  instruction: 'Call map.set-view-mode with mode "2d", "3d" or "globe".'
+                }
+              });
+            case 4:
+              ctx.dispatch(setMapViewMode(viewMode));
+              label = viewMode === MapViewMode.MODE_GLOBE ? '3D globe' : viewMode === MapViewMode.MODE_3D ? '3D tilted map' : '2D flat map';
+              return _context.abrupt("return", {
+                success: true,
+                commandId: viewModeCommandId,
+                data: {
+                  details: "Map view switched to ".concat(label, ".")
+                }
+              });
+            case 7:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee);
+      }));
+      function execute(_x, _x2) {
+        return _execute.apply(this, arguments);
+      }
+      return execute;
+    }()
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/index.js

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+/**
+ * @kepler.gl/mcp — the kepler.gl map surface.
+ *
+ * Only the map contract + the map.* commands live here, plus dependency-light
+ * helper utilities (e.g. `commands/utils.ts`) that hosts are meant to reuse.
+ * No analysis and no app-specific wiring glue — those belong to
+ * kepler-assistant, which imports this package for the commands and implements
+ * the `KeplerContext` glue seam.
+ *
+ * This root entry stays browser-safe. The stdio MCP server (which needs `ws`
+ * and Node APIs) lives in the `./server` subpath and is never imported here.
+ */
+
+export * from './map-contract';
+export * from './types';
+export * from './commands';
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vc3JjL2luZGV4LnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBNSVRcbi8vIENvcHlyaWdodCBjb250cmlidXRvcnMgdG8gdGhlIGtlcGxlci5nbCBwcm9qZWN0XG5cbi8qKlxuICogQGtlcGxlci5nbC9tY3Ag4oCUIHRoZSBrZXBsZXIuZ2wgbWFwIHN1cmZhY2UuXG4gKlxuICogT25seSB0aGUgbWFwIGNvbnRyYWN0ICsgdGhlIG1hcC4qIGNvbW1hbmRzIGxpdmUgaGVyZSwgcGx1cyBkZXBlbmRlbmN5LWxpZ2h0XG4gKiBoZWxwZXIgdXRpbGl0aWVzIChlLmcuIGBjb21tYW5kcy91dGlscy50c2ApIHRoYXQgaG9zdHMgYXJlIG1lYW50IHRvIHJldXNlLlxuICogTm8gYW5hbHlzaXMgYW5kIG5vIGFwcC1zcGVjaWZpYyB3aXJpbmcgZ2x1ZSDigJQgdGhvc2UgYmVsb25nIHRvXG4gKiBrZXBsZXItYXNzaXN0YW50LCB3aGljaCBpbXBvcnRzIHRoaXMgcGFja2FnZSBmb3IgdGhlIGNvbW1hbmRzIGFuZCBpbXBsZW1lbnRzXG4gKiB0aGUgYEtlcGxlckNvbnRleHRgIGdsdWUgc2VhbS5cbiAqXG4gKiBUaGlzIHJvb3QgZW50cnkgc3RheXMgYnJvd3Nlci1zYWZlLiBUaGUgc3RkaW8gTUNQIHNlcnZlciAod2hpY2ggbmVlZHMgYHdzYFxuICogYW5kIE5vZGUgQVBJcykgbGl2ZXMgaW4gdGhlIGAuL3NlcnZlcmAgc3VicGF0aCBhbmQgaXMgbmV2ZXIgaW1wb3J0ZWQgaGVyZS5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL21hcC1jb250cmFjdCc7XG5leHBvcnQgKiBmcm9tICcuL3R5cGVzJztcbmV4cG9ydCAqIGZyb20gJy4vY29tbWFuZHMnO1xuIl0sIm1hcHBpbmdzIjoiQUFBQTtBQUNBOztBQUVBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTs7QUFFQSxjQUFjLGdCQUFnQjtBQUM5QixjQUFjLFNBQVM7QUFDdkIsY0FBYyxZQUFZIiwiaWdub3JlTGlzdCI6W119

package/dist/esm/map-contract.js

@@ -0,0 +1,3 @@
+export {};
+export {};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/server/bridge-server.js

@@ -0,0 +1,428 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+/**
+ * The bridge between an MCP client and a kepler.gl page.
+ *
+ * Browsers cannot listen on a port, so the page is a WebSocket CLIENT that
+ * connects OUT to `ws://127.0.0.1:<port>/ws?token=...` (the reverse-connect
+ * pattern). This server holds that socket, advertises the `map.*` tools to the
+ * MCP client, and forwards each call to the page, where the command registry
+ * executes against the live map.
+ *
+ * The tool list comes from the package itself (`getKeplerCommands`), so tools
+ * exist before a page connects; a call without a page returns a clear error.
+ * Once a page says `hello` its own catalog replaces the static one, because a
+ * page may not serve every command (the demo app omits the DuckDB-backed ones).
+ */
+
+import { randomUUID } from 'node:crypto';
+import { createServer } from 'node:http';
+import { WebSocket, WebSocketServer } from 'ws';
+import { z } from 'zod';
+import { getKeplerCommands } from '../commands';
+var DEFAULT_PORT = 8765;
+var DEFAULT_HOST = '127.0.0.1';
+var DEFAULT_CALL_TIMEOUT_MS = 60000;
+/** MCP tool names are commonly restricted to [A-Za-z0-9_-]; `map.add-layer` → `map_add_layer`. */
+export function toToolName(commandId) {
+  return commandId.replace(/\./g, '_');
+}
+function toInputSchema(command) {
+  if (command.inputSchema) {
+    try {
+      var schema = z.toJSONSchema(command.inputSchema);
+      if (schema) return schema;
+    } catch (_unused) {
+      // Not every command ships a zod schema; fall back to a free-form object.
+    }
+  }
+  return {
+    type: 'object'
+  };
+}
+
+/** The map surface as declared by this package, independent of any page. */
+export function getMapTools() {
+  var commands = getKeplerCommands({});
+  return Object.values(commands).map(function (command) {
+    return {
+      name: toToolName(command.id),
+      commandId: command.id,
+      description: command.description || command.name,
+      inputSchema: toInputSchema(command)
+    };
+  });
+}
+function toolsFromDescriptors(descriptors) {
+  return descriptors.filter(function (descriptor) {
+    return descriptor && descriptor.id;
+  }).map(function (descriptor) {
+    return {
+      name: toToolName(descriptor.id),
+      commandId: descriptor.id,
+      description: descriptor.description || descriptor.name || descriptor.id,
+      inputSchema: descriptor.inputSchema || {
+        type: 'object'
+      }
+    };
+  });
+}
+
+/** RoomCommandResult → the text an MCP client shows for a tool call. */
+export function formatResult(result) {
+  var _ref, _result$data;
+  if (result && _typeof(result) === 'object' && result.success === false) {
+    var _result$error;
+    return {
+      text: "\u2717 ".concat(result.commandId, ": ").concat((_result$error = result.error) !== null && _result$error !== void 0 ? _result$error : 'failed'),
+      isError: true
+    };
+  }
+  if (result && _typeof(result) === 'object' && result.error) {
+    return {
+      text: "\u2717 ".concat(result.commandId, ": ").concat(result.error),
+      isError: true
+    };
+  }
+  var data = result === null || result === void 0 ? void 0 : result.data;
+  if (data && typeof data.details === 'string') return {
+    text: data.details,
+    isError: false
+  };
+  return {
+    text: JSON.stringify((_ref = (_result$data = result === null || result === void 0 ? void 0 : result.data) !== null && _result$data !== void 0 ? _result$data : result) !== null && _ref !== void 0 ? _ref : null, null, 2),
+    isError: false
+  };
+}
+export var KeplerMcpBridge = /*#__PURE__*/function () {
+  function KeplerMcpBridge() {
+    var _options$port, _options$host, _options$mapUrl, _options$callTimeoutM;
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    _classCallCheck(this, KeplerMcpBridge);
+    _defineProperty(this, "options", void 0);
+    _defineProperty(this, "staticTools", void 0);
+    _defineProperty(this, "pageTools", null);
+    _defineProperty(this, "socket", null);
+    _defineProperty(this, "wss", null);
+    _defineProperty(this, "httpServer", null);
+    _defineProperty(this, "pending", new Map());
+    _defineProperty(this, "token", '');
+    _defineProperty(this, "pageUrl", '');
+    this.options = {
+      port: (_options$port = options.port) !== null && _options$port !== void 0 ? _options$port : DEFAULT_PORT,
+      host: (_options$host = options.host) !== null && _options$host !== void 0 ? _options$host : DEFAULT_HOST,
+      mapUrl: (_options$mapUrl = options.mapUrl) !== null && _options$mapUrl !== void 0 ? _options$mapUrl : 'http://localhost:8080',
+      callTimeoutMs: (_options$callTimeoutM = options.callTimeoutMs) !== null && _options$callTimeoutM !== void 0 ? _options$callTimeoutM : DEFAULT_CALL_TIMEOUT_MS
+    };
+    this.staticTools = getMapTools();
+  }
+
+  /** Tools the MCP client can call right now. */
+  return _createClass(KeplerMcpBridge, [{
+    key: "getTools",
+    value: function getTools() {
+      var _this$pageTools;
+      return (_this$pageTools = this.pageTools) !== null && _this$pageTools !== void 0 ? _this$pageTools : this.staticTools;
+    }
+  }, {
+    key: "connected",
+    get: function get() {
+      var _this$socket;
+      return ((_this$socket = this.socket) === null || _this$socket === void 0 ? void 0 : _this$socket.readyState) === WebSocket.OPEN;
+    }
+  }, {
+    key: "start",
+    value: function () {
+      var _start = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+        var _this = this;
+        var httpServer, wss, address, port, mapUrl;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              if (!this.wss) {
+                _context.next = 2;
+                break;
+              }
+              throw new Error('The kepler.gl bridge is already running.');
+            case 2:
+              this.token = randomUUID().replace(/-/g, '');
+
+              // A plain HTTP GET on `/` redirects to the map page carrying the token, so
+              // the user can open `http://127.0.0.1:<port>/` even when the MCP client
+              // never shows the server's stderr. Only `/ws` upgrades to a WebSocket.
+              httpServer = createServer(function (request, response) {
+                var _request$url;
+                if (request.url === '/' || (_request$url = request.url) !== null && _request$url !== void 0 && _request$url.startsWith('/?')) {
+                  response.writeHead(302, {
+                    Location: _this.pageUrl
+                  });
+                  response.end();
+                  return;
+                }
+                response.writeHead(404, {
+                  'content-type': 'text/plain'
+                });
+                response.end('kepler-mcp: the map page connects at /ws');
+              });
+              this.httpServer = httpServer;
+              wss = new WebSocketServer({
+                server: httpServer,
+                path: '/ws'
+              });
+              this.wss = wss;
+              wss.on('connection', function (socket, request) {
+                return _this.handleConnection(socket, request.url);
+              });
+              _context.next = 10;
+              return new Promise(function (resolve, reject) {
+                httpServer.once('error', reject);
+                httpServer.listen(_this.options.port, _this.options.host, function () {
+                  return resolve();
+                });
+              });
+            case 10:
+              address = httpServer.address();
+              port = _typeof(address) === 'object' && address ? address.port : this.options.port;
+              mapUrl = this.options.mapUrl.replace(/\/$/, '');
+              this.pageUrl = "".concat(mapUrl).concat(mapUrl.includes('?') ? '&' : '?', "mcp=").concat(encodeURIComponent(this.token));
+              return _context.abrupt("return", {
+                host: this.options.host,
+                port: port,
+                token: this.token,
+                pageUrl: this.pageUrl
+              });
+            case 15:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function start() {
+        return _start.apply(this, arguments);
+      }
+      return start;
+    }()
+  }, {
+    key: "callTool",
+    value: function () {
+      var _callTool = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2(name) {
+        var _this$getTools$find,
+          _this2 = this;
+        var input,
+          tool,
+          socket,
+          callId,
+          reply,
+          _args2 = arguments;
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              input = _args2.length > 1 && _args2[1] !== undefined ? _args2[1] : {};
+              tool = (_this$getTools$find = this.getTools().find(function (candidate) {
+                return candidate.name === name;
+              })) !== null && _this$getTools$find !== void 0 ? _this$getTools$find : this.staticTools.find(function (candidate) {
+                return candidate.name === name;
+              });
+              if (tool) {
+                _context2.next = 4;
+                break;
+              }
+              throw new Error("Unknown map tool \"".concat(name, "\". Available: ").concat(this.getTools().map(function (candidate) {
+                return candidate.name;
+              }).join(', '), "."));
+            case 4:
+              socket = this.socket;
+              if (!(!socket || socket.readyState !== WebSocket.OPEN)) {
+                _context2.next = 7;
+                break;
+              }
+              throw new Error('No kepler.gl map page is connected. Open the page URL printed at startup ' + '(it carries ?mcp=<token>), then call the tool again.');
+            case 7:
+              callId = randomUUID();
+              reply = new Promise(function (resolve, reject) {
+                var timer = setTimeout(function () {
+                  _this2.pending["delete"](callId);
+                  reject(new Error("Timed out after ".concat(_this2.options.callTimeoutMs, " ms waiting for the map page.")));
+                }, _this2.options.callTimeoutMs);
+                _this2.pending.set(callId, {
+                  resolve: resolve,
+                  reject: reject,
+                  timer: timer
+                });
+              });
+              socket.send(JSON.stringify({
+                type: 'call',
+                callId: callId,
+                tool: tool.commandId,
+                input: input
+              }));
+              return _context2.abrupt("return", reply);
+            case 11:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function callTool(_x) {
+        return _callTool.apply(this, arguments);
+      }
+      return callTool;
+    }()
+  }, {
+    key: "close",
+    value: function () {
+      var _close = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+        var _this$socket2;
+        var wss, httpServer, _iterator, _step, client;
+        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              this.rejectPending('The bridge was closed.');
+              this.pageTools = null;
+              (_this$socket2 = this.socket) === null || _this$socket2 === void 0 || _this$socket2.close(1000, 'bridge closed');
+              this.socket = null;
+              wss = this.wss;
+              httpServer = this.httpServer;
+              this.wss = null;
+              this.httpServer = null;
+              if (wss) {
+                _context3.next = 10;
+                break;
+              }
+              return _context3.abrupt("return");
+            case 10:
+              // close() only stops listening and waits for clients; terminate them so
+              // shutdown (and tests) do not hang on a page that never closes its socket.
+              _iterator = _createForOfIteratorHelper(wss.clients);
+              try {
+                for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                  client = _step.value;
+                  client.terminate();
+                }
+              } catch (err) {
+                _iterator.e(err);
+              } finally {
+                _iterator.f();
+              }
+              _context3.next = 14;
+              return new Promise(function (resolve) {
+                return wss.close(function () {
+                  return resolve();
+                });
+              });
+            case 14:
+              if (!httpServer) {
+                _context3.next = 17;
+                break;
+              }
+              _context3.next = 17;
+              return new Promise(function (resolve) {
+                return httpServer.close(function () {
+                  return resolve();
+                });
+              });
+            case 17:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this);
+      }));
+      function close() {
+        return _close.apply(this, arguments);
+      }
+      return close;
+    }()
+  }, {
+    key: "handleConnection",
+    value: function handleConnection(socket, requestUrl) {
+      var _this$socket3,
+        _this3 = this;
+      var token = null;
+      try {
+        token = new URL(requestUrl !== null && requestUrl !== void 0 ? requestUrl : '/ws', 'http://127.0.0.1').searchParams.get('token');
+      } catch (_unused2) {
+        token = null;
+      }
+      // The token is the only thing keeping other local pages/processes from
+      // driving the map; reject a mismatch before accepting any message.
+      if (token !== this.token) {
+        socket.close(1008, 'invalid token');
+        return;
+      }
+
+      // One map page at a time: a second tab takes over so calls never race
+      // between two live maps.
+      (_this$socket3 = this.socket) === null || _this$socket3 === void 0 || _this$socket3.close(1000, 'replaced by a newer connection');
+      this.socket = socket;
+      this.pageTools = null;
+      socket.on('message', function (data) {
+        return _this3.handleMessage(data);
+      });
+      socket.on('close', function () {
+        if (_this3.socket === socket) {
+          _this3.socket = null;
+          _this3.pageTools = null;
+          _this3.rejectPending('The kepler.gl page disconnected.');
+        }
+      });
+      // Errors are followed by close; the close handler resets state.
+      socket.on('error', function () {
+        return undefined;
+      });
+    }
+  }, {
+    key: "handleMessage",
+    value: function handleMessage(raw) {
+      var _message, _message2;
+      var message;
+      try {
+        message = JSON.parse(String(raw));
+      } catch (_unused3) {
+        return;
+      }
+      if (((_message = message) === null || _message === void 0 ? void 0 : _message.type) === 'hello' && Array.isArray(message.commands)) {
+        this.pageTools = toolsFromDescriptors(message.commands);
+        return;
+      }
+      if (((_message2 = message) === null || _message2 === void 0 ? void 0 : _message2.type) === 'result' && typeof message.callId === 'string') {
+        var pendingCall = this.pending.get(message.callId);
+        if (!pendingCall) return;
+        clearTimeout(pendingCall.timer);
+        this.pending["delete"](message.callId);
+        pendingCall.resolve(message.result);
+      }
+    }
+  }, {
+    key: "rejectPending",
+    value: function rejectPending(reason) {
+      var _iterator2 = _createForOfIteratorHelper(this.pending),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var _step2$value = _slicedToArray(_step2.value, 2),
+            callId = _step2$value[0],
+            pendingCall = _step2$value[1];
+          clearTimeout(pendingCall.timer);
+          this.pending["delete"](callId);
+          pendingCall.reject(new Error(reason));
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+    }
+  }]);
+}();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["randomUUID","createServer","WebSocket","WebSocketServer","z","getKeplerCommands","DEFAULT_PORT","DEFAULT_HOST","DEFAULT_CALL_TIMEOUT_MS","toToolName","commandId","replace","toInputSchema","command","inputSchema","schema","toJSONSchema","_unused","type","getMapTools","commands","Object","values","map","name","id","description","toolsFromDescriptors","descriptors","filter","descriptor","formatResult","result","_ref","_result$data","_typeof","success","_result$error","text","concat","error","isError","data","details","JSON","stringify","KeplerMcpBridge","_options$port","_options$host","_options$mapUrl","_options$callTimeoutM","options","arguments","length","undefined","_classCallCheck","_defineProperty","Map","port","host","mapUrl","callTimeoutMs","staticTools","_createClass","key","value","getTools","_this$pageTools","pageTools","get","_this$socket","socket","readyState","OPEN","_start","_asyncToGenerator","_regeneratorRuntime","mark","_callee","_this","httpServer","wss","address","wrap","_callee$","_context","prev","next","Error","token","request","response","_request$url","url","startsWith","writeHead","Location","pageUrl","end","server","path","on","handleConnection","Promise","resolve","reject","once","listen","includes","encodeURIComponent","abrupt","stop","start","apply","_callTool","_callee2","_this$getTools$find","_this2","input","tool","callId","reply","_args2","_callee2$","_context2","find","candidate","join","timer","setTimeout","pending","set","send","callTool","_x","_close","_callee3","_this$socket2","_iterator","_step","client","_callee3$","_context3","rejectPending","close","_createForOfIteratorHelper","clients","s","n","done","terminate","err","e","f","requestUrl","_this$socket3","_this3","URL","searchParams","_unused2","handleMessage","raw","_message","_message2","message","parse","String","_unused3","Array","isArray","pendingCall","clearTimeout","reason","_iterator2","_step2","_step2$value","_slicedToArray"],"sources":["../../../src/server/bridge-server.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\n/**\n * The bridge between an MCP client and a kepler.gl page.\n *\n * Browsers cannot listen on a port, so the page is a WebSocket CLIENT that\n * connects OUT to `ws://127.0.0.1:<port>/ws?token=...` (the reverse-connect\n * pattern). This server holds that socket, advertises the `map.*` tools to the\n * MCP client, and forwards each call to the page, where the command registry\n * executes against the live map.\n *\n * The tool list comes from the package itself (`getKeplerCommands`), so tools\n * exist before a page connects; a call without a page returns a clear error.\n * Once a page says `hello` its own catalog replaces the static one, because a\n * page may not serve every command (the demo app omits the DuckDB-backed ones).\n */\n\nimport {randomUUID} from 'node:crypto';\nimport {createServer} from 'node:http';\nimport type {Server as HttpServer} from 'node:http';\nimport {WebSocket, WebSocketServer} from 'ws';\nimport {z} from 'zod';\nimport {getKeplerCommands} from '../commands';\nimport type {KeplerContext, RoomCommandResult, ToolDescriptor} from '../commands/types';\n\nconst DEFAULT_PORT = 8765;\nconst DEFAULT_HOST = '127.0.0.1';\nconst DEFAULT_CALL_TIMEOUT_MS = 60_000;\n\nexport type MapTool = {\n  /** MCP tool name, e.g. `map_add_layer` (dots are not allowed in tool names). */\n  name: string;\n  /** The `map.*` command id the call is forwarded to. */\n  commandId: string;\n  description: string;\n  inputSchema: Record<string, unknown>;\n};\n\nexport type KeplerMcpBridgeOptions = {\n  port?: number;\n  host?: string;\n  /** Base URL of the map page, printed with the token. */\n  mapUrl?: string;\n  callTimeoutMs?: number;\n};\n\nexport type KeplerMcpBridgeStart = {\n  host: string;\n  port: number;\n  token: string;\n  /** What a human should open: `<mapUrl>?mcp=<token>`. */\n  pageUrl: string;\n};\n\ntype PendingCall = {\n  resolve: (result: RoomCommandResult) => void;\n  reject: (error: Error) => void;\n  timer: ReturnType<typeof setTimeout>;\n};\n\n/** MCP tool names are commonly restricted to [A-Za-z0-9_-]; `map.add-layer` → `map_add_layer`. */\nexport function toToolName(commandId: string): string {\n  return commandId.replace(/\\./g, '_');\n}\n\nfunction toInputSchema(command: {inputSchema?: unknown}): Record<string, unknown> {\n  if (command.inputSchema) {\n    try {\n      const schema = z.toJSONSchema(command.inputSchema as z.ZodType);\n      if (schema) return schema as Record<string, unknown>;\n    } catch {\n      // Not every command ships a zod schema; fall back to a free-form object.\n    }\n  }\n  return {type: 'object'};\n}\n\n/** The map surface as declared by this package, independent of any page. */\nexport function getMapTools(): MapTool[] {\n  const commands = getKeplerCommands({} as KeplerContext);\n  return Object.values(commands).map(command => ({\n    name: toToolName(command.id),\n    commandId: command.id,\n    description: command.description || command.name,\n    inputSchema: toInputSchema(command)\n  }));\n}\n\nfunction toolsFromDescriptors(descriptors: ToolDescriptor[]): MapTool[] {\n  return descriptors\n    .filter(descriptor => descriptor && descriptor.id)\n    .map(descriptor => ({\n      name: toToolName(descriptor.id),\n      commandId: descriptor.id,\n      description: descriptor.description || descriptor.name || descriptor.id,\n      inputSchema: (descriptor.inputSchema as Record<string, unknown>) || {type: 'object'}\n    }));\n}\n\n/** RoomCommandResult → the text an MCP client shows for a tool call. */\nexport function formatResult(result: RoomCommandResult): {text: string; isError: boolean} {\n  if (result && typeof result === 'object' && result.success === false) {\n    return {text: `✗ ${result.commandId}: ${result.error ?? 'failed'}`, isError: true};\n  }\n  if (result && typeof result === 'object' && result.error) {\n    return {text: `✗ ${result.commandId}: ${result.error}`, isError: true};\n  }\n  const data = result?.data as {details?: string} | undefined;\n  if (data && typeof data.details === 'string') return {text: data.details, isError: false};\n  return {text: JSON.stringify(result?.data ?? result ?? null, null, 2), isError: false};\n}\n\nexport class KeplerMcpBridge {\n  private readonly options: Required<KeplerMcpBridgeOptions>;\n  private readonly staticTools: MapTool[];\n  private pageTools: MapTool[] | null = null;\n  private socket: WebSocket | null = null;\n  private wss: WebSocketServer | null = null;\n  private httpServer: HttpServer | null = null;\n  private readonly pending = new Map<string, PendingCall>();\n  private token = '';\n  private pageUrl = '';\n\n  constructor(options: KeplerMcpBridgeOptions = {}) {\n    this.options = {\n      port: options.port ?? DEFAULT_PORT,\n      host: options.host ?? DEFAULT_HOST,\n      mapUrl: options.mapUrl ?? 'http://localhost:8080',\n      callTimeoutMs: options.callTimeoutMs ?? DEFAULT_CALL_TIMEOUT_MS\n    };\n    this.staticTools = getMapTools();\n  }\n\n  /** Tools the MCP client can call right now. */\n  getTools(): MapTool[] {\n    return this.pageTools ?? this.staticTools;\n  }\n\n  get connected(): boolean {\n    return this.socket?.readyState === WebSocket.OPEN;\n  }\n\n  async start(): Promise<KeplerMcpBridgeStart> {\n    if (this.wss) throw new Error('The kepler.gl bridge is already running.');\n\n    this.token = randomUUID().replace(/-/g, '');\n\n    // A plain HTTP GET on `/` redirects to the map page carrying the token, so\n    // the user can open `http://127.0.0.1:<port>/` even when the MCP client\n    // never shows the server's stderr. Only `/ws` upgrades to a WebSocket.\n    const httpServer = createServer((request, response) => {\n      if (request.url === '/' || request.url?.startsWith('/?')) {\n        response.writeHead(302, {Location: this.pageUrl});\n        response.end();\n        return;\n      }\n      response.writeHead(404, {'content-type': 'text/plain'});\n      response.end('kepler-mcp: the map page connects at /ws');\n    });\n    this.httpServer = httpServer;\n\n    const wss = new WebSocketServer({server: httpServer, path: '/ws'});\n    this.wss = wss;\n    wss.on('connection', (socket, request) => this.handleConnection(socket, request.url));\n\n    await new Promise<void>((resolve, reject) => {\n      httpServer.once('error', reject);\n      httpServer.listen(this.options.port, this.options.host, () => resolve());\n    });\n\n    const address = httpServer.address();\n    const port = typeof address === 'object' && address ? address.port : this.options.port;\n    const mapUrl = this.options.mapUrl.replace(/\\/$/, '');\n    this.pageUrl = `${mapUrl}${mapUrl.includes('?') ? '&' : '?'}mcp=${encodeURIComponent(\n      this.token\n    )}`;\n    return {host: this.options.host, port, token: this.token, pageUrl: this.pageUrl};\n  }\n\n  async callTool(name: string, input: Record<string, unknown> = {}): Promise<RoomCommandResult> {\n    const tool =\n      this.getTools().find(candidate => candidate.name === name) ??\n      this.staticTools.find(candidate => candidate.name === name);\n    if (!tool) {\n      throw new Error(\n        `Unknown map tool \"${name}\". Available: ${this.getTools()\n          .map(candidate => candidate.name)\n          .join(', ')}.`\n      );\n    }\n    const socket = this.socket;\n    if (!socket || socket.readyState !== WebSocket.OPEN) {\n      throw new Error(\n        'No kepler.gl map page is connected. Open the page URL printed at startup ' +\n          '(it carries ?mcp=<token>), then call the tool again.'\n      );\n    }\n\n    const callId = randomUUID();\n    const reply = new Promise<RoomCommandResult>((resolve, reject) => {\n      const timer = setTimeout(() => {\n        this.pending.delete(callId);\n        reject(\n          new Error(`Timed out after ${this.options.callTimeoutMs} ms waiting for the map page.`)\n        );\n      }, this.options.callTimeoutMs);\n      this.pending.set(callId, {resolve, reject, timer});\n    });\n\n    socket.send(JSON.stringify({type: 'call', callId, tool: tool.commandId, input}));\n    return reply;\n  }\n\n  async close(): Promise<void> {\n    this.rejectPending('The bridge was closed.');\n    this.pageTools = null;\n    this.socket?.close(1000, 'bridge closed');\n    this.socket = null;\n    const wss = this.wss;\n    const httpServer = this.httpServer;\n    this.wss = null;\n    this.httpServer = null;\n    if (!wss) return;\n    // close() only stops listening and waits for clients; terminate them so\n    // shutdown (and tests) do not hang on a page that never closes its socket.\n    for (const client of wss.clients) client.terminate();\n    await new Promise<void>(resolve => wss.close(() => resolve()));\n    if (httpServer) {\n      await new Promise<void>(resolve => httpServer.close(() => resolve()));\n    }\n  }\n\n  private handleConnection(socket: WebSocket, requestUrl: string | undefined): void {\n    let token: string | null = null;\n    try {\n      token = new URL(requestUrl ?? '/ws', 'http://127.0.0.1').searchParams.get('token');\n    } catch {\n      token = null;\n    }\n    // The token is the only thing keeping other local pages/processes from\n    // driving the map; reject a mismatch before accepting any message.\n    if (token !== this.token) {\n      socket.close(1008, 'invalid token');\n      return;\n    }\n\n    // One map page at a time: a second tab takes over so calls never race\n    // between two live maps.\n    this.socket?.close(1000, 'replaced by a newer connection');\n    this.socket = socket;\n    this.pageTools = null;\n\n    socket.on('message', data => this.handleMessage(data));\n    socket.on('close', () => {\n      if (this.socket === socket) {\n        this.socket = null;\n        this.pageTools = null;\n        this.rejectPending('The kepler.gl page disconnected.');\n      }\n    });\n    // Errors are followed by close; the close handler resets state.\n    socket.on('error', () => undefined);\n  }\n\n  private handleMessage(raw: unknown): void {\n    let message: any;\n    try {\n      message = JSON.parse(String(raw));\n    } catch {\n      return;\n    }\n    if (message?.type === 'hello' && Array.isArray(message.commands)) {\n      this.pageTools = toolsFromDescriptors(message.commands as ToolDescriptor[]);\n      return;\n    }\n    if (message?.type === 'result' && typeof message.callId === 'string') {\n      const pendingCall = this.pending.get(message.callId);\n      if (!pendingCall) return;\n      clearTimeout(pendingCall.timer);\n      this.pending.delete(message.callId);\n      pendingCall.resolve(message.result as RoomCommandResult);\n    }\n  }\n\n  private rejectPending(reason: string): void {\n    for (const [callId, pendingCall] of this.pending) {\n      clearTimeout(pendingCall.timer);\n      this.pending.delete(callId);\n      pendingCall.reject(new Error(reason));\n    }\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/server/index.js

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+/**
+ * Server-side entry point of `@kepler.gl/mcp`.
+ *
+ * Browser bundles must not import this module: it pulls in `ws` and Node APIs.
+ * The map contracts and commands stay in the package root; this subpath is for
+ * the stdio MCP server (`kepler-mcp`) and for tests.
+ */
+
+export { KeplerMcpBridge, formatResult, getMapTools, toToolName } from './bridge-server';
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJLZXBsZXJNY3BCcmlkZ2UiLCJmb3JtYXRSZXN1bHQiLCJnZXRNYXBUb29scyIsInRvVG9vbE5hbWUiXSwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc2VydmVyL2luZGV4LnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBNSVRcbi8vIENvcHlyaWdodCBjb250cmlidXRvcnMgdG8gdGhlIGtlcGxlci5nbCBwcm9qZWN0XG5cbi8qKlxuICogU2VydmVyLXNpZGUgZW50cnkgcG9pbnQgb2YgYEBrZXBsZXIuZ2wvbWNwYC5cbiAqXG4gKiBCcm93c2VyIGJ1bmRsZXMgbXVzdCBub3QgaW1wb3J0IHRoaXMgbW9kdWxlOiBpdCBwdWxscyBpbiBgd3NgIGFuZCBOb2RlIEFQSXMuXG4gKiBUaGUgbWFwIGNvbnRyYWN0cyBhbmQgY29tbWFuZHMgc3RheSBpbiB0aGUgcGFja2FnZSByb290OyB0aGlzIHN1YnBhdGggaXMgZm9yXG4gKiB0aGUgc3RkaW8gTUNQIHNlcnZlciAoYGtlcGxlci1tY3BgKSBhbmQgZm9yIHRlc3RzLlxuICovXG5cbmV4cG9ydCB7S2VwbGVyTWNwQnJpZGdlLCBmb3JtYXRSZXN1bHQsIGdldE1hcFRvb2xzLCB0b1Rvb2xOYW1lfSBmcm9tICcuL2JyaWRnZS1zZXJ2ZXInO1xuZXhwb3J0IHR5cGUge0tlcGxlck1jcEJyaWRnZU9wdGlvbnMsIEtlcGxlck1jcEJyaWRnZVN0YXJ0LCBNYXBUb29sfSBmcm9tICcuL2JyaWRnZS1zZXJ2ZXInO1xuIl0sIm1hcHBpbmdzIjoiQUFBQTtBQUNBOztBQUVBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBOztBQUVBLFNBQVFBLGVBQWUsRUFBRUMsWUFBWSxFQUFFQyxXQUFXLEVBQUVDLFVBQVUsUUFBTyxpQkFBaUIiLCJpZ25vcmVMaXN0IjpbXX0=