@antidrift/mcp-attio 0.7.3

package/bin/cli.mjs

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+
+import { existsSync, mkdirSync, writeFileSync, readFileSync, cpSync } from 'fs';
+import { join } from 'path';
+import { createInterface } from 'readline';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import { homedir } from 'os';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const configDir = join(homedir(), '.antidrift');
+
+const rl = createInterface({ input: process.stdin, output: process.stdout });
+
+function ask(q) {
+  return new Promise((resolve) => {
+    rl.question(q, (answer) => { resolve(answer); });
+  });
+}
+
+async function main() {
+  const command = process.argv[2];
+
+  if (command === 'add' || command === 'setup' || !command) {
+    await setup();
+  } else if (command === 'status') {
+    status();
+  } else if (command === 'reset') {
+    const configPath = join(configDir, 'attio.json');
+    if (existsSync(configPath)) {
+      const { rmSync } = await import('fs');
+      rmSync(configPath);
+      console.log('  Credentials cleared. Run this command again to reconnect.\n');
+    } else {
+      console.log('  No credentials to clear.\n');
+    }
+    rl.close();
+    process.exit(0);
+  } else {
+    console.log(`
+@antidrift/mcp-attio — Attio CRM for Claude
+
+Usage:
+  npx @antidrift/mcp-attio              Connect Attio
+  npx @antidrift/mcp-attio status       Check connection status
+`);
+  }
+
+  rl.close();
+}
+
+async function setup() {
+  console.log(`
+  ┌─────────────────────────────┐
+  │  antidrift                  │
+  │  Attio CRM                  │
+  └─────────────────────────────┘
+`);
+
+  const configPath = join(configDir, 'attio.json');
+  if (existsSync(configPath)) {
+    console.log('  Already authorized — updating server files.\n');
+    writeMcpConfig();
+    console.log('  ✓ Attio updated. Restart your agent to pick up changes.\n');
+    process.exit(0);
+  }
+
+  console.log('  To get your API key:\n');
+  console.log('  1. Go to https://app.attio.com');
+  console.log('  2. Settings (bottom left) → Developers → API Keys');
+  console.log('  3. Create a new key with read/write access');
+  console.log('  4. Copy the key and paste it below\n');
+
+  const apiKey = await ask('  API key: ');
+
+  if (!apiKey.trim()) {
+    console.log('  No key provided.\n');
+    return;
+  }
+
+  const masked = '*'.repeat(Math.max(0, apiKey.trim().length - 5)) + apiKey.trim().slice(-5);
+  console.log(`  Key: ${masked}\n`);
+
+  // Verify the key works
+  console.log('  Verifying...');
+  try {
+    const res = await fetch('https://api.attio.com/v2/self', {
+      headers: { 'Authorization': `Bearer ${apiKey.trim()}` }
+    });
+    if (!res.ok) throw new Error(`${res.status}`);
+    const data = await res.json();
+    console.log(`  ✓ Connected to workspace: ${data.data?.workspace?.name || 'OK'}\n`);
+  } catch (err) {
+    console.log(`  ✗ Invalid key or connection failed: ${err.message}\n`);
+    return;
+  }
+
+  mkdirSync(configDir, { recursive: true });
+  writeFileSync(configPath, JSON.stringify({ apiKey: apiKey.trim() }, null, 2));
+  writeMcpConfig();
+  console.log('  ✓ Attio connected (people, companies, deals, tasks, notes)');
+  console.log('  Restart your agent to use it.\n');
+  process.exit(0);
+}
+
+function status() {
+  const hasConfig = existsSync(join(configDir, 'attio.json'));
+  const icon = hasConfig ? '✓' : '○';
+  console.log(`\n  ${icon} Attio CRM — ${hasConfig ? 'connected' : 'not connected'}`);
+  console.log('    People, companies, deals, tasks, notes\n');
+}
+
+function writeMcpConfig() {
+  const cwd = process.cwd();
+  const serverDir = join(cwd, '.mcp-servers', 'attio');
+  const pkgDir = join(__dirname, '..');
+
+  // Copy server files to brain
+  mkdirSync(join(serverDir, 'connectors'), { recursive: true });
+  cpSync(join(pkgDir, 'server.mjs'), join(serverDir, 'server.mjs'));
+  cpSync(join(pkgDir, 'connectors', 'attio.mjs'), join(serverDir, 'connectors', 'attio.mjs'));
+
+  // Write .mcp.json pointing to local copy
+  const mcpPath = join(cwd, '.mcp.json');
+  let config = {};
+
+  if (existsSync(mcpPath)) {
+    try { config = JSON.parse(readFileSync(mcpPath, 'utf8')); } catch {}
+  }
+
+  if (!config.mcpServers) config.mcpServers = {};
+
+  config.mcpServers['antidrift-attio'] = {
+    command: 'node',
+    args: [join('.mcp-servers', 'attio', 'server.mjs')]
+  };
+
+  writeFileSync(mcpPath, JSON.stringify(config, null, 2));
+}
+
+main().catch(console.error);

