adoptai-mcp 1.0.0

package/dist/integrations/notion/publish-to-adoptai.js

@@ -0,0 +1,271 @@
+#!/usr/bin/env node
+/**
+ * Publish integrations/notion/tools.js (31 base + 17 smart) to adopt.ai.
+ * See Docs/publisher.md — env: ADOPTAI_BEARER_TOKEN, ADOPTAI_INTEGRATION_ID, ADOPTAI_API_BASE_URL (optional).
+ *
+ *   node publish-to-adoptai.js
+ */
+import axios from 'axios';
+import { existsSync, readFileSync } from 'fs';
+import { dirname, join, resolve } from 'path';
+import { fileURLToPath } from 'url';
+import { smartTools, tools } from './tools.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+function loadEnvFile(filePath) {
+  if (!existsSync(filePath)) return;
+  const text = readFileSync(filePath, 'utf8');
+  for (const line of text.split('\n')) {
+    const t = line.trim();
+    if (!t || t.startsWith('#')) continue;
+    const eq = t.indexOf('=');
+    if (eq <= 0) continue;
+    const key = t.slice(0, eq).trim();
+    let val = t.slice(eq + 1).trim();
+    if (
+      (val.startsWith('"') && val.endsWith('"')) ||
+      (val.startsWith("'") && val.endsWith("'"))
+    ) {
+      val = val.slice(1, -1);
+    }
+    process.env[key] = val;
+  }
+}
+
+loadEnvFile(resolve(__dirname, '../../.env'));
+
+const ADOPTAI_API_BASE = (
+  process.env.ADOPTAI_API_BASE_URL || 'https://api.adopt.ai'
+).replace(/\/$/, '');
+const ADOPTAI_API = `${ADOPTAI_API_BASE}/v1/mcp-integrations/add-update-integration-tool`;
+const PUBLISH_DELAY_MS = Number(process.env.ADOPTAI_PUBLISH_DELAY_MS) || 300;
+
+const BEARER_TOKEN = process.env.ADOPTAI_BEARER_TOKEN;
+const INTEGRATION_ID = process.env.ADOPTAI_INTEGRATION_ID;
+
+const BASE_URL = 'https://api.notion.com';
+const APP_NAME = 'NOTION';
+const NOTION_VERSION = '2025-09-03';
+
+if (!BEARER_TOKEN) throw new Error('ADOPTAI_BEARER_TOKEN not set in ../../.env');
+if (!INTEGRATION_ID) throw new Error('ADOPTAI_INTEGRATION_ID not set in ../../.env');
+
+function pathParamsFromTemplate(pathTemplate) {
+  return [...String(pathTemplate).matchAll(/\{([^}]+)\}/g)].map((m) => m[1]);
+}
+
+function mapArgType(prop) {
+  if (!prop || typeof prop !== 'object') return 'string';
+  const t = prop.type;
+  if (t === 'integer') return 'number';
+  if (t === 'number' || t === 'boolean' || t === 'object' || t === 'array') {
+    return t;
+  }
+  return 'string';
+}
+
+function placeholderMap(keys) {
+  if (!keys?.length) return null;
+  return Object.fromEntries(keys.map((k) => [k, `{${k}}`]));
+}
+
+async function fetchExistingToolIdsByName() {
+  const map = new Map();
+  try {
+    const res = await axios.get(
+      `${ADOPTAI_API_BASE}/v1/mcp-integrations/get-integration-tools`,
+      {
+        params: { integration_id: INTEGRATION_ID },
+        headers: {
+          Authorization: `Bearer ${BEARER_TOKEN}`,
+          Accept: 'application/json',
+        },
+      }
+    );
+    if (Array.isArray(res.data)) {
+      for (const t of res.data) {
+        if (t?.name && t?.id) map.set(t.name, t.id);
+      }
+    }
+  } catch (err) {
+    console.warn(
+      '⚠️  Could not load existing tools; updates may 409:',
+      err.response?.data?.detail || err.message
+    );
+  }
+  return map;
+}
+
+function buildToolsForPublish() {
+  const manifest = JSON.parse(
+    readFileSync(join(__dirname, 'endpoints.json'), 'utf8')
+  );
+  const inputByName = new Map(
+    tools.map((t) => [t.name, t.inputSchema])
+  );
+
+  const base = manifest.endpoints.map((ep) => ({
+    name: ep.name,
+    description: ep.description,
+    method: ep.method,
+    path: ep.path,
+    inputSchema: inputByName.get(ep.name) || ep.inputSchema,
+  }));
+
+  const smart = smartTools.map((t) => {
+    if (!t.publish?.method || !t.publish?.path) {
+      throw new Error(`Smart tool "${t.name}" missing publish.method/path`);
+    }
+    return {
+      name: t.name,
+      description: t.description,
+      method: t.publish.method,
+      path: t.publish.path,
+      inputSchema: t.inputSchema,
+    };
+  });
+
+  const merged = [...base, ...smart];
+  if (merged.length !== 48) {
+    console.warn(`⚠️  Expected 48 tools, got ${merged.length}`);
+  }
+  return merged;
+}
+
+/**
+ * @param {{ name: string, description?: string, method: string, path: string, inputSchema?: object }} tool
+ */
+function buildPayload(tool) {
+  const method = String(tool.method).toUpperCase();
+  const pathTemplate = tool.path;
+  const pathParams = pathParamsFromTemplate(pathTemplate);
+  const pathSet = new Set(pathParams);
+  const properties = tool.inputSchema?.properties || {};
+
+  const nonPathKeys = Object.keys(properties).filter((k) => !pathSet.has(k));
+
+  const useQuery = method === 'GET' || method === 'DELETE';
+
+  const paramPlaceholders = placeholderMap(nonPathKeys);
+
+  let body = null;
+  let query_params = null;
+  if (useQuery) {
+    query_params = paramPlaceholders;
+  } else {
+    body = paramPlaceholders;
+  }
+
+  const args = Object.fromEntries(
+    Object.entries(properties).map(([k, v]) => [k, mapArgType(v)])
+  );
+
+  return {
+    integration_id: INTEGRATION_ID,
+    name: `${APP_NAME}_${String(tool.name).toUpperCase()}`,
+    description: tool.description || '',
+    tool_spec: {
+      url: BASE_URL + pathTemplate,
+      method,
+      headers: {
+        authorization: '{secrets.bearer_token}',
+        'content-type': 'application/json',
+        'notion-version': NOTION_VERSION,
+      },
+      body,
+      query_params,
+    },
+    input_schema: {
+      args,
+      required: tool.inputSchema?.required || [],
+    },
+    is_custom_integration: false,
+    is_published: false,
+    is_browser_call: false,
+  };
+}
+
+async function publishAll() {
+  const toPublish = buildToolsForPublish();
+  console.log(
+    `Publishing ${toPublish.length} Notion tools (adopt API: ${ADOPTAI_API_BASE})...\n`
+  );
+
+  const existingIds = await fetchExistingToolIdsByName();
+  if (existingIds.size) {
+    console.log(`Loaded ${existingIds.size} existing tool id(s) for upsert.\n`);
+  }
+
+  let published = 0;
+  let updated = 0;
+  let skipped = 0;
+  let failed = 0;
+
+  for (const tool of toPublish) {
+    let payload;
+    try {
+      payload = buildPayload(tool);
+    } catch (e) {
+      console.error(`❌ Skip: ${tool.name} — ${e.message}`);
+      failed++;
+      continue;
+    }
+
+    const existingId = existingIds.get(payload.name);
+    if (existingId) {
+      payload.id = existingId;
+    }
+
+    try {
+      await axios.post(ADOPTAI_API, payload, {
+        headers: {
+          Authorization: `Bearer ${BEARER_TOKEN}`,
+          'Content-Type': 'application/json',
+        },
+      });
+
+      if (existingId) {
+        console.log(`✅ Updated: ${payload.name}`);
+        updated++;
+      } else {
+        console.log(`✅ Published: ${payload.name}`);
+        published++;
+      }
+
+      await new Promise((r) => setTimeout(r, PUBLISH_DELAY_MS));
+    } catch (err) {
+      const status = err.response?.status;
+      const data = err.response?.data;
+      const message =
+        (typeof data?.detail === 'string' && data.detail) ||
+        data?.message ||
+        err.message;
+
+      const isDuplicate =
+        status === 409 &&
+        typeof message === 'string' &&
+        message.toLowerCase().includes('already exists');
+
+      if (isDuplicate) {
+        console.log(`⏭️  Skipped (already exists, no id): ${payload.name}`);
+        skipped++;
+      } else {
+        console.error(`❌ Failed: ${payload.name} — ${status}: ${message}`);
+        failed++;
+      }
+
+      await new Promise((r) => setTimeout(r, PUBLISH_DELAY_MS));
+    }
+  }
+
+  console.log(`\n─────────────────────────────────`);
+  console.log(`✅ Published (new): ${published}`);
+  console.log(`✅ Updated:         ${updated}`);
+  console.log(`⏭️  Skipped:         ${skipped}`);
+  console.log(`❌ Failed:          ${failed}`);
+  console.log(`─────────────────────────────────`);
+  console.log(`Total: ${toPublish.length} tools`);
+}
+
+publishAll();

