adoptai-mcp 1.0.0

package/dist/integrations/notion/tools.original.js

@@ -0,0 +1,568 @@
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { notionRequest } from './api.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const manifest = JSON.parse(readFileSync(join(__dirname, 'endpoints.json'), 'utf8'));
+const BASE_URL = manifest.baseUrl;
+
+function text(payload) {
+  return {
+    content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }],
+  };
+}
+
+function enrichSchema(schema, method) {
+  const s = structuredClone(schema);
+  s.properties = s.properties || {};
+  if (['POST', 'PUT', 'PATCH'].includes(method)) {
+    s.properties._rawBody = {
+      type: 'object',
+      description:
+        'Optional full JSON body for nested structures (parent, properties, rich_text, etc.). When set, replaces other body fields.',
+    };
+  }
+  return s;
+}
+
+const baseTools = manifest.endpoints.map((endpoint) => ({
+  name: endpoint.name,
+  description: endpoint.description,
+  inputSchema: enrichSchema(endpoint.inputSchema, endpoint.method),
+  handler: async (params) => text(await notionRequest(endpoint, BASE_URL, params)),
+}));
+
+function call(method, path, params = {}) {
+  return notionRequest({ method, path }, BASE_URL, params);
+}
+
+function richText(content) {
+  return [{ type: 'text', text: { content: String(content ?? '') } }];
+}
+
+function blockText(block) {
+  const t = block?.type;
+  const value = block?.[t];
+  if (!value) return '';
+  if (Array.isArray(value.rich_text)) {
+    return value.rich_text.map((x) => x?.plain_text || x?.text?.content || '').join('');
+  }
+  if (Array.isArray(value.title)) {
+    return value.title.map((x) => x?.plain_text || x?.text?.content || '').join('');
+  }
+  return '';
+}
+
+function pageTitle(page) {
+  const props = page?.properties || {};
+  for (const p of Object.values(props)) {
+    if (p?.type === 'title' && Array.isArray(p.title)) {
+      const t = p.title.map((x) => x?.plain_text || x?.text?.content || '').join('');
+      if (t) return t;
+    }
+  }
+  return '';
+}
+
+async function listAllChildren(block_id, max_depth = 5, depth = 1) {
+  let cursor;
+  const items = [];
+  do {
+    const page = await call('GET', '/v1/blocks/{block_id}/children', {
+      block_id,
+      start_cursor: cursor,
+      page_size: 100,
+    });
+    const results = page?.results || [];
+    for (const b of results) {
+      const out = { ...b };
+      if (b.has_children && depth < max_depth) {
+        out.children = await listAllChildren(b.id, max_depth, depth + 1);
+      }
+      items.push(out);
+    }
+    cursor = page?.has_more ? page?.next_cursor : null;
+  } while (cursor);
+  return items;
+}
+
+function markdownToBlocks(content, defaultType = 'paragraph') {
+  const lines = String(content || '')
+    .split('\n')
+    .map((x) => x.replace(/\r$/, ''));
+  const blocks = [];
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    let type = defaultType;
+    let textValue = line;
+    let checked = false;
+    if (line.startsWith('### ')) {
+      type = 'heading_3';
+      textValue = line.slice(4);
+    } else if (line.startsWith('## ')) {
+      type = 'heading_2';
+      textValue = line.slice(3);
+    } else if (line.startsWith('# ')) {
+      type = 'heading_1';
+      textValue = line.slice(2);
+    } else if (line.startsWith('- [ ] ')) {
+      type = 'to_do';
+      textValue = line.slice(6);
+      checked = false;
+    } else if (line.startsWith('- [x] ') || line.startsWith('- [X] ')) {
+      type = 'to_do';
+      textValue = line.slice(6);
+      checked = true;
+    } else if (/^\d+\.\s+/.test(line)) {
+      type = 'numbered_list_item';
+      textValue = line.replace(/^\d+\.\s+/, '');
+    } else if (line.startsWith('- ')) {
+      type = 'bulleted_list_item';
+      textValue = line.slice(2);
+    } else if (line.startsWith('> ')) {
+      type = 'quote';
+      textValue = line.slice(2);
+    } else if (line.startsWith('!! ')) {
+      type = 'callout';
+      textValue = line.slice(3);
+    }
+    const block = { object: 'block', type, [type]: { rich_text: richText(textValue) } };
+    if (type === 'to_do') block[type].checked = checked;
+    if (type === 'callout') block[type].icon = { emoji: '💡' };
+    blocks.push(block);
+  }
+  return blocks;
+}
+
+function buildDatabaseFilter(filter_property, filter_type, filter_value) {
+  const property = String(filter_property || '').trim();
+  const kind = String(filter_type || 'text').trim().toLowerCase();
+  if (!property || filter_value === undefined || filter_value === null || filter_value === '') return null;
+  if (kind === 'number') return { property, number: { equals: Number(filter_value) } };
+  if (kind === 'checkbox') return { property, checkbox: { equals: String(filter_value) === 'true' } };
+  if (kind === 'select') return { property, select: { equals: String(filter_value) } };
+  if (kind === 'date') return { property, date: { equals: String(filter_value) } };
+  if (kind === 'relation') return { property, relation: { contains: String(filter_value) } };
+  return { property, rich_text: { contains: String(filter_value) } };
+}
+
+function propertyToCell(prop) {
+  if (!prop || !prop.type) return '';
+  if (prop.type === 'title') return (prop.title || []).map((x) => x?.plain_text || '').join('');
+  if (prop.type === 'rich_text') return (prop.rich_text || []).map((x) => x?.plain_text || '').join('');
+  if (prop.type === 'number') return prop.number;
+  if (prop.type === 'checkbox') return prop.checkbox;
+  if (prop.type === 'select') return prop.select?.name || '';
+  if (prop.type === 'multi_select') return (prop.multi_select || []).map((x) => x.name).join(', ');
+  if (prop.type === 'date') return prop.date?.start || '';
+  if (prop.type === 'status') return prop.status?.name || '';
+  if (prop.type === 'url') return prop.url || '';
+  if (prop.type === 'email') return prop.email || '';
+  if (prop.type === 'phone_number') return prop.phone_number || '';
+  if (prop.type === 'relation') return (prop.relation || []).map((x) => x.id).join(', ');
+  return '';
+}
+
+const smartTools = [
+  {
+    name: 'get_page_full_content',
+    description:
+      'Retrieves a Notion page AND all its nested block content in one call. Automatically follows has_children blocks to fetch deeply nested content. Use this instead of get_page when you need the full text content of a page, not just its properties.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        page_id: { type: 'string', description: 'Notion page ID.' },
+        max_depth: { type: 'number', description: 'Maximum recursion depth. Defaults to 3.' },
+      },
+      required: ['page_id'],
+    },
+    handler: async ({ page_id, max_depth = 3 }) => {
+      const page = await call('GET', '/v1/pages/{page_id}', { page_id });
+      const blocks = await listAllChildren(page_id, max_depth);
+      return text({ page, content_blocks: blocks });
+    },
+  },
+  {
+    name: 'create_page_with_content',
+    description:
+      'Creates a new Notion page inside a parent page or database AND adds initial content blocks in one call. Use this when you want to create a page that already has content, instead of creating empty page then appending separately.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        parent_page_id: { type: 'string', description: 'Parent page ID.' },
+        parent_database_id: { type: 'string', description: 'Parent database ID.' },
+        title: { type: 'string', description: 'Page title.' },
+        content: { type: 'string', description: 'Markdown-like content text.' },
+      },
+      required: ['title', 'content'],
+    },
+    handler: async ({ parent_page_id, parent_database_id, title, content }) => {
+      if (!parent_page_id && !parent_database_id) {
+        throw new Error('Provide parent_page_id or parent_database_id.');
+      }
+      const children = markdownToBlocks(content, 'paragraph');
+      const parent = parent_database_id ? { database_id: parent_database_id } : { page_id: parent_page_id };
+      const properties = parent_database_id
+        ? { Name: { title: richText(title) } }
+        : { title: { title: richText(title) } };
+      const created = await call('POST', '/v1/pages', { _rawBody: { parent, properties, children } });
+      return text(created);
+    },
+  },
+  {
+    name: 'duplicate_page',
+    description:
+      'Duplicates a Notion page including all its properties and top-level content blocks under a specified parent. Use when you need a copy of an existing page as a template.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        page_id: { type: 'string', description: 'Source page ID.' },
+        parent_id: { type: 'string', description: 'Destination parent ID.' },
+      },
+      required: ['page_id', 'parent_id'],
+    },
+    handler: async ({ page_id, parent_id }) => {
+      const sourcePage = await call('GET', '/v1/pages/{page_id}', { page_id });
+      const childrenResp = await call('GET', '/v1/blocks/{block_id}/children', { block_id: page_id, page_size: 100 });
+      const children = childrenResp?.results || [];
+      const payload = {
+        parent: { page_id: parent_id },
+        properties: sourcePage.properties || {},
+        children,
+      };
+      const duplicated = await call('POST', '/v1/pages', { _rawBody: payload });
+      return text({ source_page_id: page_id, duplicated_page: duplicated });
+    },
+  },
+  {
+    name: 'query_database_filtered',
+    description:
+      'Queries a Notion database with property filters. Supports filtering by text, number, checkbox, select, date, and relation properties. Use this for targeted queries. For unfiltered full lists use query_database_all.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        database_id: { type: 'string', description: 'Database ID.' },
+        filter_property: { type: 'string', description: 'Property name to filter on.' },
+        filter_type: { type: 'string', description: 'text|number|checkbox|select|date|relation' },
+        filter_value: { type: 'string', description: 'Filter value.' },
+        page_size: { type: 'number', description: 'Page size for query.' },
+      },
+      required: ['database_id'],
+    },
+    handler: async ({ database_id, filter_property, filter_type, filter_value, page_size = 20 }) => {
+      const filter = buildDatabaseFilter(filter_property, filter_type, filter_value);
+      const data = await call('POST', '/v1/databases/{id}/query', {
+        id: database_id,
+        _rawBody: { page_size, ...(filter ? { filter } : {}) },
+      });
+      return text(data);
+    },
+  },
+  {
+    name: 'query_database_all',
+    description:
+      'Retrieves ALL rows from a Notion database by automatically handling pagination. Use when you need the complete dataset. Warning: may be slow for large databases. For targeted queries use query_database_filtered.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        database_id: { type: 'string', description: 'Database ID.' },
+        max_pages: { type: 'number', description: 'Safety cap for pagination pages. Defaults to 10.' },
+      },
+      required: ['database_id'],
+    },
+    handler: async ({ database_id, max_pages = 10 }) => {
+      const all = [];
+      let start_cursor;
+      let page = 0;
+      do {
+        const resp = await call('POST', '/v1/databases/{id}/query', {
+          id: database_id,
+          _rawBody: { start_cursor, page_size: 100 },
+        });
+        all.push(...(resp?.results || []));
+        start_cursor = resp?.has_more ? resp?.next_cursor : null;
+        page += 1;
+      } while (start_cursor && page < max_pages);
+      return text({ database_id, total_rows: all.length, results: all, truncated: !!start_cursor });
+    },
+  },
+  {
+    name: 'query_database_sorted',
+    description:
+      'Queries a Notion database sorted by a specific property in ascending or descending order. Use to get rows ordered by date, name, priority or any database property.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        database_id: { type: 'string', description: 'Database ID.' },
+        sort_property: { type: 'string', description: 'Property used for sorting.' },
+        sort_direction: { type: 'string', description: 'ascending or descending' },
+        page_size: { type: 'number', description: 'Page size for query.' },
+      },
+      required: ['database_id', 'sort_property'],
+    },
+    handler: async ({ database_id, sort_property, sort_direction = 'ascending', page_size = 20 }) => {
+      const resp = await call('POST', '/v1/databases/{id}/query', {
+        id: database_id,
+        _rawBody: { page_size, sorts: [{ property: sort_property, direction: sort_direction }] },
+      });
+      return text(resp);
+    },
+  },
+  {
+    name: 'get_database_rows_as_table',
+    description:
+      'Queries a database and returns results as a clean structured table with column names and values extracted. Much easier to read than raw API response. Use when presenting database contents to a user.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        database_id: { type: 'string', description: 'Database ID.' },
+        page_size: { type: 'number', description: 'Number of rows to retrieve. Defaults to 20.' },
+      },
+      required: ['database_id'],
+    },
+    handler: async ({ database_id, page_size = 20 }) => {
+      const resp = await call('POST', '/v1/databases/{id}/query', {
+        id: database_id,
+        _rawBody: { page_size },
+      });
+      const rows = resp?.results || [];
+      const columns = [...new Set(rows.flatMap((r) => Object.keys(r.properties || {})))];
+      const table = rows.map((row) =>
+        Object.fromEntries(columns.map((c) => [c, propertyToCell(row.properties?.[c])]))
+      );
+      return text({ database_id, columns, rows: table });
+    },
+  },
+  {
+    name: 'append_text_content',
+    description:
+      'Appends simple text content to a Notion page or block. Accepts plain text or markdown and converts to Notion paragraph blocks automatically. Use for simple text additions. For complex blocks with nested structure use append_complex_blocks.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        block_id: { type: 'string', description: 'Parent block/page ID.' },
+        content: { type: 'string', description: 'Plain text or markdown content.' },
+        block_type: {
+          type: 'string',
+          description:
+            'paragraph|heading_1|heading_2|heading_3|bulleted_list_item|numbered_list_item|to_do|quote|callout',
+        },
+      },
+      required: ['block_id', 'content'],
+    },
+    handler: async ({ block_id, content, block_type = 'paragraph' }) => {
+      const children = markdownToBlocks(content, block_type);
+      const resp = await call('PATCH', '/v1/blocks/{block_id}/children', { block_id, _rawBody: { children } });
+      return text(resp);
+    },
+  },
+  {
+    name: 'append_code_block',
+    description:
+      'Appends a code block with syntax highlighting to a Notion page. Use specifically for adding code snippets. Supports all major programming languages. For regular text use append_text_content.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        block_id: { type: 'string', description: 'Parent block/page ID.' },
+        code: { type: 'string', description: 'Code content.' },
+        language: { type: 'string', description: 'Code language. Defaults to plain text.' },
+        caption: { type: 'string', description: 'Optional caption.' },
+      },
+      required: ['block_id', 'code'],
+    },
+    handler: async ({ block_id, code, language = 'plain text', caption }) => {
+      const child = {
+        object: 'block',
+        type: 'code',
+        code: {
+          rich_text: richText(code),
+          language,
+          ...(caption ? { caption: richText(caption) } : {}),
+        },
+      };
+      const resp = await call('PATCH', '/v1/blocks/{block_id}/children', {
+        block_id,
+        _rawBody: { children: [child] },
+      });
+      return text(resp);
+    },
+  },
+  {
+    name: 'append_table_block',
+    description:
+      'Appends a table to a Notion page from a 2D array of values. Automatically creates table_row children. Use when adding structured tabular data to a page.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        block_id: { type: 'string', description: 'Parent block/page ID.' },
+        headers: { type: 'array', description: 'Array of column headers.' },
+        rows: { type: 'array', description: '2D array of row values.' },
+      },
+      required: ['block_id', 'headers', 'rows'],
+    },
+    handler: async ({ block_id, headers, rows }) => {
+      const head = Array.isArray(headers) ? headers : [];
+      const bodyRows = Array.isArray(rows) ? rows : [];
+      const toCell = (v) => richText(v == null ? '' : String(v));
+      const tableChildren = [
+        { object: 'block', type: 'table_row', table_row: { cells: head.map((h) => toCell(h)) } },
+        ...bodyRows.map((r) => ({
+          object: 'block',
+          type: 'table_row',
+          table_row: { cells: (Array.isArray(r) ? r : []).map((v) => toCell(v)) },
+        })),
+      ];
+      const table = {
+        object: 'block',
+        type: 'table',
+        table: {
+          table_width: head.length,
+          has_column_header: true,
+          has_row_header: false,
+          children: tableChildren,
+        },
+      };
+      const resp = await call('PATCH', '/v1/blocks/{block_id}/children', {
+        block_id,
+        _rawBody: { children: [table] },
+      });
+      return text(resp);
+    },
+  },
+  {
+    name: 'get_all_block_children_recursive',
+    description:
+      'Retrieves all nested block children of a block or page recursively. Follows has_children flags automatically. Returns complete block tree. Use when you need the full content structure of any block.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        block_id: { type: 'string', description: 'Block or page ID.' },
+        max_depth: { type: 'number', description: 'Maximum recursion depth. Defaults to 5.' },
+      },
+      required: ['block_id'],
+    },
+    handler: async ({ block_id, max_depth = 5 }) => text({ block_id, children: await listAllChildren(block_id, max_depth) }),
+  },
+  {
+    name: 'find_page_by_title',
+    description:
+      'Searches Notion workspace for pages matching a title query. Returns page IDs, titles and parent info. Use this first to find a page before reading or updating it. For databases use find_database_by_title.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        title_query: { type: 'string', description: 'Title query text.' },
+        page_size: { type: 'number', description: 'Page size. Defaults to 10.' },
+      },
+      required: ['title_query'],
+    },
+    handler: async ({ title_query, page_size = 10 }) => {
+      const resp = await call('POST', '/v1/search', {
+        _rawBody: { query: title_query, page_size, filter: { property: 'object', value: 'page' } },
+      });
+      const out = (resp?.results || []).map((x) => ({ id: x.id, title: pageTitle(x), parent: x.parent }));
+      return text({ results: out, has_more: resp?.has_more, next_cursor: resp?.next_cursor });
+    },
+  },
+  {
+    name: 'find_database_by_title',
+    description:
+      'Searches Notion workspace for databases matching a name query. Returns database IDs and schema info. Use this to find a database ID before querying it. For pages use find_page_by_title.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        title_query: { type: 'string', description: 'Database name query.' },
+        page_size: { type: 'number', description: 'Page size. Defaults to 10.' },
+      },
+      required: ['title_query'],
+    },
+    handler: async ({ title_query, page_size = 10 }) => {
+      const resp = await call('POST', '/v1/search', {
+        _rawBody: { query: title_query, page_size, filter: { property: 'object', value: 'database' } },
+      });
+      const out = (resp?.results || []).map((x) => ({ id: x.id, title: (x.title || []).map((t) => t.plain_text).join(''), properties: x.properties }));
+      return text({ results: out, has_more: resp?.has_more, next_cursor: resp?.next_cursor });
+    },
+  },
+  {
+    name: 'list_all_workspace_pages',
+    description:
+      "Lists all pages accessible to this integration in the Notion workspace. Returns page IDs, titles and parent hierarchy. Use as a discovery tool when you don't know which pages exist.",
+    inputSchema: {
+      type: 'object',
+      properties: {
+        page_size: { type: 'number', description: 'Page size. Defaults to 50.' },
+        start_cursor: { type: 'string', description: 'Pagination cursor.' },
+      },
+      required: [],
+    },
+    handler: async ({ page_size = 50, start_cursor }) => {
+      const resp = await call('POST', '/v1/search', {
+        _rawBody: { page_size, start_cursor, filter: { property: 'object', value: 'page' } },
+      });
+      const out = (resp?.results || []).map((x) => ({ id: x.id, title: pageTitle(x), parent: x.parent }));
+      return text({ results: out, has_more: resp?.has_more, next_cursor: resp?.next_cursor });
+    },
+  },
+  {
+    name: 'list_all_workspace_databases',
+    description:
+      'Lists all databases accessible to this integration in the Notion workspace. Returns database IDs, names and property schemas. Use to discover available databases before querying.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        page_size: { type: 'number', description: 'Page size. Defaults to 50.' },
+        start_cursor: { type: 'string', description: 'Pagination cursor.' },
+      },
+      required: [],
+    },
+    handler: async ({ page_size = 50, start_cursor }) => {
+      const resp = await call('POST', '/v1/search', {
+        _rawBody: { page_size, start_cursor, filter: { property: 'object', value: 'database' } },
+      });
+      const out = (resp?.results || []).map((x) => ({ id: x.id, title: (x.title || []).map((t) => t.plain_text).join(''), properties: x.properties }));
+      return text({ results: out, has_more: resp?.has_more, next_cursor: resp?.next_cursor });
+    },
+  },
+  {
+    name: 'add_comment_to_page',
+    description:
+      'Adds a top-level comment to a Notion page. Use for adding review notes, feedback or status updates to a page. For replying to existing discussion threads use reply_to_comment.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        page_id: { type: 'string', description: 'Target page ID.' },
+        comment_text: { type: 'string', description: 'Comment text.' },
+      },
+      required: ['page_id', 'comment_text'],
+    },
+    handler: async ({ page_id, comment_text }) =>
+      text(
+        await call('POST', '/v1/comments', {
+          _rawBody: { parent: { page_id }, rich_text: richText(comment_text) },
+        })
+      ),
+  },
+  {
+    name: 'reply_to_comment',
+    description:
+      'Replies to an existing comment thread on a Notion page. Requires the discussion_id from an existing comment. Use to continue a conversation thread. For new top-level comments use add_comment_to_page.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        discussion_id: { type: 'string', description: 'Discussion thread ID.' },
+        reply_text: { type: 'string', description: 'Reply text.' },
+      },
+      required: ['discussion_id', 'reply_text'],
+    },
+    handler: async ({ discussion_id, reply_text }) =>
+      text(
+        await call('POST', '/v1/comments', {
+          _rawBody: { discussion_id, rich_text: richText(reply_text) },
+        })
+      ),
+  },
+];
+
+export const tools = [...baseTools, ...smartTools];