package/connectors/attio.mjs

@@ -0,0 +1,341 @@
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const config = JSON.parse(readFileSync(join(homedir(), '.antidrift', 'attio.json'), 'utf8'));
+
+async function attio(method, path, body) {
+  const res = await fetch(`https://api.attio.com/v2${path}`, {
+    method,
+    headers: {
+      'Authorization': `Bearer ${config.apiKey}`,
+      'Content-Type': 'application/json'
+    },
+    body: body ? JSON.stringify(body) : undefined
+  });
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`Attio API ${res.status}: ${err}`);
+  }
+  return res.json();
+}
+
+function formatPerson(record) {
+  const vals = record.values || {};
+  const name = vals.name?.[0]?.full_name || vals.name?.[0]?.first_name || 'Unknown';
+  const email = vals.email_addresses?.[0]?.email_address || '';
+  const company = vals.company?.[0]?.target_object_id ? vals.company[0].target_record_id : '';
+  let line = `👤 ${name}`;
+  if (email) line += `  •  ${email}`;
+  line += `  [id: ${record.id.record_id}]`;
+  return line;
+}
+
+function formatCompany(record) {
+  const vals = record.values || {};
+  const name = vals.name?.[0]?.value || 'Unknown';
+  const domain = vals.domains?.[0]?.domain || '';
+  let line = `🏢 ${name}`;
+  if (domain) line += `  •  ${domain}`;
+  line += `  [id: ${record.id.record_id}]`;
+  return line;
+}
+
+function formatDeal(record) {
+  const vals = record.values || {};
+  const name = vals.name?.[0]?.value || 'Unknown';
+  const stage = vals.stage?.[0]?.status?.title || '';
+  const value = vals.value?.[0]?.currency_value || '';
+  let line = `💰 ${name}`;
+  if (stage) line += `  •  ${stage}`;
+  if (value) line += `  •  $${value}`;
+  line += `  [id: ${record.id.record_id}]`;
+  return line;
+}
+
+export const tools = [
+  {
+    name: 'attio_list_people',
+    description: 'List people in Attio CRM.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        limit: { type: 'number', description: 'Max results (default 20)' }
+      }
+    },
+    handler: async ({ limit = 20 }) => {
+      const res = await attio('POST', '/objects/people/records/query', { limit });
+      if (!res.data?.length) return 'No people found.';
+      return res.data.map(formatPerson).join('\n');
+    }
+  },
+  {
+    name: 'attio_search_people',
+    description: 'Search for people in Attio by name or email.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Name or email to search for' }
+      },
+      required: ['query']
+    },
+    handler: async ({ query }) => {
+      const res = await attio('POST', '/objects/people/records/query', {
+        filter: {
+          or: [
+            { attribute: 'name', condition: 'contains', value: query },
+            { attribute: 'email_addresses', condition: 'contains', value: query }
+          ]
+        }
+      });
+      if (!res.data?.length) return `No people matching "${query}".`;
+      return res.data.map(formatPerson).join('\n');
+    }
+  },
+  {
+    name: 'attio_get_person',
+    description: 'Get full details for a person by record ID.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        recordId: { type: 'string', description: 'The person record ID' }
+      },
+      required: ['recordId']
+    },
+    handler: async ({ recordId }) => {
+      const res = await attio('GET', `/objects/people/records/${recordId}`);
+      const vals = res.data.values || {};
+      const lines = [];
+      const name = vals.name?.[0]?.full_name || 'Unknown';
+      lines.push(`👤 ${name}`);
+      if (vals.email_addresses?.length) lines.push(`📧 ${vals.email_addresses.map(e => e.email_address).join(', ')}`);
+      if (vals.phone_numbers?.length) lines.push(`📞 ${vals.phone_numbers.map(p => p.phone_number).join(', ')}`);
+      if (vals.job_title?.[0]?.value) lines.push(`💼 ${vals.job_title[0].value}`);
+      if (vals.description?.[0]?.value) lines.push(`📝 ${vals.description[0].value}`);
+      lines.push(`[id: ${recordId}]`);
+      return lines.join('\n');
+    }
+  },
+  {
+    name: 'attio_create_person',
+    description: 'Create a new person in Attio.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        email: { type: 'string', description: 'Email address' },
+        firstName: { type: 'string', description: 'First name' },
+        lastName: { type: 'string', description: 'Last name' },
+        jobTitle: { type: 'string', description: 'Job title (optional)' }
+      },
+      required: ['email']
+    },
+    handler: async ({ email, firstName, lastName, jobTitle }) => {
+      const values = {
+        email_addresses: [{ email_address: email }]
+      };
+      if (firstName || lastName) {
+        values.name = [{ first_name: firstName || '', last_name: lastName || '' }];
+      }
+      if (jobTitle) values.job_title = [{ value: jobTitle }];
+
+      const res = await attio('POST', '/objects/people/records', { data: { values } });
+      return `✅ Created ${firstName || ''} ${lastName || ''} (${email})  [id: ${res.data.id.record_id}]`;
+    }
+  },
+  {
+    name: 'attio_list_companies',
+    description: 'List companies in Attio CRM.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        limit: { type: 'number', description: 'Max results (default 20)' }
+      }
+    },
+    handler: async ({ limit = 20 }) => {
+      const res = await attio('POST', '/objects/companies/records/query', { limit });
+      if (!res.data?.length) return 'No companies found.';
+      return res.data.map(formatCompany).join('\n');
+    }
+  },
+  {
+    name: 'attio_search_companies',
+    description: 'Search for companies in Attio by name or domain.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Company name or domain to search for' }
+      },
+      required: ['query']
+    },
+    handler: async ({ query }) => {
+      const res = await attio('POST', '/objects/companies/records/query', {
+        filter: {
+          or: [
+            { attribute: 'name', condition: 'contains', value: query },
+            { attribute: 'domains', condition: 'contains', value: query }
+          ]
+        }
+      });
+      if (!res.data?.length) return `No companies matching "${query}".`;
+      return res.data.map(formatCompany).join('\n');
+    }
+  },
+  {
+    name: 'attio_create_company',
+    description: 'Create a new company in Attio.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Company name' },
+        domain: { type: 'string', description: 'Website domain (optional)' }
+      },
+      required: ['name']
+    },
+    handler: async ({ name, domain }) => {
+      const values = { name: [{ value: name }] };
+      if (domain) values.domains = [{ domain }];
+
+      const res = await attio('POST', '/objects/companies/records', { data: { values } });
+      return `✅ Created ${name}  [id: ${res.data.id.record_id}]`;
+    }
+  },
+  {
+    name: 'attio_list_deals',
+    description: 'List deals in Attio CRM.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        limit: { type: 'number', description: 'Max results (default 20)' }
+      }
+    },
+    handler: async ({ limit = 20 }) => {
+      const res = await attio('POST', '/objects/deals/records/query', { limit });
+      if (!res.data?.length) return 'No deals found.';
+      return res.data.map(formatDeal).join('\n');
+    }
+  },
+  {
+    name: 'attio_update_record',
+    description: 'Update fields on a person, company, or deal in Attio.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        objectType: { type: 'string', description: 'Object type: "people", "companies", or "deals"' },
+        recordId: { type: 'string', description: 'The record ID to update' },
+        values: { type: 'object', description: 'Field values to update, e.g. {"job_title": [{"value": "CTO"}]}' }
+      },
+      required: ['objectType', 'recordId', 'values']
+    },
+    handler: async ({ objectType, recordId, values }) => {
+      const res = await attio('PATCH', `/objects/${objectType}/records/${recordId}`, { data: { values } });
+      return `✅ Updated ${objectType} record ${recordId}`;
+    }
+  },
+  {
+    name: 'attio_move_deal',
+    description: 'Move a deal to a different pipeline stage in Attio.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        recordId: { type: 'string', description: 'The deal record ID' },
+        stage: { type: 'string', description: 'The stage name to move to (e.g. "Qualified", "Proposal", "Closed Won")' }
+      },
+      required: ['recordId', 'stage']
+    },
+    handler: async ({ recordId, stage }) => {
+      const res = await attio('PATCH', `/objects/deals/records/${recordId}`, {
+        data: { values: { stage: [{ status: { title: stage } }] } }
+      });
+      return `✅ Deal moved to "${stage}"`;
+    }
+  },
+  {
+    name: 'attio_create_task',
+    description: 'Create a task in Attio, optionally linked to a record.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        content: { type: 'string', description: 'Task description' },
+        deadlineAt: { type: 'string', description: 'Deadline as ISO date string (optional)' },
+        linkedRecordId: { type: 'string', description: 'Record ID to link the task to (optional)' },
+        linkedObjectType: { type: 'string', description: 'Object type of linked record: "people", "companies", or "deals" (optional)' }
+      },
+      required: ['content']
+    },
+    handler: async ({ content, deadlineAt, linkedRecordId, linkedObjectType }) => {
+      const body = {
+        data: {
+          content: [{ type: 'paragraph', children: [{ text: content }] }],
+          format: 'plaintext',
+          is_completed: false
+        }
+      };
+      if (deadlineAt) body.data.deadline_at = deadlineAt;
+      if (linkedRecordId && linkedObjectType) {
+        body.data.linked_records = [{ target_object: linkedObjectType, target_record_id: linkedRecordId }];
+      }
+      const res = await attio('POST', '/tasks', body);
+      return `✅ Task created: "${content}"${deadlineAt ? ` (due: ${deadlineAt})` : ''}`;
+    }
+  },
+  {
+    name: 'attio_list_tasks',
+    description: 'List tasks in Attio.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        limit: { type: 'number', description: 'Max results (default 20)' }
+      }
+    },
+    handler: async ({ limit = 20 }) => {
+      const res = await attio('GET', `/tasks?limit=${limit}`);
+      if (!res.data?.length) return 'No tasks found.';
+      return res.data.map(t => {
+        const status = t.is_completed ? '✅' : '⬜';
+        const content = t.content_plaintext || 'No description';
+        const deadline = t.deadline_at ? ` (due: ${new Date(t.deadline_at).toLocaleDateString()})` : '';
+        return `${status} ${content}${deadline}  [id: ${t.id.task_id}]`;
+      }).join('\n');
+    }
+  },
+  {
+    name: 'attio_complete_task',
+    description: 'Mark a task as completed in Attio.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        taskId: { type: 'string', description: 'The task ID to complete' }
+      },
+      required: ['taskId']
+    },
+    handler: async ({ taskId }) => {
+      await attio('PATCH', `/tasks/${taskId}`, { data: { is_completed: true } });
+      return `✅ Task marked as completed`;
+    }
+  },
+  {
+    name: 'attio_add_note',
+    description: 'Add a note to a person or company in Attio.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        objectType: { type: 'string', description: 'Object type: "people" or "companies"' },
+        recordId: { type: 'string', description: 'The record ID' },
+        title: { type: 'string', description: 'Note title' },
+        content: { type: 'string', description: 'Note content' }
+      },
+      required: ['objectType', 'recordId', 'title', 'content']
+    },
+    handler: async ({ objectType, recordId, title, content }) => {
+      const res = await attio('POST', '/notes', {
+        data: {
+          title,
+          content: [{ type: 'paragraph', children: [{ text: content }] }],
+          parent_object: objectType === 'people' ? 'people' : 'companies',
+          parent_record_id: recordId
+        }
+      });
+      return `✅ Note added: "${title}"`;
+    }
+  }
+];

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@antidrift/mcp-attio",
+  "version": "0.7.3",
+  "description": "Attio CRM connector for antidrift — people, companies, deals, notes",
+  "main": "server.mjs",
+  "bin": {
+    "antidrift-mcp-attio": "bin/cli.mjs"
+  },
+  "files": [
+    "server.mjs",
+    "connectors/",
+    "bin/"
+  ],
+  "keywords": [
+    "antidrift",
+    "mcp",
+    "claude-code",
+    "attio",
+    "crm"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/probeo-io/antidrift.git",
+    "directory": "packages/mcp-attio"
+  },
+  "author": "Probeo <hello@probeo.io>"
+}

