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

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

@@ -0,0 +1,435 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.KeplerMcpBridge = void 0;
+exports.formatResult = formatResult;
+exports.getMapTools = getMapTools;
+exports.toToolName = toToolName;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _nodeCrypto = require("node:crypto");
+var _nodeHttp = require("node:http");
+var _ws = require("ws");
+var _zod = require("zod");
+var _commands = require("../commands");
+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; } // 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).
+ */
+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`. */
+function toToolName(commandId) {
+  return commandId.replace(/\./g, '_');
+}
+function toInputSchema(command) {
+  if (command.inputSchema) {
+    try {
+      var schema = _zod.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. */
+function getMapTools() {
+  var commands = (0, _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. */
+function formatResult(result) {
+  var _ref, _result$data;
+  if (result && (0, _typeof2["default"])(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 && (0, _typeof2["default"])(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
+  };
+}
+var KeplerMcpBridge = exports.KeplerMcpBridge = /*#__PURE__*/function () {
+  function KeplerMcpBridge() {
+    var _options$port, _options$host, _options$mapUrl, _options$callTimeoutM;
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    (0, _classCallCheck2["default"])(this, KeplerMcpBridge);
+    (0, _defineProperty2["default"])(this, "options", void 0);
+    (0, _defineProperty2["default"])(this, "staticTools", void 0);
+    (0, _defineProperty2["default"])(this, "pageTools", null);
+    (0, _defineProperty2["default"])(this, "socket", null);
+    (0, _defineProperty2["default"])(this, "wss", null);
+    (0, _defineProperty2["default"])(this, "httpServer", null);
+    (0, _defineProperty2["default"])(this, "pending", new Map());
+    (0, _defineProperty2["default"])(this, "token", '');
+    (0, _defineProperty2["default"])(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 (0, _createClass2["default"])(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) === _ws.WebSocket.OPEN;
+    }
+  }, {
+    key: "start",
+    value: function () {
+      var _start = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee() {
+        var _this = this;
+        var httpServer, wss, address, port, mapUrl;
+        return _regenerator["default"].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 = (0, _nodeCrypto.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 = (0, _nodeHttp.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 _ws.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 = (0, _typeof2["default"])(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 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2(name) {
+        var _this$getTools$find,
+          _this2 = this;
+        var input,
+          tool,
+          socket,
+          callId,
+          reply,
+          _args2 = arguments;
+        return _regenerator["default"].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 !== _ws.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 = (0, _nodeCrypto.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 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3() {
+        var _this$socket2;
+        var wss, httpServer, _iterator, _step, client;
+        return _regenerator["default"].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 = (0, _slicedToArray2["default"])(_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":["_nodeCrypto","require","_nodeHttp","_ws","_zod","_commands","_createForOfIteratorHelper","r","e","t","Symbol","iterator","Array","isArray","_unsupportedIterableToArray","length","_n","F","s","n","done","value","f","TypeError","o","a","u","call","next","_arrayLikeToArray","toString","slice","constructor","name","from","test","DEFAULT_PORT","DEFAULT_HOST","DEFAULT_CALL_TIMEOUT_MS","toToolName","commandId","replace","toInputSchema","command","inputSchema","schema","z","toJSONSchema","_unused","type","getMapTools","commands","getKeplerCommands","Object","values","map","id","description","toolsFromDescriptors","descriptors","filter","descriptor","formatResult","result","_ref","_result$data","_typeof2","success","_result$error","text","concat","error","isError","data","details","JSON","stringify","KeplerMcpBridge","exports","_options$port","_options$host","_options$mapUrl","_options$callTimeoutM","options","arguments","undefined","_classCallCheck2","_defineProperty2","Map","port","host","mapUrl","callTimeoutMs","staticTools","_createClass2","key","getTools","_this$pageTools","pageTools","get","_this$socket","socket","readyState","WebSocket","OPEN","_start","_asyncToGenerator2","_regenerator","mark","_callee","_this","httpServer","wss","address","wrap","_callee$","_context","prev","Error","token","randomUUID","createServer","request","response","_request$url","url","startsWith","writeHead","Location","pageUrl","end","WebSocketServer","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","clients","terminate","err","requestUrl","_this$socket3","_this3","URL","searchParams","_unused2","handleMessage","raw","_message","_message2","message","parse","String","_unused3","pendingCall","clearTimeout","reason","_iterator2","_step2","_step2$value","_slicedToArray2"],"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/cjs/server/index.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "KeplerMcpBridge", {
+  enumerable: true,
+  get: function get() {
+    return _bridgeServer.KeplerMcpBridge;
+  }
+});
+Object.defineProperty(exports, "formatResult", {
+  enumerable: true,
+  get: function get() {
+    return _bridgeServer.formatResult;
+  }
+});
+Object.defineProperty(exports, "getMapTools", {
+  enumerable: true,
+  get: function get() {
+    return _bridgeServer.getMapTools;
+  }
+});
+Object.defineProperty(exports, "toToolName", {
+  enumerable: true,
+  get: function get() {
+    return _bridgeServer.toToolName;
+  }
+});
+var _bridgeServer = require("./bridge-server");
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJfYnJpZGdlU2VydmVyIiwicmVxdWlyZSJdLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zZXJ2ZXIvaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IE1JVFxuLy8gQ29weXJpZ2h0IGNvbnRyaWJ1dG9ycyB0byB0aGUga2VwbGVyLmdsIHByb2plY3RcblxuLyoqXG4gKiBTZXJ2ZXItc2lkZSBlbnRyeSBwb2ludCBvZiBgQGtlcGxlci5nbC9tY3BgLlxuICpcbiAqIEJyb3dzZXIgYnVuZGxlcyBtdXN0IG5vdCBpbXBvcnQgdGhpcyBtb2R1bGU6IGl0IHB1bGxzIGluIGB3c2AgYW5kIE5vZGUgQVBJcy5cbiAqIFRoZSBtYXAgY29udHJhY3RzIGFuZCBjb21tYW5kcyBzdGF5IGluIHRoZSBwYWNrYWdlIHJvb3Q7IHRoaXMgc3VicGF0aCBpcyBmb3JcbiAqIHRoZSBzdGRpbyBNQ1Agc2VydmVyIChga2VwbGVyLW1jcGApIGFuZCBmb3IgdGVzdHMuXG4gKi9cblxuZXhwb3J0IHtLZXBsZXJNY3BCcmlkZ2UsIGZvcm1hdFJlc3VsdCwgZ2V0TWFwVG9vbHMsIHRvVG9vbE5hbWV9IGZyb20gJy4vYnJpZGdlLXNlcnZlcic7XG5leHBvcnQgdHlwZSB7S2VwbGVyTWNwQnJpZGdlT3B0aW9ucywgS2VwbGVyTWNwQnJpZGdlU3RhcnQsIE1hcFRvb2x9IGZyb20gJy4vYnJpZGdlLXNlcnZlcic7XG4iXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBV0EsSUFBQUEsYUFBQSxHQUFBQyxPQUFBIiwiaWdub3JlTGlzdCI6W119