package/dist/integrations/salesforce/.env

@@ -0,0 +1,8 @@
+SALESFORCE_CLIENT_ID=fake_client_id_for_testing
+SALESFORCE_CLIENT_SECRET=fake_client_secret
+SALESFORCE_USERNAME=test@test.com
+SALESFORCE_PASSWORD=fakepassword
+SALESFORCE_SECURITY_TOKEN=faketoken123
+SALESFORCE_LOGIN_URL=https://login.salesforce.com
+SALESFORCE_API_VERSION=v59.0
+SALESFORCE_INSTANCE_URL=https://fake.salesforce.com

package/dist/integrations/salesforce/.env.example

@@ -0,0 +1,15 @@
+# Connected App (required for npx adoptai-salesforce-mcp setup OAuth)
+SALESFORCE_CLIENT_ID=
+SALESFORCE_CLIENT_SECRET=
+
+# Production login; use https://test.salesforce.com for sandboxes
+SALESFORCE_LOGIN_URL=https://login.salesforce.com
+
+# Optional: fixed OAuth callback (must match Connected App redirect URL)
+# SALESFORCE_REDIRECT_URI=http://127.0.0.1:8765/callback
+
+# Optional API version for tools (default v59.0). MCP config usually sets this after OAuth.
+# SALESFORCE_API_VERSION=v59.0
+
+# Optional: instance URL if not injected by MCP env (normally set automatically at setup)
+# SALESFORCE_INSTANCE_URL=https://yourinstance.salesforce.com