package/server.mjs

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+
+import { createInterface } from 'readline';
+import { tools as attioTools } from './connectors/attio.mjs';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const allTools = [];
+
+if (existsSync(join(homedir(), '.antidrift', 'attio.json'))) {
+  allTools.push(...attioTools);
+}
+
+const rl = createInterface({ input: process.stdin, terminal: false });
+
+function send(msg) {
+  process.stdout.write(JSON.stringify(msg) + '\n');
+}
+
+rl.on('line', async (line) => {
+  let req;
+  try { req = JSON.parse(line); } catch { return; }
+
+  const { id, method, params } = req;
+
+  if (method === 'initialize') {
+    send({
+      jsonrpc: '2.0', id,
+      result: {
+        protocolVersion: '2024-11-05',
+        capabilities: { tools: {} },
+        serverInfo: { name: 'antidrift-attio', version: '0.1.0' }
+      }
+    });
+  } else if (method === 'notifications/initialized') {
+    // no response needed
+  } else if (method === 'tools/list') {
+    send({
+      jsonrpc: '2.0', id,
+      result: {
+        tools: allTools.map(t => ({
+          name: t.name,
+          description: t.description,
+          inputSchema: t.inputSchema
+        }))
+      }
+    });
+  } else if (method === 'tools/call') {
+    const tool = allTools.find(t => t.name === params.name);
+    if (!tool) {
+      send({ jsonrpc: '2.0', id, error: { code: -32601, message: `Unknown tool: ${params.name}` } });
+      return;
+    }
+
+    try {
+      const result = await tool.handler(params.arguments || {});
+      send({ jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] } });
+    } catch (err) {
+      send({ jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true } });
+    }
+  } else {
+    send({ jsonrpc: '2.0', id, error: { code: -32601, message: `Unknown method: ${method}` } });
+  }
+});