@rashidazarang/airtable-mcp 1.6.0 → 2.1.0

package/airtable-clipper/terms-of-service.md

@@ -0,0 +1,124 @@
+# Terms of Service for Airtable Clipper
+
+**Last updated: August 15, 2025**
+
+## 1. Acceptance of Terms
+
+By installing, accessing, or using Airtable Clipper ("the Extension"), you agree to be bound by these Terms of Service ("Terms"). If you do not agree to these Terms, do not use the Extension.
+
+## 2. Description of Service
+
+Airtable Clipper is a Chrome browser extension that enables users to save web content directly to their personal Airtable bases. The Extension provides functionality to:
+
+- Save webpage titles, URLs, and content to Airtable
+- Extract LinkedIn profile information (public data only)
+- Organize web research and data collection
+- Bulk selection and saving of multiple items
+
+## 3. User Responsibilities
+
+### 3.1 Account Security
+- You are responsible for maintaining the security of your Airtable credentials
+- You must not share your Personal Access Token with others
+- You agree to notify us immediately of any unauthorized use of your account
+
+### 3.2 Lawful Use
+- You agree to use the Extension only for lawful purposes
+- You will not use the Extension to collect or process data in violation of applicable laws
+- You respect the terms of service of websites you visit while using the Extension
+
+### 3.3 Data Accuracy
+- You are responsible for the accuracy of data you save to your Airtable bases
+- You understand that the Extension processes publicly available web content only
+
+## 4. Privacy and Data Protection
+
+- Your data privacy is governed by our Privacy Policy
+- We do not store or access your Airtable data
+- All data processing occurs locally in your browser
+- We do not sell or share your personal information
+
+## 5. Intellectual Property
+
+### 5.1 Extension Rights
+- The Extension and its original content are owned by Rashid Azarang
+- You are granted a limited, non-exclusive license to use the Extension
+
+### 5.2 User Content
+- You retain ownership of all data you save using the Extension
+- You grant us no rights to your data or content
+
+## 6. Third-Party Services
+
+### 6.1 Airtable Integration
+- The Extension integrates with Airtable's services
+- Your use of Airtable is subject to Airtable's Terms of Service
+- We are not responsible for Airtable's availability or performance
+
+### 6.2 Website Content
+- You are responsible for respecting the terms of service of websites you visit
+- We do not control or endorse third-party website content
+
+## 7. Disclaimers
+
+### 7.1 Service Availability
+- The Extension is provided "as is" without warranties of any kind
+- We do not guarantee uninterrupted or error-free service
+- We reserve the right to modify or discontinue the Extension at any time
+
+### 7.2 Data Loss
+- While we strive for reliability, we cannot guarantee against data loss
+- You are responsible for backing up important data
+- We recommend regular exports of your Airtable data
+
+## 8. Limitation of Liability
+
+To the maximum extent permitted by law:
+- We shall not be liable for any indirect, incidental, or consequential damages
+- Our total liability shall not exceed $10 USD
+- We are not liable for data loss, business interruption, or lost profits
+
+## 9. Support and Updates
+
+### 9.1 Support
+- Support is provided on a best-effort basis through GitHub issues
+- We do not guarantee response times or issue resolution
+
+### 9.2 Updates
+- We may release updates to improve functionality and security
+- Updates are provided at our discretion
+- Continued use after updates constitutes acceptance of changes
+
+## 10. Termination
+
+### 10.1 User Termination
+- You may stop using the Extension at any time by uninstalling it
+- You may disconnect your Airtable account through the Extension settings
+
+### 10.2 Service Termination
+- We may terminate or suspend the Extension for violations of these Terms
+- We may discontinue the Extension with reasonable notice
+
+## 11. Changes to Terms
+
+- We may update these Terms from time to time
+- Changes will be posted on this page with an updated date
+- Continued use after changes constitutes acceptance of new Terms
+
+## 12. Governing Law
+
+These Terms are governed by the laws of the United States and the State of California, without regard to conflict of law principles.
+
+## 13. Contact Information
+
+For questions about these Terms, please contact:
+- Email: rashid.azarang.e@gmail.com
+- GitHub: https://github.com/rashidazarang/airtable-clipper/issues
+
+## 14. Severability
+
+If any provision of these Terms is found to be unenforceable, the remaining provisions will remain in full force and effect.
+
+---
+
+By using Airtable Clipper, you acknowledge that you have read, understood, and agree to be bound by these Terms of Service.

