@rashidazarang/airtable-mcp 1.2.0

package/bin/airtable-crud-cli.js

@@ -0,0 +1,445 @@
+#!/usr/bin/env node
+
+/**
+ * Command-line interface for Airtable CRUD operations
+ */
+const fs = require('fs');
+const path = require('path');
+const dotenv = require('dotenv');
+const baseUtils = require('../tools/airtable-base');
+const crudUtils = require('../tools/airtable-crud');
+const schemaUtils = require('../tools/airtable-schema');
+
+// Load environment variables
+dotenv.config();
+
+// Get the base ID from environment variables
+const baseId = process.env.AIRTABLE_BASE_ID;
+if (!baseId) {
+  console.error('Error: AIRTABLE_BASE_ID not set in .env file');
+  process.exit(1);
+}
+
+// Parse command line arguments
+const args = process.argv.slice(2);
+const command = args[0];
+
+// Display help if no command is provided
+if (!command) {
+  showHelp();
+  process.exit(0);
+}
+
+// Process the command
+processCommand(command, args.slice(1))
+  .then(() => {
+    console.log('Command completed successfully');
+  })
+  .catch(error => {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  });
+
+/**
+ * Process the command
+ * @param {string} command - The command to process
+ * @param {Array} args - The command arguments
+ */
+async function processCommand(command, args) {
+  switch (command) {
+    case 'list-bases':
+      await listBases();
+      break;
+    
+    case 'list-tables':
+      await listTables();
+      break;
+    
+    case 'list-records':
+      await listRecords(args);
+      break;
+    
+    case 'get-record':
+      await getRecord(args);
+      break;
+    
+    case 'create-records':
+      await createRecords(args);
+      break;
+    
+    case 'update-records':
+      await updateRecords(args);
+      break;
+    
+    case 'delete-records':
+      await deleteRecords(args);
+      break;
+    
+    case 'export-records':
+      await exportRecords(args);
+      break;
+    
+    case 'import-records':
+      await importRecords(args);
+      break;
+    
+    case 'help':
+      showHelp();
+      break;
+    
+    default:
+      console.error(`Unknown command: ${command}`);
+      showHelp();
+      process.exit(1);
+  }
+}
+
+/**
+ * List all accessible bases
+ */
+async function listBases() {
+  console.log('Listing accessible bases...');
+  const bases = await baseUtils.listAllBases();
+  
+  console.log(`Found ${bases.length} accessible bases:`);
+  bases.forEach(base => {
+    console.log(`- ${base.name} (${base.id})`);
+  });
+}
+
+/**
+ * List all tables in the base
+ */
+async function listTables() {
+  console.log(`Listing tables in base ${baseId}...`);
+  const tables = await baseUtils.listTables(baseId);
+  
+  console.log(`Found ${tables.length} tables:`);
+  tables.forEach(table => {
+    console.log(`- ${table.name} (${table.id})`);
+  });
+}
+
+/**
+ * List records from a table
+ * @param {Array} args - Command arguments
+ */
+async function listRecords(args) {
+  if (args.length < 1) {
+    console.error('Error: Table name is required');
+    console.log('Usage: node airtable-crud-cli.js list-records <tableName> [maxRecords] [filterFormula]');
+    process.exit(1);
+  }
+  
+  const tableName = args[0];
+  const maxRecords = args[1] ? parseInt(args[1]) : 100;
+  const filterFormula = args[2] || null;
+  
+  console.log(`Listing records from table "${tableName}"...`);
+  console.log(`Max records: ${maxRecords}`);
+  if (filterFormula) {
+    console.log(`Filter: ${filterFormula}`);
+  }
+  
+  const records = await crudUtils.readRecords(baseId, tableName, maxRecords, filterFormula);
+  
+  console.log(`Found ${records.length} records:`);
+  records.forEach(record => {
+    console.log(`- ${record.id}: ${JSON.stringify(record)}`);
+  });
+}
+
+/**
+ * Get a specific record by ID
+ * @param {Array} args - Command arguments
+ */
+async function getRecord(args) {
+  if (args.length < 2) {
+    console.error('Error: Table name and record ID are required');
+    console.log('Usage: node airtable-crud-cli.js get-record <tableName> <recordId>');
+    process.exit(1);
+  }
+  
+  const tableName = args[0];
+  const recordId = args[1];
+  
+  console.log(`Getting record ${recordId} from table "${tableName}"...`);
+  
+  const record = await crudUtils.getRecord(baseId, tableName, recordId);
+  
+  console.log('Record:');
+  console.log(JSON.stringify(record, null, 2));
+}
+
+/**
+ * Create records in a table
+ * @param {Array} args - Command arguments
+ */
+async function createRecords(args) {
+  if (args.length < 2) {
+    console.error('Error: Table name and JSON file are required');
+    console.log('Usage: node airtable-crud-cli.js create-records <tableName> <jsonFile>');
+    process.exit(1);
+  }
+  
+  const tableName = args[0];
+  const jsonFile = args[1];
+  
+  // Read the JSON file
+  let records;
+  try {
+    const jsonData = fs.readFileSync(jsonFile, 'utf8');
+    records = JSON.parse(jsonData);
+    
+    if (!Array.isArray(records)) {
+      console.error('Error: JSON file must contain an array of records');
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(`Error reading JSON file: ${error.message}`);
+    process.exit(1);
+  }
+  
+  console.log(`Creating ${records.length} records in table "${tableName}"...`);
+  
+  const createdRecords = await crudUtils.createRecords(baseId, tableName, records);
+  
+  console.log(`Created ${createdRecords.length} records`);
+  console.log('First record:');
+  console.log(JSON.stringify(createdRecords[0], null, 2));
+}
+
+/**
+ * Update records in a table
+ * @param {Array} args - Command arguments
+ */
+async function updateRecords(args) {
+  if (args.length < 2) {
+    console.error('Error: Table name and JSON file are required');
+    console.log('Usage: node airtable-crud-cli.js update-records <tableName> <jsonFile>');
+    process.exit(1);
+  }
+  
+  const tableName = args[0];
+  const jsonFile = args[1];
+  
+  // Read the JSON file
+  let records;
+  try {
+    const jsonData = fs.readFileSync(jsonFile, 'utf8');
+    records = JSON.parse(jsonData);
+    
+    if (!Array.isArray(records)) {
+      console.error('Error: JSON file must contain an array of records');
+      process.exit(1);
+    }
+    
+    // Check if records have id and fields
+    for (const record of records) {
+      if (!record.id) {
+        console.error('Error: Each record must have an id field');
+        process.exit(1);
+      }
+      
+      if (!record.fields || typeof record.fields !== 'object') {
+        console.error('Error: Each record must have a fields object');
+        process.exit(1);
+      }
+    }
+  } catch (error) {
+    console.error(`Error reading JSON file: ${error.message}`);
+    process.exit(1);
+  }
+  
+  console.log(`Updating ${records.length} records in table "${tableName}"...`);
+  
+  const updatedRecords = await crudUtils.updateRecords(baseId, tableName, records);
+  
+  console.log(`Updated ${updatedRecords.length} records`);
+  console.log('First record:');
+  console.log(JSON.stringify(updatedRecords[0], null, 2));
+}
+
+/**
+ * Delete records from a table
+ * @param {Array} args - Command arguments
+ */
+async function deleteRecords(args) {
+  if (args.length < 2) {
+    console.error('Error: Table name and record IDs are required');
+    console.log('Usage: node airtable-crud-cli.js delete-records <tableName> <recordId1,recordId2,...>');
+    process.exit(1);
+  }
+  
+  const tableName = args[0];
+  const recordIds = args[1].split(',');
+  
+  console.log(`Deleting ${recordIds.length} records from table "${tableName}"...`);
+  
+  const deletedRecords = await crudUtils.deleteRecords(baseId, tableName, recordIds);
+  
+  console.log(`Deleted ${deletedRecords.length} records`);
+}
+
+/**
+ * Export records from a table to a JSON file
+ * @param {Array} args - Command arguments
+ */
+async function exportRecords(args) {
+  if (args.length < 2) {
+    console.error('Error: Table name and output file are required');
+    console.log('Usage: node airtable-crud-cli.js export-records <tableName> <outputFile> [maxRecords] [filterFormula]');
+    process.exit(1);
+  }
+  
+  const tableName = args[0];
+  const outputFile = args[1];
+  const maxRecords = args[2] ? parseInt(args[2]) : 100;
+  const filterFormula = args[3] || null;
+  
+  console.log(`Exporting records from table "${tableName}" to ${outputFile}...`);
+  console.log(`Max records: ${maxRecords}`);
+  if (filterFormula) {
+    console.log(`Filter: ${filterFormula}`);
+  }
+  
+  const records = await crudUtils.readRecords(baseId, tableName, maxRecords, filterFormula);
+  
+  // Write records to file
+  try {
+    fs.writeFileSync(outputFile, JSON.stringify(records, null, 2));
+    console.log(`Exported ${records.length} records to ${outputFile}`);
+  } catch (error) {
+    console.error(`Error writing to file: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Import records from a JSON file to a table
+ * @param {Array} args - Command arguments
+ */
+async function importRecords(args) {
+  if (args.length < 2) {
+    console.error('Error: Table name and input file are required');
+    console.log('Usage: node airtable-crud-cli.js import-records <tableName> <inputFile> [--update] [--clear]');
+    process.exit(1);
+  }
+  
+  const tableName = args[0];
+  const inputFile = args[1];
+  const update = args.includes('--update');
+  const clear = args.includes('--clear');
+  
+  // Read the JSON file
+  let records;
+  try {
+    const jsonData = fs.readFileSync(inputFile, 'utf8');
+    records = JSON.parse(jsonData);
+    
+    if (!Array.isArray(records)) {
+      console.error('Error: JSON file must contain an array of records');
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(`Error reading JSON file: ${error.message}`);
+    process.exit(1);
+  }
+  
+  console.log(`Importing ${records.length} records to table "${tableName}"...`);
+  
+  // Clear the table if requested
+  if (clear) {
+    console.log('Clearing existing records...');
+    const existingRecords = await crudUtils.readRecords(baseId, tableName, 100000);
+    
+    if (existingRecords.length > 0) {
+      const recordIds = existingRecords.map(record => record.id);
+      await crudUtils.deleteRecords(baseId, tableName, recordIds);
+      console.log(`Deleted ${existingRecords.length} existing records`);
+    }
+  }
+  
+  // Update existing records if requested
+  if (update) {
+    console.log('Updating existing records...');
+    
+    // Get existing records
+    const existingRecords = await crudUtils.readRecords(baseId, tableName, 100000);
+    const existingRecordsMap = {};
+    
+    // Create a map of existing records by a key field (assuming 'Name' is the key)
+    existingRecords.forEach(record => {
+      if (record.Name) {
+        existingRecordsMap[record.Name] = record;
+      }
+    });
+    
+    // Separate records to update and create
+    const recordsToUpdate = [];
+    const recordsToCreate = [];
+    
+    records.forEach(record => {
+      if (record.Name && existingRecordsMap[record.Name]) {
+        // Record exists, update it
+        recordsToUpdate.push({
+          id: existingRecordsMap[record.Name].id,
+          fields: record
+        });
+      } else {
+        // Record doesn't exist, create it
+        recordsToCreate.push(record);
+      }
+    });
+    
+    // Update existing records
+    if (recordsToUpdate.length > 0) {
+      const updatedRecords = await crudUtils.updateRecords(baseId, tableName, recordsToUpdate);
+      console.log(`Updated ${updatedRecords.length} existing records`);
+    }
+    
+    // Create new records
+    if (recordsToCreate.length > 0) {
+      const createdRecords = await crudUtils.createRecords(baseId, tableName, recordsToCreate);
+      console.log(`Created ${createdRecords.length} new records`);
+    }
+  } else {
+    // Create all records
+    const createdRecords = await crudUtils.createRecords(baseId, tableName, records);
+    console.log(`Created ${createdRecords.length} records`);
+  }
+}
+
+/**
+ * Show help
+ */
+function showHelp() {
+  console.log('Airtable CRUD CLI');
+  console.log('================');
+  console.log('');
+  console.log('Usage: node airtable-crud-cli.js <command> [options]');
+  console.log('');
+  console.log('Commands:');
+  console.log('  list-bases                                  List all accessible bases');
+  console.log('  list-tables                                 List all tables in the base');
+  console.log('  list-records <tableName> [max] [filter]     List records from a table');
+  console.log('  get-record <tableName> <recordId>           Get a specific record');
+  console.log('  create-records <tableName> <jsonFile>       Create records from a JSON file');
+  console.log('  update-records <tableName> <jsonFile>       Update records from a JSON file');
+  console.log('  delete-records <tableName> <id1,id2,...>    Delete records from a table');
+  console.log('  export-records <tableName> <file> [max]     Export records to a JSON file');
+  console.log('  import-records <tableName> <file> [flags]   Import records from a JSON file');
+  console.log('  help                                        Show this help');
+  console.log('');
+  console.log('Flags for import-records:');
+  console.log('  --update    Update existing records (match by Name field)');
+  console.log('  --clear     Clear all existing records before import');
+  console.log('');
+  console.log('Examples:');
+  console.log('  node airtable-crud-cli.js list-tables');
+  console.log('  node airtable-crud-cli.js list-records "My Table" 10');
+  console.log('  node airtable-crud-cli.js get-record "My Table" rec123456');
+  console.log('  node airtable-crud-cli.js create-records "My Table" data.json');
+  console.log('  node airtable-crud-cli.js export-records "My Table" export.json 1000');
+  console.log('  node airtable-crud-cli.js import-records "My Table" import.json --update');
+} 

package/bin/airtable-mcp.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+const path = require('path');
+
+// Find the Python interpreter
+const getPythonPath = () => {
+  try {
+    const whichPython = require('child_process').execSync('which python3.10').toString().trim();
+    return whichPython;
+  } catch (e) {
+    try {
+      const whichPython = require('child_process').execSync('which python3').toString().trim();
+      return whichPython;
+    } catch (e) {
+      return 'python';
+    }
+  }
+};
+
+const pythonPath = getPythonPath();
+const serverScript = path.join(__dirname, '..', 'airtable_mcp', 'src', 'server.py');
+
+// Get the arguments
+const args = process.argv.slice(2);
+
+// Construct the full command
+const serverProcess = spawn(pythonPath, [serverScript, ...args], {
+  stdio: 'inherit',
+});
+
+// Handle process exit
+serverProcess.on('close', (code) => {
+  process.exit(code);
+});
+
+// Handle signals
+process.on('SIGINT', () => {
+  serverProcess.kill('SIGINT');
+});
+
+process.on('SIGTERM', () => {
+  serverProcess.kill('SIGTERM');
+}); 

package/examples/airtable-crud-example.js

@@ -0,0 +1,203 @@
+/**
+ * Example script demonstrating how to use the Airtable CRUD utilities
+ */
+const dotenv = require('dotenv');
+const baseUtils = require('../tools/airtable-base');
+const crudUtils = require('../tools/airtable-crud');
+const schemaUtils = require('../tools/airtable-schema');
+
+// Load environment variables
+dotenv.config();
+
+// Configuration
+const EXAMPLE_TABLE_NAME = 'Example Tasks';
+const EXAMPLE_RECORDS = [
+  { 
+    Name: 'Complete project documentation', 
+    Description: 'Write comprehensive documentation for the project', 
+    Status: 'Not Started', 
+    Priority: 'High',
+    DueDate: '2023-12-31'
+  },
+  { 
+    Name: 'Fix login bug', 
+    Description: 'Users are experiencing issues with the login process', 
+    Status: 'In Progress', 
+    Priority: 'Critical',
+    DueDate: '2023-11-15'
+  },
+  { 
+    Name: 'Add new feature', 
+    Description: 'Implement the new feature requested by the client', 
+    Status: 'Not Started', 
+    Priority: 'Medium',
+    DueDate: '2024-01-15'
+  }
+];
+
+/**
+ * Main function to run the example
+ */
+async function runExample() {
+  console.log('Starting Airtable CRUD Example...\n');
+  
+  const baseId = process.env.AIRTABLE_BASE_ID;
+  if (!baseId) {
+    console.error('AIRTABLE_BASE_ID not set in .env file');
+    process.exit(1);
+  }
+  
+  try {
+    // Step 1: Check if we have access to the base
+    console.log('Step 1: Checking base access...');
+    const bases = await baseUtils.listAllBases();
+    const hasAccess = bases.some(base => base.id === baseId);
+    
+    if (!hasAccess) {
+      throw new Error(`No access to base with ID: ${baseId}`);
+    }
+    
+    console.log(`✅ Access confirmed to base: ${baseId}\n`);
+    
+    // Step 2: List existing tables
+    console.log('Step 2: Listing existing tables...');
+    const tables = await baseUtils.listTables(baseId);
+    console.log(`Found ${tables.length} tables in the base:`);
+    tables.forEach(table => console.log(`- ${table.name}`));
+    console.log();
+    
+    // Step 3: Check if our example table exists
+    console.log('Step 3: Checking if example table exists...');
+    let tableExists = await crudUtils.tableExists(baseId, EXAMPLE_TABLE_NAME);
+    
+    if (tableExists) {
+      console.log(`Table "${EXAMPLE_TABLE_NAME}" already exists\n`);
+    } else {
+      console.log(`Table "${EXAMPLE_TABLE_NAME}" does not exist, creating it...\n`);
+      
+      // Step 4: Create the example table
+      console.log('Step 4: Creating example table...');
+      const tableConfig = {
+        name: EXAMPLE_TABLE_NAME,
+        description: 'Example table for demonstrating CRUD operations',
+        fields: [
+          {
+            name: 'Name',
+            type: 'singleLineText',
+            description: 'Task name'
+          },
+          {
+            name: 'Description',
+            type: 'multilineText',
+            description: 'Task description'
+          },
+          {
+            name: 'Status',
+            type: 'singleSelect',
+            options: {
+              choices: [
+                { name: 'Not Started' },
+                { name: 'In Progress' },
+                { name: 'Completed' }
+              ]
+            },
+            description: 'Current status of the task'
+          },
+          {
+            name: 'Priority',
+            type: 'singleSelect',
+            options: {
+              choices: [
+                { name: 'Low' },
+                { name: 'Medium' },
+                { name: 'High' },
+                { name: 'Critical' }
+              ]
+            },
+            description: 'Task priority'
+          },
+          {
+            name: 'DueDate',
+            type: 'date',
+            description: 'When the task is due',
+            options: {
+              dateFormat: {
+                name: 'local'
+              }
+            }
+          }
+        ]
+      };
+      
+      await schemaUtils.createTable(baseId, tableConfig);
+      console.log(`✅ Created table: ${EXAMPLE_TABLE_NAME}\n`);
+    }
+    
+    // Step 5: Create records
+    console.log('Step 5: Creating example records...');
+    const createdRecords = await crudUtils.createRecords(baseId, EXAMPLE_TABLE_NAME, EXAMPLE_RECORDS);
+    console.log(`✅ Created ${createdRecords.length} records\n`);
+    
+    // Step 6: Read all records
+    console.log('Step 6: Reading all records...');
+    const allRecords = await crudUtils.readRecords(baseId, EXAMPLE_TABLE_NAME, 100);
+    console.log(`✅ Read ${allRecords.length} records`);
+    console.log('Sample record:');
+    console.log(JSON.stringify(allRecords[0], null, 2));
+    console.log();
+    
+    // Step 7: Filter records
+    console.log('Step 7: Filtering records by status...');
+    const notStartedRecords = await crudUtils.readRecords(
+      baseId, 
+      EXAMPLE_TABLE_NAME, 
+      100, 
+      'Status="Not Started"'
+    );
+    console.log(`✅ Found ${notStartedRecords.length} records with Status="Not Started"`);
+    notStartedRecords.forEach(record => console.log(`- ${record.Name} (Priority: ${record.Priority})`));
+    console.log();
+    
+    // Step 8: Update records
+    console.log('Step 8: Updating records...');
+    const recordsToUpdate = notStartedRecords.map(record => ({
+      id: record.id,
+      fields: { Status: 'In Progress' }
+    }));
+    
+    const updatedRecords = await crudUtils.updateRecords(baseId, EXAMPLE_TABLE_NAME, recordsToUpdate);
+    console.log(`✅ Updated ${updatedRecords.length} records to Status="In Progress"\n`);
+    
+    // Step 9: Verify updates
+    console.log('Step 9: Verifying updates...');
+    const inProgressRecords = await crudUtils.readRecords(
+      baseId, 
+      EXAMPLE_TABLE_NAME, 
+      100, 
+      'Status="In Progress"'
+    );
+    console.log(`✅ Found ${inProgressRecords.length} records with Status="In Progress"`);
+    inProgressRecords.forEach(record => console.log(`- ${record.Name} (Priority: ${record.Priority})`));
+    console.log();
+    
+    // Step 10: Delete records (optional - commented out to preserve data)
+    console.log('Step 10: Deleting records (optional)...');
+    console.log('Skipping deletion to preserve example data.');
+    console.log('To delete records, uncomment the code below:');
+    console.log('```');
+    console.log('const recordIdsToDelete = allRecords.map(record => record.id);');
+    console.log('const deletedRecords = await crudUtils.deleteRecords(baseId, EXAMPLE_TABLE_NAME, recordIdsToDelete);');
+    console.log('console.log(`✅ Deleted ${deletedRecords.length} records`);');
+    console.log('```\n');
+    
+    console.log('Example completed successfully!');
+    console.log('You can now view the data in your Airtable base.');
+    
+  } catch (error) {
+    console.error('Error during example:', error.message);
+    process.exit(1);
+  }
+}
+
+// Run the example
+runExample();