@rashidazarang/airtable-mcp 1.2.4 → 1.5.0

package/airtable_simple.js

@@ -23,7 +23,7 @@ const baseId = baseIndex !== -1 ? args[baseIndex + 1] : process.env.AIRTABLE_BAS
 if (!token || !baseId) {
   console.error('Error: Missing Airtable credentials');
   console.error('\nUsage options:');
-  console.error('  1. Command line: node airtable_simple.js --token YOUR_TOKEN --base YOUR_BASE_ID');
+  console.error('  1. Command line: node airtable_enhanced.js --token YOUR_TOKEN --base YOUR_BASE_ID');
   console.error('  2. Environment variables: AIRTABLE_TOKEN and AIRTABLE_BASE_ID');
   console.error('  3. .env file with AIRTABLE_TOKEN and AIRTABLE_BASE_ID');
   process.exit(1);
@@ -55,7 +55,76 @@ function log(level, message, ...args) {
   }
 }
 
-log(LOG_LEVELS.INFO, `Starting Airtable MCP server with token ${token.slice(0, 5)}...${token.slice(-5)} and base ${baseId}`);
+log(LOG_LEVELS.INFO, `Starting Enhanced Airtable MCP server v1.5.0`);
+log(LOG_LEVELS.INFO, `Authentication configured`);
+log(LOG_LEVELS.INFO, `Base connection established`);
+
+// Enhanced Airtable API function with full HTTP method support
+function callAirtableAPI(endpoint, method = 'GET', body = null, queryParams = {}) {
+  return new Promise((resolve, reject) => {
+    const isBaseEndpoint = !endpoint.startsWith('meta/') && !endpoint.startsWith('bases/');
+    const baseUrl = isBaseEndpoint ? `${baseId}/${endpoint}` : endpoint;
+    
+    // Build query string
+    const queryString = Object.keys(queryParams).length > 0 
+      ? '?' + new URLSearchParams(queryParams).toString() 
+      : '';
+    
+    const url = `https://api.airtable.com/v0/${baseUrl}${queryString}`;
+    const urlObj = new URL(url);
+    
+    log(LOG_LEVELS.DEBUG, `API Request: ${method} ${url}`);
+    if (body) {
+      log(LOG_LEVELS.DEBUG, `Request body:`, JSON.stringify(body, null, 2));
+    }
+    
+    const options = {
+      hostname: urlObj.hostname,
+      path: urlObj.pathname + urlObj.search,
+      method: method,
+      headers: {
+        'Authorization': `Bearer ${token}`,
+        'Content-Type': 'application/json'
+      }
+    };
+    
+    const req = https.request(options, (response) => {
+      let data = '';
+      
+      response.on('data', (chunk) => {
+        data += chunk;
+      });
+      
+      response.on('end', () => {
+        log(LOG_LEVELS.DEBUG, `Response status: ${response.statusCode}`);
+        log(LOG_LEVELS.DEBUG, `Response data:`, data);
+        
+        try {
+          const parsed = data ? JSON.parse(data) : {};
+          
+          if (response.statusCode >= 200 && response.statusCode < 300) {
+            resolve(parsed);
+          } else {
+            const error = parsed.error || {};
+            reject(new Error(`Airtable API error (${response.statusCode}): ${error.message || error.type || 'Unknown error'}`));
+          }
+        } catch (e) {
+          reject(new Error(`Failed to parse Airtable response: ${e.message}`));
+        }
+      });
+    });
+    
+    req.on('error', (error) => {
+      reject(new Error(`Airtable API request failed: ${error.message}`));
+    });
+    
+    if (body) {
+      req.write(JSON.stringify(body));
+    }
+    
+    req.end();
+  });
+}
 
 // Create HTTP server
 const server = http.createServer(async (req, res) => {
@@ -86,8 +155,323 @@ const server = http.createServer(async (req, res) => {
   req.on('end', async () => {
     try {
       const request = JSON.parse(body);
+      log(LOG_LEVELS.DEBUG, 'Received request:', JSON.stringify(request, null, 2));
       
       // Handle JSON-RPC methods
+      if (request.method === 'tools/list') {
+        const response = {
+          jsonrpc: '2.0',
+          id: request.id,
+          result: {
+            tools: [
+              {
+                name: 'list_tables',
+                description: 'List all tables in the Airtable base',
+                inputSchema: {
+                  type: 'object',
+                  properties: {}
+                }
+              },
+              {
+                name: 'list_records',
+                description: 'List records from a specific table',
+                inputSchema: {
+                  type: 'object',
+                  properties: {
+                    table: { type: 'string', description: 'Table name or ID' },
+                    maxRecords: { type: 'number', description: 'Maximum number of records to return' },
+                    view: { type: 'string', description: 'View name or ID' }
+                  },
+                  required: ['table']
+                }
+              },
+              {
+                name: 'get_record',
+                description: 'Get a single record by ID',
+                inputSchema: {
+                  type: 'object',
+                  properties: {
+                    table: { type: 'string', description: 'Table name or ID' },
+                    recordId: { type: 'string', description: 'Record ID' }
+                  },
+                  required: ['table', 'recordId']
+                }
+              },
+              {
+                name: 'create_record',
+                description: 'Create a new record in a table',
+                inputSchema: {
+                  type: 'object',
+                  properties: {
+                    table: { type: 'string', description: 'Table name or ID' },
+                    fields: { type: 'object', description: 'Field values for the new record' }
+                  },
+                  required: ['table', 'fields']
+                }
+              },
+              {
+                name: 'update_record',
+                description: 'Update an existing record',
+                inputSchema: {
+                  type: 'object',
+                  properties: {
+                    table: { type: 'string', description: 'Table name or ID' },
+                    recordId: { type: 'string', description: 'Record ID to update' },
+                    fields: { type: 'object', description: 'Fields to update' }
+                  },
+                  required: ['table', 'recordId', 'fields']
+                }
+              },
+              {
+                name: 'delete_record',
+                description: 'Delete a record from a table',
+                inputSchema: {
+                  type: 'object',
+                  properties: {
+                    table: { type: 'string', description: 'Table name or ID' },
+                    recordId: { type: 'string', description: 'Record ID to delete' }
+                  },
+                  required: ['table', 'recordId']
+                }
+              },
+              {
+                name: 'search_records',
+                description: 'Search records with filtering and sorting',
+                inputSchema: {
+                  type: 'object',
+                  properties: {
+                    table: { type: 'string', description: 'Table name or ID' },
+                    filterByFormula: { type: 'string', description: 'Airtable formula to filter records' },
+                    sort: { type: 'array', description: 'Sort configuration' },
+                    maxRecords: { type: 'number', description: 'Maximum records to return' },
+                    fields: { type: 'array', description: 'Fields to return' }
+                  },
+                  required: ['table']
+                }
+              },
+              {
+                name: 'list_webhooks',
+                description: 'List all webhooks for the base',
+                inputSchema: {
+                  type: 'object',
+                  properties: {}
+                }
+              },
+              {
+                name: 'create_webhook',
+                description: 'Create a new webhook for a table',
+                inputSchema: {
+                  type: 'object',
+                  properties: {
+                    notificationUrl: { type: 'string', description: 'URL to receive webhook notifications' },
+                    specification: {
+                      type: 'object',
+                      description: 'Webhook specification',
+                      properties: {
+                        options: {
+                          type: 'object',
+                          properties: {
+                            filters: {
+                              type: 'object',
+                              properties: {
+                                dataTypes: { type: 'array', items: { type: 'string' } },
+                                recordChangeScope: { type: 'string' }
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  },
+                  required: ['notificationUrl']
+                }
+              },
+              {
+                name: 'delete_webhook',
+                description: 'Delete a webhook',
+                inputSchema: {
+                  type: 'object',
+                  properties: {
+                    webhookId: { type: 'string', description: 'Webhook ID to delete' }
+                  },
+                  required: ['webhookId']
+                }
+              },
+              {
+                name: 'get_webhook_payloads',
+                description: 'Get webhook payload history',
+                inputSchema: {
+                  type: 'object',
+                  properties: {
+                    webhookId: { type: 'string', description: 'Webhook ID' },
+                    cursor: { type: 'number', description: 'Cursor for pagination' }
+                  },
+                  required: ['webhookId']
+                }
+              },
+              {
+                name: 'refresh_webhook',
+                description: 'Refresh a webhook to extend its expiration',
+                inputSchema: {
+                  type: 'object',
+                  properties: {
+                    webhookId: { type: 'string', description: 'Webhook ID to refresh' }
+                  },
+                  required: ['webhookId']
+                }
+              },
+              {
+                name: 'list_bases',
+                description: 'List all accessible Airtable bases',
+                inputSchema: {
+                  type: 'object',
+                  properties: {
+                    offset: { type: 'string', description: 'Pagination offset for listing more bases' }
+                  }
+                }
+              },
+              {
+                name: 'get_base_schema',
+                description: 'Get complete schema information for a base',
+                inputSchema: {
+                  type: 'object',
+                  properties: {
+                    baseId: { type: 'string', description: 'Base ID to get schema for (optional, defaults to current base)' }
+                  }
+                }
+              },
+              {
+                name: 'describe_table',
+                description: 'Get detailed information about a specific table including all fields',
+                inputSchema: {
+                  type: 'object',
+                  properties: {
+                    table: { type: 'string', description: 'Table name or ID' }
+                  },
+                  required: ['table']
+                }
+              },
+              {
+                name: 'create_table',
+                description: 'Create a new table in the base',
+                inputSchema: {
+                  type: 'object',
+                  properties: {
+                    name: { type: 'string', description: 'Name for the new table' },
+                    description: { type: 'string', description: 'Optional description for the table' },
+                    fields: { 
+                      type: 'array', 
+                      description: 'Array of field definitions',
+                      items: {
+                        type: 'object',
+                        properties: {
+                          name: { type: 'string', description: 'Field name' },
+                          type: { type: 'string', description: 'Field type (singleLineText, number, etc.)' },
+                          description: { type: 'string', description: 'Field description' },
+                          options: { type: 'object', description: 'Field-specific options' }
+                        },
+                        required: ['name', 'type']
+                      }
+                    }
+                  },
+                  required: ['name', 'fields']
+                }
+              },
+              {
+                name: 'update_table',
+                description: 'Update table name or description',
+                inputSchema: {
+                  type: 'object',
+                  properties: {
+                    table: { type: 'string', description: 'Table name or ID' },
+                    name: { type: 'string', description: 'New table name' },
+                    description: { type: 'string', description: 'New table description' }
+                  },
+                  required: ['table']
+                }
+              },
+              {
+                name: 'delete_table',
+                description: 'Delete a table (WARNING: This will permanently delete all data)',
+                inputSchema: {
+                  type: 'object',
+                  properties: {
+                    table: { type: 'string', description: 'Table name or ID to delete' },
+                    confirm: { type: 'boolean', description: 'Must be true to confirm deletion' }
+                  },
+                  required: ['table', 'confirm']
+                }
+              },
+              {
+                name: 'create_field',
+                description: 'Add a new field to an existing table',
+                inputSchema: {
+                  type: 'object',
+                  properties: {
+                    table: { type: 'string', description: 'Table name or ID' },
+                    name: { type: 'string', description: 'Field name' },
+                    type: { type: 'string', description: 'Field type (singleLineText, number, multipleSelectionList, etc.)' },
+                    description: { type: 'string', description: 'Field description' },
+                    options: { type: 'object', description: 'Field-specific options (e.g., choices for select fields)' }
+                  },
+                  required: ['table', 'name', 'type']
+                }
+              },
+              {
+                name: 'update_field',
+                description: 'Update field properties',
+                inputSchema: {
+                  type: 'object',
+                  properties: {
+                    table: { type: 'string', description: 'Table name or ID' },
+                    fieldId: { type: 'string', description: 'Field ID to update' },
+                    name: { type: 'string', description: 'New field name' },
+                    description: { type: 'string', description: 'New field description' },
+                    options: { type: 'object', description: 'Updated field options' }
+                  },
+                  required: ['table', 'fieldId']
+                }
+              },
+              {
+                name: 'delete_field',
+                description: 'Delete a field from a table (WARNING: This will permanently delete all data in this field)',
+                inputSchema: {
+                  type: 'object',
+                  properties: {
+                    table: { type: 'string', description: 'Table name or ID' },
+                    fieldId: { type: 'string', description: 'Field ID to delete' },
+                    confirm: { type: 'boolean', description: 'Must be true to confirm deletion' }
+                  },
+                  required: ['table', 'fieldId', 'confirm']
+                }
+              },
+              {
+                name: 'list_field_types',
+                description: 'Get a reference of all available Airtable field types and their schemas',
+                inputSchema: {
+                  type: 'object',
+                  properties: {}
+                }
+              },
+              {
+                name: 'get_table_views',
+                description: 'List all views for a specific table',
+                inputSchema: {
+                  type: 'object',
+                  properties: {
+                    table: { type: 'string', description: 'Table name or ID' }
+                  },
+                  required: ['table']
+                }
+              }
+            ]
+          }
+        };
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(response));
+        return;
+      }
+      
       if (request.method === 'resources/list') {
         const response = {
           jsonrpc: '2.0',
@@ -129,15 +513,525 @@ const server = http.createServer(async (req, res) => {
       // Handle tool calls
       if (request.method === 'tools/call') {
         const toolName = request.params.name;
+        const toolParams = request.params.arguments || {};
+        
+        let result;
+        let responseText;
         
-        if (toolName === 'list_tables') {
-          // Call Airtable API to list tables
-          const result = await callAirtableAPI(`meta/bases/${baseId}/tables`);
-          const tables = result.tables || [];
+        try {
+          // LIST TABLES
+          if (toolName === 'list_tables') {
+            result = await callAirtableAPI(`meta/bases/${baseId}/tables`);
+            const tables = result.tables || [];
+            
+            responseText = tables.length > 0 
+              ? `Found ${tables.length} table(s):\n` + tables.map((table, i) => 
+                  `${i+1}. ${table.name} (ID: ${table.id}, Fields: ${table.fields?.length || 0})`
+                ).join('\n')
+              : 'No tables found in this base.';
+          }
+          
+          // LIST RECORDS
+          else if (toolName === 'list_records') {
+            const { table, maxRecords, view } = toolParams;
+            
+            const queryParams = {};
+            if (maxRecords) queryParams.maxRecords = maxRecords;
+            if (view) queryParams.view = view;
+            
+            result = await callAirtableAPI(`${table}`, 'GET', null, queryParams);
+            const records = result.records || [];
+            
+            responseText = records.length > 0
+              ? `Found ${records.length} record(s) in table "${table}":\n` + 
+                records.map((record, i) => 
+                  `${i+1}. ID: ${record.id}\n   Fields: ${JSON.stringify(record.fields, null, 2)}`
+                ).join('\n\n')
+              : `No records found in table "${table}".`;
+          }
+          
+          // GET SINGLE RECORD
+          else if (toolName === 'get_record') {
+            const { table, recordId } = toolParams;
+            
+            result = await callAirtableAPI(`${table}/${recordId}`);
+            
+            responseText = `Record ${recordId} from table "${table}":\n` + 
+              JSON.stringify(result.fields, null, 2) +
+              `\n\nCreated: ${result.createdTime}`;
+          }
+          
+          // CREATE RECORD
+          else if (toolName === 'create_record') {
+            const { table, fields } = toolParams;
+            
+            const body = {
+              fields: fields
+            };
+            
+            result = await callAirtableAPI(table, 'POST', body);
+            
+            responseText = `Successfully created record in table "${table}":\n` +
+              `Record ID: ${result.id}\n` +
+              `Fields: ${JSON.stringify(result.fields, null, 2)}\n` +
+              `Created at: ${result.createdTime}`;
+          }
+          
+          // UPDATE RECORD
+          else if (toolName === 'update_record') {
+            const { table, recordId, fields } = toolParams;
+            
+            const body = {
+              fields: fields
+            };
+            
+            result = await callAirtableAPI(`${table}/${recordId}`, 'PATCH', body);
+            
+            responseText = `Successfully updated record ${recordId} in table "${table}":\n` +
+              `Updated fields: ${JSON.stringify(result.fields, null, 2)}`;
+          }
+          
+          // DELETE RECORD
+          else if (toolName === 'delete_record') {
+            const { table, recordId } = toolParams;
+            
+            result = await callAirtableAPI(`${table}/${recordId}`, 'DELETE');
+            
+            responseText = `Successfully deleted record ${recordId} from table "${table}".\n` +
+              `Deleted record ID: ${result.id}\n` +
+              `Deleted: ${result.deleted}`;
+          }
+          
+          // SEARCH RECORDS
+          else if (toolName === 'search_records') {
+            const { table, filterByFormula, sort, maxRecords, fields } = toolParams;
+            
+            const queryParams = {};
+            if (filterByFormula) queryParams.filterByFormula = filterByFormula;
+            if (maxRecords) queryParams.maxRecords = maxRecords;
+            if (fields && fields.length > 0) queryParams.fields = fields;
+            if (sort && sort.length > 0) {
+              sort.forEach((s, i) => {
+                queryParams[`sort[${i}][field]`] = s.field;
+                queryParams[`sort[${i}][direction]`] = s.direction || 'asc';
+              });
+            }
+            
+            result = await callAirtableAPI(table, 'GET', null, queryParams);
+            const records = result.records || [];
+            
+            responseText = records.length > 0
+              ? `Found ${records.length} matching record(s) in table "${table}":\n` + 
+                records.map((record, i) => 
+                  `${i+1}. ID: ${record.id}\n   Fields: ${JSON.stringify(record.fields, null, 2)}`
+                ).join('\n\n')
+              : `No records found matching the search criteria in table "${table}".`;
+          }
+          
+          // LIST WEBHOOKS
+          else if (toolName === 'list_webhooks') {
+            result = await callAirtableAPI(`bases/${baseId}/webhooks`, 'GET');
+            const webhooks = result.webhooks || [];
+            
+            responseText = webhooks.length > 0
+              ? `Found ${webhooks.length} webhook(s):\n` + 
+                webhooks.map((webhook, i) => 
+                  `${i+1}. ID: ${webhook.id}\n` +
+                  `   URL: ${webhook.notificationUrl}\n` +
+                  `   Active: ${webhook.isHookEnabled}\n` +
+                  `   Created: ${webhook.createdTime}\n` +
+                  `   Expires: ${webhook.expirationTime}`
+                ).join('\n\n')
+              : 'No webhooks configured for this base.';
+          }
+          
+          // CREATE WEBHOOK
+          else if (toolName === 'create_webhook') {
+            const { notificationUrl, specification } = toolParams;
+            
+            const body = {
+              notificationUrl: notificationUrl,
+              specification: specification || {
+                options: {
+                  filters: {
+                    dataTypes: ['tableData']
+                  }
+                }
+              }
+            };
+            
+            result = await callAirtableAPI(`bases/${baseId}/webhooks`, 'POST', body);
+            
+            responseText = `Successfully created webhook:\n` +
+              `Webhook ID: ${result.id}\n` +
+              `URL: ${result.notificationUrl}\n` +
+              `MAC Secret: ${result.macSecretBase64}\n` +
+              `Expiration: ${result.expirationTime}\n` +
+              `Cursor: ${result.cursorForNextPayload}\n\n` +
+              `⚠️ IMPORTANT: Save the MAC secret - it won't be shown again!`;
+          }
+          
+          // DELETE WEBHOOK
+          else if (toolName === 'delete_webhook') {
+            const { webhookId } = toolParams;
+            
+            await callAirtableAPI(`bases/${baseId}/webhooks/${webhookId}`, 'DELETE');
+            
+            responseText = `Successfully deleted webhook ${webhookId}`;
+          }
+          
+          // GET WEBHOOK PAYLOADS
+          else if (toolName === 'get_webhook_payloads') {
+            const { webhookId, cursor } = toolParams;
+            
+            const queryParams = {};
+            if (cursor) queryParams.cursor = cursor;
+            
+            result = await callAirtableAPI(`bases/${baseId}/webhooks/${webhookId}/payloads`, 'GET', null, queryParams);
+            
+            const payloads = result.payloads || [];
+            responseText = payloads.length > 0
+              ? `Found ${payloads.length} webhook payload(s):\n` + 
+                payloads.map((payload, i) => 
+                  `${i+1}. Timestamp: ${payload.timestamp}\n` +
+                  `   Base/Table: ${payload.baseTransactionNumber}\n` +
+                  `   Change Types: ${JSON.stringify(payload.changePayload?.changedTablesById || {})}`
+                ).join('\n\n') +
+                (result.cursor ? `\n\nNext cursor: ${result.cursor}` : '')
+              : 'No payloads found for this webhook.';
+          }
+          
+          // REFRESH WEBHOOK
+          else if (toolName === 'refresh_webhook') {
+            const { webhookId } = toolParams;
+            
+            result = await callAirtableAPI(`bases/${baseId}/webhooks/${webhookId}/refresh`, 'POST');
+            
+            responseText = `Successfully refreshed webhook ${webhookId}:\n` +
+              `New expiration: ${result.expirationTime}`;
+          }
+          
+          // Schema Management Tools
+          else if (toolName === 'list_bases') {
+            const { offset } = toolParams;
+            const queryParams = offset ? { offset } : {};
+            
+            result = await callAirtableAPI('meta/bases', 'GET', null, queryParams);
+            
+            if (result.bases && result.bases.length > 0) {
+              responseText = `Found ${result.bases.length} accessible base(s):\n`;
+              result.bases.forEach((base, index) => {
+                responseText += `${index + 1}. ${base.name} (ID: ${base.id})\n`;
+                if (base.permissionLevel) {
+                  responseText += `   Permission: ${base.permissionLevel}\n`;
+                }
+              });
+              if (result.offset) {
+                responseText += `\nNext page offset: ${result.offset}`;
+              }
+            } else {
+              responseText = 'No accessible bases found.';
+            }
+          }
+          
+          else if (toolName === 'get_base_schema') {
+            const { baseId: targetBaseId } = toolParams;
+            const targetId = targetBaseId || baseId;
+            
+            result = await callAirtableAPI(`meta/bases/${targetId}/tables`, 'GET');
+            
+            if (result.tables && result.tables.length > 0) {
+              responseText = `Base schema for ${targetId}:\n\n`;
+              result.tables.forEach((table, index) => {
+                responseText += `${index + 1}. Table: ${table.name} (ID: ${table.id})\n`;
+                if (table.description) {
+                  responseText += `   Description: ${table.description}\n`;
+                }
+                responseText += `   Fields (${table.fields.length}):\n`;
+                table.fields.forEach((field, fieldIndex) => {
+                  responseText += `   ${fieldIndex + 1}. ${field.name} (${field.type})\n`;
+                  if (field.description) {
+                    responseText += `      Description: ${field.description}\n`;
+                  }
+                });
+                if (table.views && table.views.length > 0) {
+                  responseText += `   Views (${table.views.length}): ${table.views.map(v => v.name).join(', ')}\n`;
+                }
+                responseText += '\n';
+              });
+            } else {
+              responseText = 'No tables found in this base.';
+            }
+          }
+          
+          else if (toolName === 'describe_table') {
+            const { table } = toolParams;
+            
+            // Get table schema first
+            const schemaResult = await callAirtableAPI(`meta/bases/${baseId}/tables`, 'GET');
+            const tableInfo = schemaResult.tables.find(t => 
+              t.name.toLowerCase() === table.toLowerCase() || t.id === table
+            );
+            
+            if (!tableInfo) {
+              responseText = `Table "${table}" not found.`;
+            } else {
+              responseText = `Table Details: ${tableInfo.name}\n`;
+              responseText += `ID: ${tableInfo.id}\n`;
+              if (tableInfo.description) {
+                responseText += `Description: ${tableInfo.description}\n`;
+              }
+              responseText += `\nFields (${tableInfo.fields.length}):\n`;
+              
+              tableInfo.fields.forEach((field, index) => {
+                responseText += `${index + 1}. ${field.name}\n`;
+                responseText += `   Type: ${field.type}\n`;
+                responseText += `   ID: ${field.id}\n`;
+                if (field.description) {
+                  responseText += `   Description: ${field.description}\n`;
+                }
+                if (field.options) {
+                  responseText += `   Options: ${JSON.stringify(field.options, null, 2)}\n`;
+                }
+                responseText += '\n';
+              });
+              
+              if (tableInfo.views && tableInfo.views.length > 0) {
+                responseText += `Views (${tableInfo.views.length}):\n`;
+                tableInfo.views.forEach((view, index) => {
+                  responseText += `${index + 1}. ${view.name} (${view.type})\n`;
+                });
+              }
+            }
+          }
+          
+          else if (toolName === 'create_table') {
+            const { name, description, fields } = toolParams;
+            
+            const body = {
+              name,
+              fields: fields.map(field => ({
+                name: field.name,
+                type: field.type,
+                description: field.description,
+                options: field.options
+              }))
+            };
+            
+            if (description) {
+              body.description = description;
+            }
+            
+            result = await callAirtableAPI(`meta/bases/${baseId}/tables`, 'POST', body);
+            
+            responseText = `Successfully created table "${name}" (ID: ${result.id})\n`;
+            responseText += `Fields created: ${result.fields.length}\n`;
+            result.fields.forEach((field, index) => {
+              responseText += `${index + 1}. ${field.name} (${field.type})\n`;
+            });
+          }
           
-          const tableList = tables.map((table, i) => 
-            `${i+1}. ${table.name} (ID: ${table.id})`
-          ).join('\n');
+          else if (toolName === 'update_table') {
+            const { table, name, description } = toolParams;
+            
+            // Get table ID first
+            const schemaResult = await callAirtableAPI(`meta/bases/${baseId}/tables`, 'GET');
+            const tableInfo = schemaResult.tables.find(t => 
+              t.name.toLowerCase() === table.toLowerCase() || t.id === table
+            );
+            
+            if (!tableInfo) {
+              responseText = `Table "${table}" not found.`;
+            } else {
+              const body = {};
+              if (name) body.name = name;
+              if (description !== undefined) body.description = description;
+              
+              if (Object.keys(body).length === 0) {
+                responseText = 'No updates specified. Provide name or description to update.';
+              } else {
+                result = await callAirtableAPI(`meta/bases/${baseId}/tables/${tableInfo.id}`, 'PATCH', body);
+                responseText = `Successfully updated table "${tableInfo.name}":\n`;
+                if (name) responseText += `New name: ${result.name}\n`;
+                if (description !== undefined) responseText += `New description: ${result.description || '(none)'}\n`;
+              }
+            }
+          }
+          
+          else if (toolName === 'delete_table') {
+            const { table, confirm } = toolParams;
+            
+            if (!confirm) {
+              responseText = 'Table deletion requires confirm=true to proceed. This action cannot be undone!';
+            } else {
+              // Get table ID first
+              const schemaResult = await callAirtableAPI(`meta/bases/${baseId}/tables`, 'GET');
+              const tableInfo = schemaResult.tables.find(t => 
+                t.name.toLowerCase() === table.toLowerCase() || t.id === table
+              );
+              
+              if (!tableInfo) {
+                responseText = `Table "${table}" not found.`;
+              } else {
+                result = await callAirtableAPI(`meta/bases/${baseId}/tables/${tableInfo.id}`, 'DELETE');
+                responseText = `Successfully deleted table "${tableInfo.name}" (ID: ${tableInfo.id})\n`;
+                responseText += 'All data in this table has been permanently removed.';
+              }
+            }
+          }
+          
+          // Field Management Tools
+          else if (toolName === 'create_field') {
+            const { table, name, type, description, options } = toolParams;
+            
+            // Get table ID first
+            const schemaResult = await callAirtableAPI(`meta/bases/${baseId}/tables`, 'GET');
+            const tableInfo = schemaResult.tables.find(t => 
+              t.name.toLowerCase() === table.toLowerCase() || t.id === table
+            );
+            
+            if (!tableInfo) {
+              responseText = `Table "${table}" not found.`;
+            } else {
+              const body = {
+                name,
+                type
+              };
+              
+              if (description) body.description = description;
+              if (options) body.options = options;
+              
+              result = await callAirtableAPI(`meta/bases/${baseId}/tables/${tableInfo.id}/fields`, 'POST', body);
+              
+              responseText = `Successfully created field "${name}" in table "${tableInfo.name}"\n`;
+              responseText += `Field ID: ${result.id}\n`;
+              responseText += `Type: ${result.type}\n`;
+              if (result.description) {
+                responseText += `Description: ${result.description}\n`;
+              }
+            }
+          }
+          
+          else if (toolName === 'update_field') {
+            const { table, fieldId, name, description, options } = toolParams;
+            
+            // Get table ID first
+            const schemaResult = await callAirtableAPI(`meta/bases/${baseId}/tables`, 'GET');
+            const tableInfo = schemaResult.tables.find(t => 
+              t.name.toLowerCase() === table.toLowerCase() || t.id === table
+            );
+            
+            if (!tableInfo) {
+              responseText = `Table "${table}" not found.`;
+            } else {
+              const body = {};
+              if (name) body.name = name;
+              if (description !== undefined) body.description = description;
+              if (options) body.options = options;
+              
+              if (Object.keys(body).length === 0) {
+                responseText = 'No updates specified. Provide name, description, or options to update.';
+              } else {
+                result = await callAirtableAPI(`meta/bases/${baseId}/tables/${tableInfo.id}/fields/${fieldId}`, 'PATCH', body);
+                responseText = `Successfully updated field in table "${tableInfo.name}":\n`;
+                responseText += `Field: ${result.name} (${result.type})\n`;
+                responseText += `ID: ${result.id}\n`;
+                if (result.description) {
+                  responseText += `Description: ${result.description}\n`;
+                }
+              }
+            }
+          }
+          
+          else if (toolName === 'delete_field') {
+            const { table, fieldId, confirm } = toolParams;
+            
+            if (!confirm) {
+              responseText = 'Field deletion requires confirm=true to proceed. This action cannot be undone!';
+            } else {
+              // Get table ID first
+              const schemaResult = await callAirtableAPI(`meta/bases/${baseId}/tables`, 'GET');
+              const tableInfo = schemaResult.tables.find(t => 
+                t.name.toLowerCase() === table.toLowerCase() || t.id === table
+              );
+              
+              if (!tableInfo) {
+                responseText = `Table "${table}" not found.`;
+              } else {
+                result = await callAirtableAPI(`meta/bases/${baseId}/tables/${tableInfo.id}/fields/${fieldId}`, 'DELETE');
+                responseText = `Successfully deleted field from table "${tableInfo.name}"\n`;
+                responseText += 'All data in this field has been permanently removed.';
+              }
+            }
+          }
+          
+          else if (toolName === 'list_field_types') {
+            responseText = `Available Airtable Field Types:\n\n`;
+            responseText += `Basic Fields:\n`;
+            responseText += `• singleLineText - Single line text input\n`;
+            responseText += `• multilineText - Multi-line text input\n`;
+            responseText += `• richText - Rich text with formatting\n`;
+            responseText += `• number - Number field with optional formatting\n`;
+            responseText += `• percent - Percentage field\n`;
+            responseText += `• currency - Currency field\n`;
+            responseText += `• singleSelect - Single choice from predefined options\n`;
+            responseText += `• multipleSelectionList - Multiple choices from predefined options\n`;
+            responseText += `• date - Date field\n`;
+            responseText += `• dateTime - Date and time field\n`;
+            responseText += `• phoneNumber - Phone number field\n`;
+            responseText += `• email - Email address field\n`;
+            responseText += `• url - URL field\n`;
+            responseText += `• checkbox - Checkbox (true/false)\n`;
+            responseText += `• rating - Star rating field\n`;
+            responseText += `• duration - Duration/time field\n\n`;
+            responseText += `Advanced Fields:\n`;
+            responseText += `• multipleAttachment - File attachments\n`;
+            responseText += `• linkedRecord - Link to records in another table\n`;
+            responseText += `• lookup - Lookup values from linked records\n`;
+            responseText += `• rollup - Calculate values from linked records\n`;
+            responseText += `• count - Count of linked records\n`;
+            responseText += `• formula - Calculated field with formulas\n`;
+            responseText += `• createdTime - Auto-timestamp when record created\n`;
+            responseText += `• createdBy - Auto-user who created record\n`;
+            responseText += `• lastModifiedTime - Auto-timestamp when record modified\n`;
+            responseText += `• lastModifiedBy - Auto-user who last modified record\n`;
+            responseText += `• autoNumber - Auto-incrementing number\n`;
+            responseText += `• barcode - Barcode/QR code field\n`;
+            responseText += `• button - Action button field\n`;
+          }
+          
+          else if (toolName === 'get_table_views') {
+            const { table } = toolParams;
+            
+            // Get table schema
+            const schemaResult = await callAirtableAPI(`meta/bases/${baseId}/tables`, 'GET');
+            const tableInfo = schemaResult.tables.find(t => 
+              t.name.toLowerCase() === table.toLowerCase() || t.id === table
+            );
+            
+            if (!tableInfo) {
+              responseText = `Table "${table}" not found.`;
+            } else {
+              if (tableInfo.views && tableInfo.views.length > 0) {
+                responseText = `Views for table "${tableInfo.name}" (${tableInfo.views.length}):\n\n`;
+                tableInfo.views.forEach((view, index) => {
+                  responseText += `${index + 1}. ${view.name}\n`;
+                  responseText += `   Type: ${view.type}\n`;
+                  responseText += `   ID: ${view.id}\n`;
+                  if (view.visibleFieldIds && view.visibleFieldIds.length > 0) {
+                    responseText += `   Visible fields: ${view.visibleFieldIds.length}\n`;
+                  }
+                  responseText += '\n';
+                });
+              } else {
+                responseText = `No views found for table "${tableInfo.name}".`;
+              }
+            }
+          }
+          
+          else {
+            throw new Error(`Unknown tool: ${toolName}`);
+          }
           
           const response = {
             jsonrpc: '2.0',
@@ -146,33 +1040,16 @@ const server = http.createServer(async (req, res) => {
               content: [
                 {
                   type: 'text',
-                  text: tables.length > 0 
-                    ? `Tables in this base:\n${tableList}` 
-                    : 'No tables found in this base.'
+                  text: responseText
                 }
               ]
             }
           };
-          
           res.writeHead(200, { 'Content-Type': 'application/json' });
           res.end(JSON.stringify(response));
-          return;
-        }
-        
-        if (toolName === 'list_records') {
-          const tableName = request.params.arguments.table_name;
-          const maxRecords = request.params.arguments.max_records || 100;
-          
-          // Call Airtable API to list records
-          const result = await callAirtableAPI(`${baseId}/${tableName}`, { maxRecords });
-          const records = result.records || [];
           
-          const recordList = records.map((record, i) => {
-            const fields = Object.entries(record.fields || {})
-              .map(([k, v]) => `${k}: ${v}`)
-              .join(', ');
-            return `${i+1}. ID: ${record.id} - ${fields}`;
-          }).join('\n');
+        } catch (error) {
+          log(LOG_LEVELS.ERROR, `Tool ${toolName} error:`, error.message);
           
           const response = {
             jsonrpc: '2.0',
@@ -181,30 +1058,15 @@ const server = http.createServer(async (req, res) => {
               content: [
                 {
                   type: 'text',
-                  text: records.length > 0 
-                    ? `Records:\n${recordList}` 
-                    : 'No records found in this table.'
+                  text: `Error executing ${toolName}: ${error.message}`
                 }
               ]
             }
           };
-          
           res.writeHead(200, { 'Content-Type': 'application/json' });
           res.end(JSON.stringify(response));
-          return;
         }
         
-        // Tool not found
-        const response = {
-          jsonrpc: '2.0',
-          id: request.id,
-          error: {
-            code: -32601,
-            message: `Tool ${toolName} not found`
-          }
-        };
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify(response));
         return;
       }
       
@@ -221,7 +1083,7 @@ const server = http.createServer(async (req, res) => {
       res.end(JSON.stringify(response));
       
     } catch (error) {
-      console.error('Error processing request:', error);
+      log(LOG_LEVELS.ERROR, 'Error processing request:', error);
       const response = {
         jsonrpc: '2.0',
         id: request.id || null,
@@ -236,42 +1098,18 @@ const server = http.createServer(async (req, res) => {
   });
 });
 
-// Helper function to call Airtable API
-function callAirtableAPI(endpoint, params = {}) {
-  return new Promise((resolve, reject) => {
-    const queryParams = new URLSearchParams(params).toString();
-    const url = `https://api.airtable.com/v0/${endpoint}${queryParams ? '?' + queryParams : ''}`;
-    
-    const options = {
-      headers: {
-        'Authorization': `Bearer ${token}`,
-        'Content-Type': 'application/json'
-      }
-    };
-    
-    https.get(url, options, (response) => {
-      let data = '';
-      
-      response.on('data', (chunk) => {
-        data += chunk;
-      });
-      
-      response.on('end', () => {
-        try {
-          resolve(JSON.parse(data));
-        } catch (e) {
-          reject(new Error(`Failed to parse Airtable response: ${e.message}`));
-        }
-      });
-    }).on('error', (error) => {
-      reject(new Error(`Airtable API request failed: ${error.message}`));
-    });
-  });
-}
-
-// Start the server on port 8010
-const PORT = 8010;
+// Start server
+const PORT = process.env.PORT || 8010;
 server.listen(PORT, () => {
-  console.log(`Airtable MCP server running at http://localhost:${PORT}/mcp`);
+  log(LOG_LEVELS.INFO, `Enhanced Airtable MCP server v1.4.0 running at http://localhost:${PORT}/mcp`);
   console.log(`For Claude, use this URL: http://localhost:${PORT}/mcp`);
-}); 
+});
+
+// Graceful shutdown
+process.on('SIGINT', () => {
+  log(LOG_LEVELS.INFO, 'Shutting down server...');
+  server.close(() => {
+    log(LOG_LEVELS.INFO, 'Server stopped');
+    process.exit(0);
+  });
+});