package/airtable-clipper/test-credentials.md

@@ -0,0 +1,61 @@
+# Test Credentials for Airtable Clipper
+
+## For Manual Connection Testing
+
+### Personal Access Token:
+```
+pat_yourTokenHere_generateFromAirtable
+```
+*Note: You need to create this from https://airtable.com/create/tokens*
+
+### Base ID:
+```
+appYourBaseId
+```
+*Note: This is found in your Airtable URL like https://airtable.com/appYourBaseId/...*
+
+## Setting Up Test Base
+
+1. Go to https://airtable.com
+2. Create a new base called "Clipper Test"
+3. Create these tables:
+
+### Table 1: "Contacts"
+Fields:
+- Name (Single line text)
+- Title (Single line text) 
+- Company (Single line text)
+- LinkedIn URL (URL)
+- Location (Single line text)
+- Date Added (Date)
+- Source (Single select: LinkedIn, Manual, Import)
+- Notes (Long text)
+
+### Table 2: "Web Clips"  
+Fields:
+- Title (Single line text)
+- URL (URL)
+- Content (Long text)
+- Domain (Single line text)
+- Saved At (Date)
+- Type (Single select: Web Page, Text Selection, Image)
+
+## OAuth Client ID (Already Configured)
+```
+db9710e0-7d4b-4be6-bb15-2621448b0425
+```
+
+## Testing Steps
+
+1. **Install Extension**: Load the `test-extension` folder as an unpacked extension in Chrome
+2. **Manual Connection**: Use the Personal Access Token and Base ID from above
+3. **Test Quick Save**: Visit any webpage and click "Save Page"
+4. **Test LinkedIn**: Visit a LinkedIn profile and click "Save Profile"
+5. **Test Bulk Mode**: Try bulk selection on a webpage
+
+## Troubleshooting
+
+- Check Chrome DevTools Console for errors
+- Verify token has correct permissions (data.records:read, data.records:write, schema.bases:read)
+- Ensure base ID is correct from Airtable URL
+- Check that table names match exactly (case-sensitive)

package/airtable-clipper/test-extension/background.js

