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

package/dist/esm/server/stdio.js

@@ -0,0 +1,198 @@
+#!/usr/bin/env node
+
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+/**
+ * `kepler-mcp` — a stdio MCP server for the kepler.gl map surface.
+ *
+ * The agent starts this process (it speaks MCP on stdin/stdout); the process
+ * also listens for the map page on a loopback WebSocket. It prints a URL that
+ * carries the one-time token — open that URL and the page connects, after which
+ * every map.* tool call executes against the live map.
+ *
+ * stdout belongs to the MCP protocol: every log line here goes to stderr.
+ */
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { KeplerMcpBridge, formatResult } from './bridge-server';
+var DEFAULT_MAP_URL = 'http://localhost:8080';
+function readVersion() {
+  if (typeof __dirname === 'undefined') return '0.0.0';
+  var directory = __dirname;
+  // Walk up until the package manifest is found, so this works both from src/
+  // (babel-node, tests) and from dist/cjs/server (the published bin).
+  for (var depth = 0; depth < 5; depth++) {
+    try {
+      var manifest = JSON.parse(readFileSync(join(directory, 'package.json'), 'utf8'));
+      if (manifest.name === '@kepler.gl/mcp') return manifest.version;
+    } catch (_unused) {
+      // no manifest at this level — keep walking
+    }
+    directory = dirname(directory);
+  }
+  return '0.0.0';
+}
+function usage() {
+  return ['Usage: kepler-mcp [--port <n>] [--host <h>] [--map-url <url>]', '', 'Runs a stdio MCP server for the kepler.gl map surface and waits for a', 'kepler.gl page to connect over a loopback WebSocket.', '', '  --port <n>       WebSocket port for the page (default 8765)', '  --host <h>       loopback host to bind (default 127.0.0.1)', "  --map-url <url>  page URL printed with the token (default ".concat(DEFAULT_MAP_URL, ")")].join('\n');
+}
+function parseArgs(argv) {
+  var options = {};
+  for (var i = 0; i < argv.length; i++) {
+    var arg = argv[i];
+    if (arg === '--help' || arg === '-h') {
+      options.help = true;
+    } else if (arg === '--port') {
+      var value = Number(argv[++i]);
+      if (!Number.isInteger(value) || value < 0 || value > 65535) {
+        throw new Error("Invalid --port value: ".concat(argv[i]));
+      }
+      options.port = value;
+    } else if (arg === '--host') {
+      options.host = argv[++i];
+    } else if (arg === '--map-url') {
+      options.mapUrl = argv[++i];
+    } else {
+      throw new Error("Unknown argument: ".concat(arg));
+    }
+  }
+  return options;
+}
+function main() {
+  return _main.apply(this, arguments);
+}
+function _main() {
+  _main = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+    var options, bridge, started, server, shutdown;
+    return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          options = parseArgs(process.argv.slice(2));
+          if (!options.help) {
+            _context4.next = 4;
+            break;
+          }
+          console.error(usage());
+          return _context4.abrupt("return");
+        case 4:
+          bridge = new KeplerMcpBridge(options);
+          _context4.next = 7;
+          return bridge.start();
+        case 7:
+          started = _context4.sent;
+          server = new Server({
+            name: 'kepler-mcp',
+            version: readVersion()
+          }, {
+            capabilities: {
+              tools: {}
+            }
+          });
+          server.setRequestHandler(ListToolsRequestSchema, /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+            return _regeneratorRuntime.wrap(function _callee$(_context) {
+              while (1) switch (_context.prev = _context.next) {
+                case 0:
+                  return _context.abrupt("return", {
+                    tools: bridge.getTools().map(function (tool) {
+                      return {
+                        name: tool.name,
+                        description: tool.description,
+                        inputSchema: tool.inputSchema
+                      };
+                    })
+                  });
+                case 1:
+                case "end":
+                  return _context.stop();
+              }
+            }, _callee);
+          })));
+          server.setRequestHandler(CallToolRequestSchema, /*#__PURE__*/function () {
+            var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2(request) {
+              var _request$params, name, args, result, _formatResult, text, isError;
+              return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+                while (1) switch (_context2.prev = _context2.next) {
+                  case 0:
+                    _request$params = request.params, name = _request$params.name, args = _request$params.arguments;
+                    _context2.prev = 1;
+                    _context2.next = 4;
+                    return bridge.callTool(name, args !== null && args !== void 0 ? args : {});
+                  case 4:
+                    result = _context2.sent;
+                    _formatResult = formatResult(result), text = _formatResult.text, isError = _formatResult.isError;
+                    return _context2.abrupt("return", _objectSpread({
+                      content: [{
+                        type: 'text',
+                        text: text
+                      }]
+                    }, isError ? {
+                      isError: true
+                    } : {}));
+                  case 9:
+                    _context2.prev = 9;
+                    _context2.t0 = _context2["catch"](1);
+                    return _context2.abrupt("return", {
+                      content: [{
+                        type: 'text',
+                        text: _context2.t0 instanceof Error ? _context2.t0.message : String(_context2.t0)
+                      }],
+                      isError: true
+                    });
+                  case 12:
+                  case "end":
+                    return _context2.stop();
+                }
+              }, _callee2, null, [[1, 9]]);
+            }));
+            return function (_x) {
+              return _ref2.apply(this, arguments);
+            };
+          }());
+          shutdown = /*#__PURE__*/function () {
+            var _ref3 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+              return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+                while (1) switch (_context3.prev = _context3.next) {
+                  case 0:
+                    _context3.next = 2;
+                    return bridge.close();
+                  case 2:
+                    process.exit(0);
+                  case 3:
+                  case "end":
+                    return _context3.stop();
+                }
+              }, _callee3);
+            }));
+            return function shutdown() {
+              return _ref3.apply(this, arguments);
+            };
+          }();
+          process.on('SIGINT', shutdown);
+          process.on('SIGTERM', shutdown);
+          _context4.next = 16;
+          return server.connect(new StdioServerTransport());
+        case 16:
+          console.error("[kepler-mcp] bridge listening on ws://".concat(started.host, ":").concat(started.port, "/ws"));
+          console.error("[kepler-mcp] open http://".concat(started.host, ":").concat(started.port, "/ in a browser \u2014 it redirects ") + 'to the map page with the token — so the agent can drive the map');
+          console.error("[kepler-mcp] or open ".concat(started.pageUrl));
+        case 19:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  }));
+  return _main.apply(this, arguments);
+}
+main()["catch"](function (error) {
+  console.error("[kepler-mcp] ".concat(error instanceof Error ? error.message : String(error)));
+  process.exit(1);
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_defineProperty","_asyncToGenerator","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","getOwnPropertyDescriptors","defineProperties","defineProperty","_regeneratorRuntime","readFileSync","dirname","join","Server","StdioServerTransport","CallToolRequestSchema","ListToolsRequestSchema","KeplerMcpBridge","formatResult","DEFAULT_MAP_URL","readVersion","__dirname","directory","depth","manifest","JSON","parse","name","version","_unused","usage","concat","parseArgs","argv","options","i","arg","help","value","Number","isInteger","Error","port","host","mapUrl","main","_main","mark","_callee4","bridge","started","server","shutdown","wrap","_callee4$","_context4","prev","next","process","slice","console","error","abrupt","start","sent","capabilities","tools","setRequestHandler","_callee","_callee$","_context","getTools","map","tool","description","inputSchema","stop","_ref2","_callee2","request","_request$params","args","result","_formatResult","text","isError","_callee2$","_context2","params","callTool","content","type","t0","message","String","_x","_ref3","_callee3","_callee3$","_context3","close","exit","on","connect","pageUrl"],"sources":["../../../src/server/stdio.ts"],"sourcesContent":["#!/usr/bin/env node\n\n// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\n/**\n * `kepler-mcp` — a stdio MCP server for the kepler.gl map surface.\n *\n * The agent starts this process (it speaks MCP on stdin/stdout); the process\n * also listens for the map page on a loopback WebSocket. It prints a URL that\n * carries the one-time token — open that URL and the page connects, after which\n * every map.* tool call executes against the live map.\n *\n * stdout belongs to the MCP protocol: every log line here goes to stderr.\n */\n\nimport {readFileSync} from 'node:fs';\nimport {dirname, join} from 'node:path';\nimport {Server} from '@modelcontextprotocol/sdk/server/index.js';\nimport {StdioServerTransport} from '@modelcontextprotocol/sdk/server/stdio.js';\nimport {CallToolRequestSchema, ListToolsRequestSchema} from '@modelcontextprotocol/sdk/types.js';\nimport {KeplerMcpBridge, formatResult} from './bridge-server';\nimport type {KeplerMcpBridgeOptions} from './bridge-server';\n\nconst DEFAULT_MAP_URL = 'http://localhost:8080';\n\nfunction readVersion(): string {\n  if (typeof __dirname === 'undefined') return '0.0.0';\n  let directory = __dirname;\n  // Walk up until the package manifest is found, so this works both from src/\n  // (babel-node, tests) and from dist/cjs/server (the published bin).\n  for (let depth = 0; depth < 5; depth++) {\n    try {\n      const manifest = JSON.parse(readFileSync(join(directory, 'package.json'), 'utf8'));\n      if (manifest.name === '@kepler.gl/mcp') return manifest.version;\n    } catch {\n      // no manifest at this level — keep walking\n    }\n    directory = dirname(directory);\n  }\n  return '0.0.0';\n}\n\nfunction usage(): string {\n  return [\n    'Usage: kepler-mcp [--port <n>] [--host <h>] [--map-url <url>]',\n    '',\n    'Runs a stdio MCP server for the kepler.gl map surface and waits for a',\n    'kepler.gl page to connect over a loopback WebSocket.',\n    '',\n    '  --port <n>       WebSocket port for the page (default 8765)',\n    '  --host <h>       loopback host to bind (default 127.0.0.1)',\n    `  --map-url <url>  page URL printed with the token (default ${DEFAULT_MAP_URL})`\n  ].join('\\n');\n}\n\nfunction parseArgs(argv: string[]): KeplerMcpBridgeOptions & {help?: boolean} {\n  const options: KeplerMcpBridgeOptions & {help?: boolean} = {};\n  for (let i = 0; i < argv.length; i++) {\n    const arg = argv[i];\n    if (arg === '--help' || arg === '-h') {\n      options.help = true;\n    } else if (arg === '--port') {\n      const value = Number(argv[++i]);\n      if (!Number.isInteger(value) || value < 0 || value > 65535) {\n        throw new Error(`Invalid --port value: ${argv[i]}`);\n      }\n      options.port = value;\n    } else if (arg === '--host') {\n      options.host = argv[++i];\n    } else if (arg === '--map-url') {\n      options.mapUrl = argv[++i];\n    } else {\n      throw new Error(`Unknown argument: ${arg}`);\n    }\n  }\n  return options;\n}\n\nasync function main(): Promise<void> {\n  const options = parseArgs(process.argv.slice(2));\n  if (options.help) {\n    console.error(usage());\n    return;\n  }\n\n  const bridge = new KeplerMcpBridge(options);\n  const started = await bridge.start();\n\n  const server = new Server(\n    {name: 'kepler-mcp', version: readVersion()},\n    {capabilities: {tools: {}}}\n  );\n\n  server.setRequestHandler(ListToolsRequestSchema, async () => ({\n    tools: bridge.getTools().map(tool => ({\n      name: tool.name,\n      description: tool.description,\n      inputSchema: tool.inputSchema as {type: 'object'; [key: string]: unknown}\n    }))\n  }));\n\n  server.setRequestHandler(CallToolRequestSchema, async request => {\n    const {name, arguments: args} = request.params;\n    try {\n      const result = await bridge.callTool(name, (args ?? {}) as Record<string, unknown>);\n      const {text, isError} = formatResult(result);\n      return {content: [{type: 'text' as const, text}], ...(isError ? {isError: true} : {})};\n    } catch (error) {\n      return {\n        content: [\n          {type: 'text' as const, text: error instanceof Error ? error.message : String(error)}\n        ],\n        isError: true\n      };\n    }\n  });\n\n  const shutdown = async () => {\n    await bridge.close();\n    process.exit(0);\n  };\n  process.on('SIGINT', shutdown);\n  process.on('SIGTERM', shutdown);\n\n  await server.connect(new StdioServerTransport());\n\n  console.error(`[kepler-mcp] bridge listening on ws://${started.host}:${started.port}/ws`);\n  console.error(\n    `[kepler-mcp] open http://${started.host}:${started.port}/ in a browser — it redirects ` +\n      'to the map page with the token — so the agent can drive the map'\n  );\n  console.error(`[kepler-mcp] or open ${started.pageUrl}`);\n}\n\nmain().catch(error => {\n  console.error(`[kepler-mcp] ${error instanceof Error ? error.message : String(error)}`);\n  process.exit(1);\n});\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/types.js

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+/**
+ * Shared contract types for the kepler.gl map surface.
+ *
+ * This module is the home of the reusable *map surface* contract — the map.*
+ * tool namespace that any AI client can drive. It defines the map.* tool ids
+ * and the `ToolResult` shape so any host (the demo-app browser page, the
+ * kepler-assistant library, or a future MCP server) can implement or consume
+ * the same contract.
+ */
+
+/** A command/tool execution result. */
+
+/**
+ * The v1 map tool surface. These are the command ids the kepler.gl demo-app's
+ * assistant actually registers, reconciled with the kepler-mcp proposal. Most
+ * commands are pure map actuation (set-basemap, add-layer, ...); the table ops
+ * (map.create-table, map.add-column, map.save-data) are DuckDB-backed and are
+ * included because they mutate the map's datasets in place.
+ */
+export var MAP_TOOL_IDS = ['map.set-basemap', 'map.get-boundary', 'map.add-layer', 'map.update-layer-color', 'map.load-data', 'map.save-data', 'map.create-table', 'map.add-column', 'map.add-time-filter', 'map.toggle-time-filter', 'map.split-view', 'map.get-dataset-context'];
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @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';

package/dist/map-contract.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The kepler.gl map tool contract — the "map surface".
+ *
+ * kepler.gl's contract is "accept data, actuate the map, introspect, render."
+ * The surface is map-focused: no spatial analysis and no charts — those belong
+ * to the analysis service (kepler-assistant). A few table ops (map.create-table,
+ * map.add-column, map.save-data) are DuckDB-backed and mutate the map's datasets
+ * in place; they are part of the surface because they change what the map shows.
+ *
+ * This module is intentionally dependency-light. It defines the map.* tool ids
+ * and a `MapContract` interface so any host (the demo-app browser page, the
+ * kepler-assistant library, or a future MCP server) can implement or consume
+ * the same contract.
+ */
+import type { MapToolId, ToolResult } from './types';
+/**
+ * The map tool surface. Mostly pure map actuation (set-basemap, add-layer, ...);
+ * a few table ops (map.create-table, map.add-column, map.save-data) are included
+ * because they mutate the map's datasets in place.
+ */
+export interface MapContract {
+    readonly toolIds: readonly MapToolId[];
+    /** List the tools this surface exposes (id + input JSON Schema, if known). */
+    listTools(): Array<{
+        id: MapToolId;
+        inputSchema?: unknown;
+        description?: string;
+    }>;
+    /** Execute a map tool. Returns a trimmed, model-facing result. */
+    callTool(id: MapToolId, input: Record<string, unknown>): Promise<ToolResult>;
+}

package/dist/server/bridge-server.d.ts

@@ -0,0 +1,53 @@
+import type { RoomCommandResult } from '../commands/types';
+export type MapTool = {
+    /** MCP tool name, e.g. `map_add_layer` (dots are not allowed in tool names). */
+    name: string;
+    /** The `map.*` command id the call is forwarded to. */
+    commandId: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+};
+export type KeplerMcpBridgeOptions = {
+    port?: number;
+    host?: string;
+    /** Base URL of the map page, printed with the token. */
+    mapUrl?: string;
+    callTimeoutMs?: number;
+};
+export type KeplerMcpBridgeStart = {
+    host: string;
+    port: number;
+    token: string;
+    /** What a human should open: `<mapUrl>?mcp=<token>`. */
+    pageUrl: string;
+};
+/** MCP tool names are commonly restricted to [A-Za-z0-9_-]; `map.add-layer` → `map_add_layer`. */
+export declare function toToolName(commandId: string): string;
+/** The map surface as declared by this package, independent of any page. */
+export declare function getMapTools(): MapTool[];
+/** RoomCommandResult → the text an MCP client shows for a tool call. */
+export declare function formatResult(result: RoomCommandResult): {
+    text: string;
+    isError: boolean;
+};
+export declare class KeplerMcpBridge {
+    private readonly options;
+    private readonly staticTools;
+    private pageTools;
+    private socket;
+    private wss;
+    private httpServer;
+    private readonly pending;
+    private token;
+    private pageUrl;
+    constructor(options?: KeplerMcpBridgeOptions);
+    /** Tools the MCP client can call right now. */
+    getTools(): MapTool[];
+    get connected(): boolean;
+    start(): Promise<KeplerMcpBridgeStart>;
+    callTool(name: string, input?: Record<string, unknown>): Promise<RoomCommandResult>;
+    close(): Promise<void>;
+    private handleConnection;
+    private handleMessage;
+    private rejectPending;
+}

package/dist/server/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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';
+export type { KeplerMcpBridgeOptions, KeplerMcpBridgeStart, MapTool } from './bridge-server';

package/dist/server/stdio.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/types.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Shared contract types for the kepler.gl map surface.
+ *
+ * This module is the home of the reusable *map surface* contract — the map.*
+ * tool namespace that any AI client can drive. It defines the map.* tool ids
+ * and the `ToolResult` shape so any host (the demo-app browser page, the
+ * kepler-assistant library, or a future MCP server) can implement or consume
+ * the same contract.
+ */
+/** A command/tool execution result. */
+export interface ToolResult {
+    success: boolean;
+    data?: unknown;
+    error?: string;
+}
+/**
+ * The v1 map tool surface. These are the command ids the kepler.gl demo-app's
+ * assistant actually registers, reconciled with the kepler-mcp proposal. Most
+ * commands are pure map actuation (set-basemap, add-layer, ...); the table ops
+ * (map.create-table, map.add-column, map.save-data) are DuckDB-backed and are
+ * included because they mutate the map's datasets in place.
+ */
+export declare const MAP_TOOL_IDS: readonly ["map.set-basemap", "map.get-boundary", "map.add-layer", "map.update-layer-color", "map.load-data", "map.save-data", "map.create-table", "map.add-column", "map.add-time-filter", "map.toggle-time-filter", "map.split-view", "map.get-dataset-context"];
+export type MapToolId = (typeof MAP_TOOL_IDS)[number];

package/package.json

@@ -1,6 +1,86 @@
 {
   "name": "@kepler.gl/mcp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "author": "Shan He <heshan0131@gmail.com>",
+  "version": "3.3.0-alpha.19",
+  "description": "The kepler.gl map surface for AI agents: map.* commands, command contract + JSON Schemas + types, a stdio MCP server that bridges to an open kepler.gl page, and the kepler map-management skill",
+  "license": "MIT",
+  "main": "dist/cjs/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "kepler-mcp": "dist/cjs/server/stdio.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js",
+      "default": "./dist/cjs/index.js"
+    },
+    "./server": {
+      "types": "./dist/server/index.d.ts",
+      "import": "./dist/esm/server/index.js",
+      "require": "./dist/cjs/server/index.js",
+      "default": "./dist/cjs/server/index.js"
+    },
+    "./skill/kepler/SKILL.md": "./skill/kepler/SKILL.md",
+    "./skill/kepler/skill.yaml": "./skill/kepler/skill.yaml"
+  },
+  "keywords": [
+    "kepler",
+    "kepler.gl",
+    "map",
+    "mcp",
+    "ai"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/keplergl/kepler.gl.git"
+  },
+  "scripts": {
+    "build": "rm -fr dist && babel src --out-dir dist/cjs --source-maps inline --extensions '.ts,.tsx,.js,.jsx' --ignore '**/*.d.ts,**/*.spec.ts,**/*.test.ts' && BABEL_ENV=esm babel src --out-dir dist/esm --source-maps inline --extensions '.ts,.tsx,.js,.jsx' --ignore '**/*.d.ts,**/*.spec.ts,**/*.test.ts'",
+    "build:types": "tsc --project ./tsconfig.production.json",
+    "prepublishOnly": "babel-node ../../scripts/license-header/bin --license ../../FILE-HEADER && yarn build && yarn build:types",
+    "stab": "mkdir -p dist/cjs dist/esm && echo \"'use strict'; Object.assign(module.exports, require('../../src'));\" > dist/cjs/index.js && echo \"export * from '../../src';\" > dist/esm/index.js"
+  },
+  "files": [
+    "dist",
+    "skill"
+  ],
+  "dependencies": {
+    "@kepler.gl/actions": "3.3.0-alpha.19",
+    "@kepler.gl/constants": "3.3.0-alpha.19",
+    "@kepler.gl/layers": "3.3.0-alpha.19",
+    "@kepler.gl/processors": "3.3.0-alpha.19",
+    "@kepler.gl/reducers": "3.3.0-alpha.19",
+    "@kepler.gl/table": "3.3.0-alpha.19",
+    "@kepler.gl/types": "3.3.0-alpha.19",
+    "@modelcontextprotocol/sdk": "^1.32.2",
+    "apache-arrow": "^17.0.0",
+    "ws": "^8.22.0",
+    "zod": "^4.4.0"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.12.1",
+    "@babel/node": "^7.12.1",
+    "@types/ws": "^8.18.2"
+  },
+  "nyc": {
+    "sourceMap": false,
+    "instrument": false
+  },
+  "maintainers": [
+    "Shan He <heshan0131@gmail.com>",
+    "Igor Dykhta <dikhta.igor@gmail.com>",
+    "Ilya Boyandin <ilya@boyandin.me>",
+    "Xun Li <lixun910@gmail.com>"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "volta": {
+    "node": "20.19.3",
+    "yarn": "4.4.0"
+  },
+  "packageManager": "yarn@4.4.0",
+  "module": "dist/esm/index.js"
+}