package/dist/integrations/notion/scripts/generate-endpoints.mjs

@@ -0,0 +1,306 @@
+#!/usr/bin/env node
+/**
+ * Generates integrations/notion/endpoints.json from Notion Postman collections.
+ * Follows docs/instructions.md Section B (recursive extract, path/query/body schema).
+ */
+import { readFileSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const NOTION_DIR = join(__dirname, '..');
+const REPO_ROOT = join(__dirname, '..', '..', '..');
+
+const SPEC_PRIMARY = join(REPO_ROOT, 'specs/notion/Notion API (2025-09-03).postman_collection.json');
+const SPEC_LEGACY = join(REPO_ROOT, 'specs/notion/Notion API.postman_collection.json');
+const OUT = join(NOTION_DIR, 'endpoints.json');
+
+function resolveVariable(str, variables) {
+  let s = str ?? '';
+  for (const v of variables || []) {
+    s = s.replaceAll(`{{${v.key}}}`, v.value ?? '');
+  }
+  return s;
+}
+
+function extractAllRequests(items) {
+  const requests = [];
+  for (const item of items || []) {
+    if (Array.isArray(item.item)) {
+      requests.push(...extractAllRequests(item.item));
+    } else if (item.request) {
+      requests.push({ name: item.name, request: item.request });
+    }
+  }
+  return requests;
+}
+
+function inferType(value) {
+  if (value == null) return 'string';
+  const v = String(value).toLowerCase().trim();
+  if (v === '<integer>' || v === '<number>') return 'number';
+  if (v === '<boolean>') return 'boolean';
+  if (v === '<datetime>' || v === '<date>') return 'string';
+  if (v === '<array>') return 'array';
+  if (v === '<object>') return 'object';
+  if (!Number.isNaN(Number(v)) && v !== '') return 'number';
+  if (v === 'true' || v === 'false') return 'boolean';
+  return 'string';
+}
+
+/**
+ * Path segment → MCP path token. Do not resolve {{var}} to empty collection defaults;
+ * those must stay as path parameters (instructions §B1 / §G).
+ */
+function normalizeSegment(seg) {
+  if (!seg) return '';
+  const t = String(seg).trim();
+  const br = /^\{\{([^}]+)\}\}$/.exec(t);
+  if (br) return `{${br[1]}}`;
+  if (t.startsWith(':')) return `{${t.slice(1)}}`;
+  return t.replace(/\{\{([^}]+)\}\}/g, '{$1}');
+}
+
+/**
+ * Build API path starting with /v1/... from Postman url object.
+ * Prefer path[] so {{base_url}} mismatch (e.g. .../v1 + /v1/...) cannot duplicate segments.
+ */
+function buildApiPath(urlObj, variables) {
+  if (typeof urlObj === 'string') {
+    const resolved = resolveVariable(urlObj, variables);
+    try {
+      const u = new URL(resolved.split('?')[0]);
+      let p = u.pathname.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, '{$1}');
+      if (!p.startsWith('/')) p = '/' + p;
+      return p;
+    } catch {
+      return '/';
+    }
+  }
+  const segments = (urlObj.path || []).map((s) => normalizeSegment(s));
+  const p = '/' + segments.filter(Boolean).join('/');
+  return p.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, '{$1}');
+}
+
+function buildSchemaFromPostman(request, normalizedPath, variables) {
+  const properties = {};
+  const required = [];
+
+  const pathParams = [...normalizedPath.matchAll(/\{([^}]+)\}/g)];
+  for (const [, name] of pathParams) {
+    properties[name] = { type: 'string', description: `The ${name}` };
+    required.push(name);
+  }
+
+  const seenKeys = new Set();
+  const queryItems = typeof request.url === 'object' ? request.url.query || [] : [];
+  for (const param of queryItems) {
+    if (!param.key || seenKeys.has(param.key) || param.disabled) continue;
+    seenKeys.add(param.key);
+    properties[param.key] = {
+      type: inferType(param.value),
+      description: param.description || `The ${param.key} parameter`,
+    };
+  }
+
+  if (request.body?.mode === 'raw' && request.body.raw) {
+    try {
+      const bodyJson = JSON.parse(request.body.raw);
+      for (const [key, value] of Object.entries(bodyJson)) {
+        if (properties[key]) continue;
+        properties[key] = {
+          type: inferType(typeof value === 'object' ? JSON.stringify(value) : String(value)),
+          description: `The ${key} field`,
+        };
+      }
+    } catch {
+      /* non-JSON body */
+    }
+  }
+
+  if (request.body?.mode === 'urlencoded' || request.body?.mode === 'formdata') {
+    const items = request.body.urlencoded || request.body.formdata || [];
+    for (const row of items) {
+      if (!row.key || properties[row.key]) continue;
+      properties[row.key] = { type: 'string', description: row.description || row.key };
+    }
+  }
+
+  return { type: 'object', properties, required: [...new Set(required)] };
+}
+
+/** Stable MCP tool id from method + path (instructions §C1 priority 2). */
+function generateToolName(method, path) {
+  const prefix = {
+    GET: 'get',
+    POST: 'create',
+    PUT: 'update',
+    PATCH: 'update',
+    DELETE: 'delete',
+  }[method] || method.toLowerCase();
+
+  const cleanPath = path
+    .replace(/\/v[0-9]+\//g, '/')
+    .replace(/\/[0-9]{4}-[0-9]{2}\//g, '/')
+    .replace(/\{([^}]+)\}/g, 'by_$1')
+    .replace(/\//g, '_')
+    .replace(/^_+|_+$/g, '')
+    .replace(/_+/g, '_')
+    .toLowerCase()
+    .substring(0, 50);
+
+  return `${prefix}_${cleanPath}`;
+}
+
+function dedupeRouteKey(method, path) {
+  const norm = path.replace(/\{[^}]+\}/g, '{}');
+  return `${method} ${norm}`;
+}
+
+function methodOrder(m) {
+  const order = { GET: 0, POST: 1, PUT: 2, PATCH: 2, DELETE: 3 };
+  return order[m] ?? 9;
+}
+
+function shouldSkip(method, path, description) {
+  const p = path.toLowerCase();
+  const d = (description || '').toLowerCase();
+  if (['OPTIONS', 'HEAD', 'TRACE'].includes(method)) return true;
+  if (p.includes('/oauth') || p.includes('/token') || p.includes('/login') || p.includes('/logout') || p.includes('/webhook'))
+    return true;
+  // Skip OAuth token path explicitly
+  if (p.endsWith('/oauth/token') || p.includes('/v1/oauth/')) return true;
+  if (d.includes('deprecated')) return true;
+  return false;
+}
+
+function requestToEndpoint(item, variables, sourceLabel) {
+  const req = item.request;
+  const method = String(req.method || 'GET').toUpperCase();
+  const path = buildApiPath(req.url, variables);
+
+  const descRaw =
+    typeof req.description === 'string' ? req.description : req.description?.content || item.name || path;
+  const description = descRaw.substring(0, 200);
+
+  if (shouldSkip(method, path, descRaw)) return null;
+
+  const inputSchema = buildSchemaFromPostman(req, path, variables);
+  const name = generateToolName(method, path);
+
+  return {
+    name,
+    description: description.trim(),
+    method,
+    path,
+    inputSchema,
+    _sortMethod: methodOrder(method),
+    _dedupeKey: dedupeRouteKey(method, path),
+    _source: sourceLabel,
+  };
+}
+
+function loadCollection(path) {
+  return JSON.parse(readFileSync(path, 'utf8'));
+}
+
+function processCollection(collection, sourceLabel) {
+  const variables = collection.variable || [];
+  const items = extractAllRequests(collection.item);
+  const out = [];
+  for (const item of items) {
+    const ep = requestToEndpoint(item, variables, sourceLabel);
+    if (ep) out.push(ep);
+  }
+  return out;
+}
+
+function main() {
+  const primary = loadCollection(SPEC_PRIMARY);
+  const legacy = loadCollection(SPEC_LEGACY);
+
+  const primaryEps = processCollection(primary, '2025-09-03');
+  const legacyEps = processCollection(legacy, 'legacy');
+
+  /** Same HTTP route (ignoring path param names): prefer 2025-09-03 over legacy. */
+  const byRoute = new Map();
+  for (const ep of legacyEps) {
+    byRoute.set(ep._dedupeKey, ep);
+  }
+  for (const ep of primaryEps) {
+    byRoute.set(ep._dedupeKey, ep);
+  }
+
+  let endpoints = [...byRoute.values()];
+
+  /**
+   * Cursor MCP: combined server id + tool name must be < 60 chars.
+   * Server name is `notion-adoptai` (14) → tool names must be <= 45.
+   */
+  const MCP_SERVER_ID = 'notion-adoptai';
+  const MCP_MAX_COMBINED_LEN = 59;
+  const mcpMaxToolLen = MCP_MAX_COMBINED_LEN - MCP_SERVER_ID.length;
+  const shortToolNameByRoute = new Map([
+    ['GET /v1/pages/{page_id}/properties/{property_id}', 'get_page_property_item'],
+    ['POST /v1/file_uploads/{file_upload_id}/complete', 'complete_file_upload'],
+  ]);
+  for (const ep of endpoints) {
+    const routeKey = `${ep.method} ${ep.path}`;
+    const shortName = shortToolNameByRoute.get(routeKey);
+    if (shortName) {
+      ep.name = shortName;
+    } else if (ep.name.length > mcpMaxToolLen) {
+      ep.name = ep.name.slice(0, mcpMaxToolLen).replace(/_+$/g, '');
+    }
+  }
+
+  const seenNames = new Map();
+  for (const ep of endpoints) {
+    if (seenNames.has(ep.name)) {
+      const n = (seenNames.get(ep.name) || 1) + 1;
+      seenNames.set(ep.name, n);
+      ep.name = `${ep.name}_v${n}`;
+    } else {
+      seenNames.set(ep.name, 1);
+    }
+  }
+
+  endpoints.sort((a, b) => {
+    if (a._sortMethod !== b._sortMethod) return a._sortMethod - b._sortMethod;
+    return a.path.localeCompare(b.path);
+  });
+
+  for (const ep of endpoints) {
+    delete ep._sortMethod;
+    delete ep._source;
+    delete ep._dedupeKey;
+  }
+
+  const listComments = endpoints.find((e) => e.method === 'GET' && e.path === '/v1/comments');
+  if (listComments) {
+    listComments.inputSchema.properties.page_id = {
+      type: 'string',
+      description: 'List comments for this page (use block_id or page_id per Notion API).',
+    };
+    listComments.inputSchema.properties.start_cursor = {
+      type: 'string',
+      description: 'Pagination cursor from the previous response.',
+    };
+    listComments.inputSchema.properties.page_size = {
+      type: 'number',
+      description: 'Max number of results (Notion default applies if omitted).',
+    };
+  }
+
+  const payload = {
+    baseUrl: 'https://api.notion.com',
+    generatedAt: new Date().toISOString(),
+    sources: ['specs/notion/Notion API (2025-09-03).postman_collection.json', 'specs/notion/Notion API.postman_collection.json'],
+    endpoints,
+  };
+
+  writeFileSync(OUT, JSON.stringify(payload, null, 2), 'utf8');
+  console.log(`Wrote ${endpoints.length} endpoints → ${OUT}`);
+}
+
+main();

package/dist/integrations/notion/setup.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+import { writeConfig, removeConfig } from '../../core/config-writer.js';
+import { getCredentials, isTokenExpired } from '../../core/auth-manager.js';
+import { runAuth } from './auth.js';
+import { fileURLToPath } from 'url';
+import { dirname, resolve } from 'path';
+import readline from 'readline';
+import { tools } from './tools.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const args = process.argv.slice(2);
+const clientFlag = args.includes('--client') ? args[args.indexOf('--client') + 1] : 'cursor';
+const isRemove = args.includes('--remove');
+const isStatus = args.includes('--status');
+const SUPPORTED = ['cursor', 'claude', 'windsurf', 'vscode'];
+const toolCount = tools.length;
+
+if (isRemove) {
+  removeConfig({ client: clientFlag, serverName: 'notion-adoptai' });
+  console.log(`✅ Notion MCP removed from ${clientFlag}`);
+  process.exit(0);
+}
+
+if (isStatus) {
+  const creds = getCredentials('notion');
+  if (!creds) {
+    console.log('❌ Not authenticated');
+  } else {
+    console.log(`✅ Authenticated\n   Token: ${creds.token?.substring(0, 20)}...\n   Saved: ${creds.savedAt}`);
+  }
+  process.exit(0);
+}
+
+if (!SUPPORTED.includes(clientFlag)) {
+  console.error(`Invalid client: ${clientFlag}\nSupported: ${SUPPORTED.join(', ')}`);
+  process.exit(1);
+}
+
+async function main() {
+  const existing = getCredentials('notion');
+
+  if (existing && !isTokenExpired('notion')) {
+    console.log('✅ Already authenticated');
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const ans = await new Promise((r) =>
+      rl.question('Re-authenticate? (y/n): ', (a) => {
+        rl.close();
+        r(a.trim());
+      })
+    );
+    if (ans !== 'y') {
+      writeConfig({
+        client: clientFlag,
+        serverName: 'notion-adoptai',
+        command: 'node',
+        args: [resolve(__dirname, 'index.js')],
+        env: {},
+      });
+      process.exit(0);
+    }
+  }
+
+  await runAuth();
+
+  writeConfig({
+    client: clientFlag,
+    serverName: 'notion-adoptai',
+    command: 'node',
+    args: [resolve(__dirname, 'index.js')],
+    env: {},
+  });
+
+  console.log(`
+✅ Notion MCP is ready!
+────────────────────────────────────────
+Your AI (${clientFlag}) can now use ${toolCount} tools.
+
+Try asking:
+  "Retrieve my Notion bot user"
+  "Search my workspace for pages about the roadmap"
+
+Run health check: node core/doctor.js --client ${clientFlag}
+  `);
+}
+
+main().catch((err) => {
+  console.error('❌ Setup failed:', err.message);
+  process.exit(1);
+});