@striderlabs/mcp-airtable 1.0.0

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,223 @@
+#!/usr/bin/env node
+
+// src/index.ts
+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 { z } from "zod";
+var API_KEY = process.env.AIRTABLE_API_KEY;
+var BASE_URL = "https://api.airtable.com/v0";
+var META_URL = "https://api.airtable.com/v0/meta";
+async function airtableRequest(method, url, body) {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (API_KEY) {
+    headers["Authorization"] = `Bearer ${API_KEY}`;
+  }
+  const res = await fetch(url, {
+    method,
+    headers,
+    body: body ? JSON.stringify(body) : void 0
+  });
+  const data = await res.json();
+  if (!res.ok) {
+    throw new Error(`Airtable API error ${res.status}: ${JSON.stringify(data)}`);
+  }
+  return data;
+}
+var server = new Server(
+  { name: "mcp-airtable", version: "1.0.0" },
+  { capabilities: { tools: {} } }
+);
+server.setRequestHandler(ListToolsRequestSchema, async (_request, _extra) => ({
+  tools: [
+    {
+      name: "list_bases",
+      description: "List all accessible Airtable bases",
+      inputSchema: {
+        type: "object",
+        properties: {
+          offset: { type: "string", description: "Pagination offset" }
+        }
+      }
+    },
+    {
+      name: "list_records",
+      description: "List records from an Airtable table",
+      inputSchema: {
+        type: "object",
+        properties: {
+          base_id: { type: "string", description: "The base ID" },
+          table_name: { type: "string", description: "Table name or ID" },
+          max_records: { type: "number", description: "Max records to return" },
+          view: { type: "string", description: "View name or ID" },
+          filter_formula: { type: "string", description: "Airtable formula for filtering" },
+          sort: { type: "array", description: "Sort array [{field, direction}]" },
+          fields: { type: "array", items: { type: "string" }, description: "Fields to include" },
+          offset: { type: "string", description: "Pagination offset" }
+        },
+        required: ["base_id", "table_name"]
+      }
+    },
+    {
+      name: "get_record",
+      description: "Get a specific record from Airtable",
+      inputSchema: {
+        type: "object",
+        properties: {
+          base_id: { type: "string", description: "The base ID" },
+          table_name: { type: "string", description: "Table name or ID" },
+          record_id: { type: "string", description: "The record ID" }
+        },
+        required: ["base_id", "table_name", "record_id"]
+      }
+    },
+    {
+      name: "create_record",
+      description: "Create a new record in Airtable",
+      inputSchema: {
+        type: "object",
+        properties: {
+          base_id: { type: "string", description: "The base ID" },
+          table_name: { type: "string", description: "Table name or ID" },
+          fields: { type: "object", description: "Record field values" }
+        },
+        required: ["base_id", "table_name", "fields"]
+      }
+    },
+    {
+      name: "update_record",
+      description: "Update a record in Airtable",
+      inputSchema: {
+        type: "object",
+        properties: {
+          base_id: { type: "string", description: "The base ID" },
+          table_name: { type: "string", description: "Table name or ID" },
+          record_id: { type: "string", description: "The record ID" },
+          fields: { type: "object", description: "Fields to update" },
+          replace: { type: "boolean", description: "If true, replace all fields (PUT); otherwise patch (PATCH)" }
+        },
+        required: ["base_id", "table_name", "record_id", "fields"]
+      }
+    },
+    {
+      name: "delete_record",
+      description: "Delete a record from Airtable",
+      inputSchema: {
+        type: "object",
+        properties: {
+          base_id: { type: "string", description: "The base ID" },
+          table_name: { type: "string", description: "Table name or ID" },
+          record_id: { type: "string", description: "The record ID" }
+        },
+        required: ["base_id", "table_name", "record_id"]
+      }
+    }
+  ]
+}));
+var ListBasesSchema = z.object({
+  offset: z.string().optional()
+});
+var ListRecordsSchema = z.object({
+  base_id: z.string(),
+  table_name: z.string(),
+  max_records: z.number().optional(),
+  view: z.string().optional(),
+  filter_formula: z.string().optional(),
+  sort: z.array(z.unknown()).optional(),
+  fields: z.array(z.string()).optional(),
+  offset: z.string().optional()
+});
+var GetRecordSchema = z.object({
+  base_id: z.string(),
+  table_name: z.string(),
+  record_id: z.string()
+});
+var CreateRecordSchema = z.object({
+  base_id: z.string(),
+  table_name: z.string(),
+  fields: z.record(z.string(), z.unknown())
+});
+var UpdateRecordSchema = z.object({
+  base_id: z.string(),
+  table_name: z.string(),
+  record_id: z.string(),
+  fields: z.record(z.string(), z.unknown()),
+  replace: z.boolean().optional()
+});
+var DeleteRecordSchema = z.object({
+  base_id: z.string(),
+  table_name: z.string(),
+  record_id: z.string()
+});
+server.setRequestHandler(CallToolRequestSchema, async (request, _extra) => {
+  const { name, arguments: args } = request.params;
+  try {
+    switch (name) {
+      case "list_bases": {
+        const { offset } = ListBasesSchema.parse(args);
+        const qs = offset ? `?offset=${offset}` : "";
+        const result = await airtableRequest("GET", `${META_URL}/bases${qs}`);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      case "list_records": {
+        const params = ListRecordsSchema.parse(args);
+        const qs = new URLSearchParams();
+        if (params.max_records) qs.set("maxRecords", String(params.max_records));
+        if (params.view) qs.set("view", params.view);
+        if (params.filter_formula) qs.set("filterByFormula", params.filter_formula);
+        if (params.offset) qs.set("offset", params.offset);
+        if (params.fields) {
+          params.fields.forEach((f) => qs.append("fields[]", f));
+        }
+        if (params.sort) {
+          params.sort.forEach((s, i) => {
+            qs.set(`sort[${i}][field]`, s.field);
+            if (s.direction) qs.set(`sort[${i}][direction]`, s.direction);
+          });
+        }
+        const url = `${BASE_URL}/${params.base_id}/${encodeURIComponent(params.table_name)}?${qs}`;
+        const result = await airtableRequest("GET", url);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      case "get_record": {
+        const { base_id, table_name, record_id } = GetRecordSchema.parse(args);
+        const url = `${BASE_URL}/${base_id}/${encodeURIComponent(table_name)}/${record_id}`;
+        const result = await airtableRequest("GET", url);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      case "create_record": {
+        const { base_id, table_name, fields } = CreateRecordSchema.parse(args);
+        const url = `${BASE_URL}/${base_id}/${encodeURIComponent(table_name)}`;
+        const result = await airtableRequest("POST", url, { fields });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      case "update_record": {
+        const { base_id, table_name, record_id, fields, replace } = UpdateRecordSchema.parse(args);
+        const url = `${BASE_URL}/${base_id}/${encodeURIComponent(table_name)}/${record_id}`;
+        const method = replace ? "PUT" : "PATCH";
+        const result = await airtableRequest(method, url, { fields });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      case "delete_record": {
+        const { base_id, table_name, record_id } = DeleteRecordSchema.parse(args);
+        const url = `${BASE_URL}/${base_id}/${encodeURIComponent(table_name)}/${record_id}`;
+        const result = await airtableRequest("DELETE", url);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  } catch (error) {
+    return {
+      content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+      isError: true
+    };
+  }
+});
+var transport = new StdioServerTransport();
+await server.connect(transport);

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@striderlabs/mcp-airtable",
+  "version": "1.0.0",
+  "description": "MCP connector for Airtable API",
+  "main": "dist/index.js",
+  "type": "module",
+  "bin": {
+    "mcp-airtable": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts",
+    "dev": "tsup src/index.ts --format esm --watch"
+  },
+  "files": ["dist"],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "latest",
+    "zod": "latest"
+  },
+  "devDependencies": {
+    "tsup": "latest",
+    "typescript": "latest",
+    "@types/node": "latest"
+  }
+}