@@ -0,0 +1,337 @@
+// Airtable Clipper - Background Service Worker
+// Handles context menus, notifications, and cross-tab communication
+
+class BackgroundService {
+  constructor() {
+    this.init();
+  }
+
+  init() {
+    // Create context menu on installation
+    chrome.runtime.onInstalled.addListener(() => {
+      this.createContextMenus();
+      this.setupNotifications();
+    });
+
+    // Handle context menu clicks
+    chrome.contextMenus.onClicked.addListener((info, tab) => {
+      this.handleContextMenuClick(info, tab);
+    });
+
+    // Handle messages from content scripts and popup
+    chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
+      this.handleMessage(message, sender, sendResponse);
+      return true; // Keep message channel open for async responses
+    });
+
+    // Handle extension icon clicks
+    chrome.action.onClicked.addListener((tab) => {
+      this.handleActionClick(tab);
+    });
+
+    // Periodic cleanup
+    chrome.alarms.onAlarm.addListener((alarm) => {
+      if (alarm.name === 'cleanup') {
+        this.cleanupStorage();
+      }
+    });
+
+    // Set up cleanup alarm
+    chrome.alarms.create('cleanup', { delayInMinutes: 60, periodInMinutes: 60 });
+  }
+
+  createContextMenus() {
+    // Remove existing menus
+    chrome.contextMenus.removeAll();
+
+    // Main menu
+    chrome.contextMenus.create({
+      id: 'save-to-airtable',
+      title: 'Save to Airtable',
+      contexts: ['page', 'selection', 'link', 'image']
+    });
+
+    // LinkedIn specific
+    chrome.contextMenus.create({
+      id: 'save-linkedin-profile',
+      title: 'Save LinkedIn Profile',
+      contexts: ['page'],
+      documentUrlPatterns: ['*://www.linkedin.com/in/*', '*://linkedin.com/in/*']
+    });
+
+    // Quick save selection
+    chrome.contextMenus.create({
+      id: 'quick-save-selection',
+      title: 'Quick Save Selected Text',
+      contexts: ['selection']
+    });
+  }
+
+  async handleContextMenuClick(info, tab) {
+    try {
+      switch (info.menuItemId) {
+        case 'save-to-airtable':
+          await this.triggerSave(tab, { type: 'general', info });
+          break;
+        case 'save-linkedin-profile':
+          await this.triggerSave(tab, { type: 'linkedin', info });
+          break;
+        case 'quick-save-selection':
+          await this.triggerSave(tab, { type: 'selection', text: info.selectionText });
+          break;
+      }
+    } catch (error) {
+      console.error('Context menu error:', error);
+      this.showErrorNotification(error.message);
+    }
+  }
+
+  async triggerSave(tab, data) {
+    // Send message to content script to initiate save
+    try {
+      const response = await chrome.tabs.sendMessage(tab.id, {
+        action: 'triggerSave',
+        data: data
+      });
+
+      if (response && response.success) {
+        this.showSuccessNotification('Content saved to Airtable!');
+      } else {
+        throw new Error(response?.error || 'Failed to save content');
+      }
+    } catch (error) {
+      console.error('Save trigger error:', error);
+      // Fallback: open popup if content script isn't available
+      chrome.action.openPopup();
+    }
+  }
+
+  async handleMessage(message, sender, sendResponse) {
+    try {
+      switch (message.action) {
+        case 'saveToAirtable':
+          const result = await this.saveToAirtable(message.data);
+          sendResponse({ success: true, result });
+          break;
+
+        case 'getSettings':
+          const settings = await this.getSettings();
+          sendResponse({ success: true, settings });
+          break;
+
+        case 'saveSettings':
+          await this.saveSettings(message.settings);
+          sendResponse({ success: true });
+          break;
+
+        case 'showNotification':
+          this.showNotification(message.title, message.message, message.type);
+          sendResponse({ success: true });
+          break;
+
+        case 'openSidePanel':
+          if (sender.tab) {
+            chrome.sidePanel.open({ tabId: sender.tab.id });
+          }
+          sendResponse({ success: true });
+          break;
+
+        default:
+          sendResponse({ success: false, error: 'Unknown action' });
+      }
+    } catch (error) {
+      console.error('Message handler error:', error);
+      sendResponse({ success: false, error: error.message });
+    }
+  }
+
+  async saveToAirtable(data) {
+    // Get user settings
+    const settings = await this.getSettings();
+    
+    if (!settings.airtableToken || !settings.baseId) {
+      throw new Error('Airtable credentials not configured');
+    }
+
+    // Import Airtable client
+    const { AirtableClient } = await import('./lib/airtable-client.js');
+    const client = new AirtableClient(settings.airtableToken, settings.baseId);
+
+    // Process and save data
+    const processedData = await this.processData(data, settings);
+    const result = await client.createRecord(processedData.table, processedData.fields);
+
+    // Update usage stats
+    await this.updateUsageStats();
+
+    return result;
+  }
+
+  async processData(data, settings) {
+    // Smart data processing based on content type
+    if (data.type === 'linkedin') {
+      return {
+        table: settings.linkedinTable || 'Contacts',
+        fields: this.processLinkedInData(data)
+      };
+    } else if (data.type === 'selection') {
+      return {
+        table: settings.defaultTable || 'Clips',
+        fields: {
+          'Content': data.text,
+          'Source URL': data.url,
+          'Saved At': new Date().toISOString().split('T')[0],
+          'Type': 'Text Selection'
+        }
+      };
+    } else {
+      return {
+        table: settings.defaultTable || 'Clips',
+        fields: {
+          'Title': data.title || 'Untitled',
+          'URL': data.url,
+          'Content': data.content,
+          'Saved At': new Date().toISOString().split('T')[0],
+          'Type': 'Web Page'
+        }
+      };
+    }
+  }
+
+  processLinkedInData(data) {
+    return {
+      'Name': data.name || '',
+      'Title': data.title || '',
+      'Company': data.company || '',
+      'Location': data.location || '',
+      'LinkedIn URL': data.url || '',
+      'Date Added': new Date().toISOString().split('T')[0],
+      'Source': 'LinkedIn',
+      'Notes': data.about ? data.about.substring(0, 500) + '...' : ''
+    };
+  }
+
+  async getSettings() {
+    const result = await chrome.storage.sync.get([
+      'airtableToken',
+      'baseId',
+      'linkedinTable',
+      'defaultTable',
+      'autoSave',
+      'notifications'
+    ]);
+
+    return {
+      airtableToken: result.airtableToken || '',
+      baseId: result.baseId || '',
+      linkedinTable: result.linkedinTable || 'Contacts',
+      defaultTable: result.defaultTable || 'Clips',
+      autoSave: result.autoSave || false,
+      notifications: result.notifications !== false // Default to true
+    };
+  }
+
+  async saveSettings(settings) {
+    await chrome.storage.sync.set(settings);
+  }
+
+  async updateUsageStats() {
+    const stats = await chrome.storage.local.get(['usageStats']);
+    const currentStats = stats.usageStats || {
+      totalClips: 0,
+      weeklyClips: 0,
+      lastResetDate: new Date().toDateString()
+    };
+
+    // Reset weekly counter if it's a new week
+    const today = new Date().toDateString();
+    if (currentStats.lastResetDate !== today) {
+      const lastReset = new Date(currentStats.lastResetDate);
+      const daysSinceReset = Math.floor((Date.now() - lastReset.getTime()) / (1000 * 60 * 60 * 24));
+      
+      if (daysSinceReset >= 7) {
+        currentStats.weeklyClips = 0;
+        currentStats.lastResetDate = today;
+      }
+    }
+
+    currentStats.totalClips++;
+    currentStats.weeklyClips++;
+
+    await chrome.storage.local.set({ usageStats: currentStats });
+  }
+
+  setupNotifications() {
+    // Check if notifications are supported
+    if ('notifications' in chrome) {
+      // Request notification permission if needed
+      chrome.notifications.getPermissionLevel((level) => {
+        if (level !== 'granted') {
+          console.log('Notification permission not granted');
+        }
+      });
+    }
+  }
+
+  showSuccessNotification(message) {
+    this.showNotification('Success!', message, 'success');
+  }
+
+  showErrorNotification(message) {
+    this.showNotification('Error', message, 'error');
+  }
+
+  async showNotification(title, message, type = 'basic') {
+    const settings = await this.getSettings();
+    if (!settings.notifications) return;
+
+    const iconUrl = type === 'error' ? 'icons/icon-error-48.png' : 'icons/icon-48.png';
+
+    chrome.notifications.create({
+      type: 'basic',
+      iconUrl: iconUrl,
+      title: title,
+      message: message
+    });
+  }
+
+  async handleActionClick(tab) {
+    // Check if this is a LinkedIn profile page
+    if (tab.url.includes('linkedin.com/in/')) {
+      // Try to extract LinkedIn data automatically
+      try {
+        await this.triggerSave(tab, { type: 'linkedin' });
+      } catch (error) {
+        // Fallback to opening popup
+        chrome.action.openPopup();
+      }
+    } else {
+      // Open popup for general pages
+      chrome.action.openPopup();
+    }
+  }
+
+  async cleanupStorage() {
+    // Clean up old temporary data
+    const result = await chrome.storage.local.get(null);
+    const keysToRemove = [];
+
+    for (const [key, value] of Object.entries(result)) {
+      // Remove temporary data older than 24 hours
+      if (key.startsWith('temp_') && value.timestamp) {
+        const age = Date.now() - value.timestamp;
+        if (age > 24 * 60 * 60 * 1000) { // 24 hours
+          keysToRemove.push(key);
+        }
+      }
+    }
+
+    if (keysToRemove.length > 0) {
+      await chrome.storage.local.remove(keysToRemove);
+      console.log(`Cleaned up ${keysToRemove.length} temporary items`);
+    }
+  }
+}
+
+// Initialize the background service
+new BackgroundService();