adoptai-mcp 1.0.0

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

@@ -0,0 +1,386 @@
+#!/usr/bin/env node
+/**
+ * Publish Salesforce tools to adopt.ai (Docs/publisher.md).
+ * Root .env: ADOPTAI_BEARER_TOKEN, ADOPTAI_INTEGRATION_ID, optional ADOPTAI_API_BASE_URL,
+ * SALESFORCE_PUBLISH_API_VERSION (default v59.0).
+ *
+ * Secrets: salesforce_instance_url, bearer_token; optional salesforce_einstein_platform_url (default https://api.einstein.ai/v2).
+ *
+ *   node publish-to-adoptai.js
+ */
+import axios from 'axios';
+import { existsSync, readFileSync } from 'fs';
+import { dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+import { SMART_PUBLISH_SPECS } from './publish-smart-specs.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) || 400;
+
+const BEARER_TOKEN = process.env.ADOPTAI_BEARER_TOKEN;
+const INTEGRATION_ID = process.env.ADOPTAI_INTEGRATION_ID;
+
+const API_VER_RAW = process.env.SALESFORCE_PUBLISH_API_VERSION || 'v59.0';
+const API_VER = API_VER_RAW.startsWith('v') ? API_VER_RAW : `v${API_VER_RAW}`;
+const API_VER_NUM = API_VER.replace(/^v/i, '');
+
+const INSTANCE = '{secrets.salesforce_instance_url}';
+const EINSTEIN_BASE = '{secrets.salesforce_einstein_platform_url}';
+
+const APP_NAME = 'SALESFORCE';
+
+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 publishUrlPrefix(urlKind) {
+  switch (urlKind) {
+    case 'apex':
+      return `${INSTANCE}/services/apexrest`;
+    case 'data-catalog':
+      return `${INSTANCE}/services/data`;
+    case 'tooling':
+      return `${INSTANCE}/services/data/${API_VER}/tooling`;
+    case 'ui-api':
+      return `${INSTANCE}/services/data/${API_VER}/ui-api`;
+    case 'graphql':
+      return `${INSTANCE}/services/data/${API_VER}/graphql`;
+    case 'bulk-v1-async':
+      return `${INSTANCE}/services/async/${API_VER_NUM}`;
+    case 'soap-metadata':
+      return `${INSTANCE}/services/Soap/m/${API_VER_NUM}`;
+    case 'einstein-platform':
+      return EINSTEIN_BASE.replace(/\/$/, '');
+    default:
+      return `${INSTANCE}/services/data/${API_VER}`;
+  }
+}
+
+function fullToolUrl(urlKind, pathTemplate) {
+  if (urlKind === 'graphql') {
+    return publishUrlPrefix('graphql');
+  }
+  if (urlKind === 'einstein-platform') {
+    const base = publishUrlPrefix('einstein-platform');
+    const p =
+      !pathTemplate || pathTemplate === ''
+        ? ''
+        : pathTemplate.startsWith('/')
+          ? pathTemplate
+          : `/${pathTemplate}`;
+    return base + p;
+  }
+  if (urlKind === 'soap-metadata') {
+    return publishUrlPrefix('soap-metadata');
+  }
+  const p =
+    pathTemplate == null || pathTemplate === ''
+      ? ''
+      : pathTemplate.startsWith('/')
+        ? pathTemplate
+        : `/${pathTemplate}`;
+  return publishUrlPrefix(urlKind) + p;
+}
+
+function pathParamsFromTemplate(pathTemplate) {
+  const s = String(pathTemplate ?? '');
+  return [...s.matchAll(/\{([^}]+)\}/g)].map((m) => m[1]);
+}
+
+function pathArgKeySet(pathTemplate, pathPlaceholderArgs) {
+  const segs = pathParamsFromTemplate(pathTemplate);
+  const map = pathPlaceholderArgs || {};
+  return new Set(segs.map((s) => map[s] || s));
+}
+
+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;
+}
+
+const PLACEHOLDER_RE = /^\{[a-zA-Z0-9_]+\}$/;
+
+function buildPayload(tool) {
+  const spec = SMART_PUBLISH_SPECS[tool.name] || null;
+
+  const method = String((spec?.method ?? tool.method) || '').toUpperCase();
+  const urlKind = spec?.urlKind ?? tool.urlKind;
+  let pathTemplate =
+    spec?.path !== undefined ? spec.path : tool.path != null ? tool.path : '';
+
+  if (!method || !urlKind) {
+    throw new Error('missing method or urlKind');
+  }
+  const pathOk =
+    urlKind === 'graphql' ||
+    urlKind === 'soap-metadata' ||
+    typeof pathTemplate === 'string';
+  if (!pathOk) {
+    throw new Error('missing path');
+  }
+
+  const inputSchema = spec?.inputSchemaOverride ?? tool.inputSchema;
+  const properties = inputSchema?.properties || {};
+  const required = inputSchema?.required || [];
+
+  const pathKeys = pathArgKeySet(pathTemplate, spec?.pathPlaceholderArgs);
+  const omit = new Set(spec?.omitArgsFromHttp || []);
+
+  const fullUrl = fullToolUrl(urlKind, pathTemplate);
+  const useQuery = method === 'GET' || method === 'DELETE';
+
+  let query_params = null;
+  let body = null;
+
+  if (spec?.queryParamsLiteral) {
+    query_params = { ...spec.queryParamsLiteral };
+  } else if (spec?.queryParamsExplicit) {
+    query_params = { ...spec.queryParamsExplicit };
+  }
+
+  if (spec?.rawStringBodyArg) {
+    body = `{${spec.rawStringBodyArg}}`;
+  } else if (spec?.wholeBodyPlaceholderArg) {
+    body = `{${spec.wholeBodyPlaceholderArg}}`;
+  } else if (spec?.bodyLiteral) {
+    body = { ...spec.bodyLiteral };
+  } else if (spec?.bodyExplicit) {
+    body = {};
+    for (const [k, v] of Object.entries(spec.bodyExplicit)) {
+      if (typeof v === 'string' && PLACEHOLDER_RE.test(v)) {
+        body[k] = v;
+      } else {
+        body[k] = v;
+      }
+    }
+  } else if (urlKind === 'graphql') {
+    const nk = Object.keys(properties).filter((k) => !pathKeys.has(k) && !omit.has(k));
+    body = placeholderMap(nk);
+  } else if (useQuery && !spec?.queryParamsExplicit && !spec?.queryParamsLiteral) {
+    const nk = Object.keys(properties).filter((k) => !pathKeys.has(k) && !omit.has(k));
+    query_params = placeholderMap(nk);
+  } else if (!useQuery) {
+    const nk = Object.keys(properties).filter((k) => !pathKeys.has(k) && !omit.has(k));
+    body = placeholderMap(nk);
+  }
+
+  if (
+    body &&
+    typeof body === 'object' &&
+    !spec?.bodyLiteral &&
+    !spec?.rawStringBodyArg &&
+    !spec?.wholeBodyPlaceholderArg &&
+    Object.keys(body).length === 0
+  ) {
+    body = null;
+  }
+  if (
+    query_params &&
+    typeof query_params === 'object' &&
+    Object.keys(query_params).length === 0
+  ) {
+    query_params = null;
+  }
+
+  const args = Object.fromEntries(
+    Object.entries(properties).map(([k, v]) => [k, mapArgType(v)])
+  );
+
+  const baseHeaders = {
+    authorization: '{secrets.bearer_token}',
+    'content-type': spec?.contentTypeOverride || 'application/json',
+  };
+  const extra = spec?.extraHeaders || {};
+  for (const [k, v] of Object.entries(extra)) {
+    baseHeaders[k.toLowerCase()] = v;
+  }
+
+  let description = (tool.description || '').slice(0, 7500);
+  if (spec?.note) {
+    description = `${description}\n\n[HTTP catalog] ${spec.note}`.slice(0, 8000);
+  }
+
+  return {
+    integration_id: INTEGRATION_ID,
+    name: `${APP_NAME}_${String(tool.name).toUpperCase()}`,
+    description,
+    tool_spec: {
+      url: fullUrl,
+      method,
+      headers: baseHeaders,
+      body,
+      query_params,
+    },
+    input_schema: {
+      args,
+      required,
+    },
+    is_custom_integration: false,
+    is_published: false,
+    is_browser_call: false,
+  };
+}
+
+function isPublishableTool(tool) {
+  if (!tool?.name) return false;
+  if (SMART_PUBLISH_SPECS[tool.name]) return true;
+  return Boolean(
+    tool.method &&
+      tool.urlKind &&
+      (tool.urlKind === 'graphql' || typeof tool.path === 'string')
+  );
+}
+
+async function publishAll() {
+  const { tools } = await import('./tools.js');
+  const publishable = tools.filter(isPublishableTool);
+  const skipped = tools.length - publishable.length;
+
+  console.log(
+    `Publishing ${publishable.length} Salesforce tools (${skipped} skipped) to 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 skipDup = 0;
+  let failed = 0;
+
+  for (const tool of publishable) {
+    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}`);
+        skipDup++;
+      } 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 (409):   ${skipDup}`);
+  console.log(`❌ Failed:          ${failed}`);
+  console.log(`⏭️  Skipped (no spec): ${skipped}`);
+  console.log(`─────────────────────────────────`);
+  console.log(`Total tools in tools.js: ${tools.length}`);
+}
+
+publishAll().catch((e) => {
+  console.error(e);
+  process.exit(1);
+});

package/dist/integrations/salesforce/scripts/extract-postman.mjs

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+/**
+ * Extract REST tools from specs/split/salesforce-rest.json (Section B).
+ * Outputs integrations/salesforce/endpoints.json
+ */
+import { readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SPEC = join(__dirname, '../../../specs/split/salesforce-rest.json');
+const OUT = join(__dirname, '../endpoints.json');
+
+function buildVarMap(collection) {
+  const map = {};
+  for (const v of collection.variable || []) {
+    map[v.key] = v.value ?? '';
+  }
+  return map;
+}
+
+function resolveTemplate(str, map) {
+  if (str == null) return str;
+  let out = String(str);
+  for (const [k, v] of Object.entries(map)) {
+    out = out.split(`{{${k}}}`).join(v);
+  }
+  return out;
+}
+
+const SKIP_PATH_RE =
+  /\/oauth|\/token|\/login|\/logout|\/services\/oauth2|\/webhook|\/Soap\/|\/soap\/|soap\.jsp/i;
+
+function shouldSkipUrl(fullPath) {
+  const p = fullPath || '';
+  return SKIP_PATH_RE.test(p);
+}
+
+/**
+ * Parse Salesforce request URL into { urlKind, path } for tools.
+ * - versioned: path under /services/data/vXX/...
+ * - data-catalog: GET /services/data (list API versions)
+ * - apex: /services/apexrest/...
+ */
+function parseSalesforceUrl(rawUrl, varMap) {
+  const resolved = resolveTemplate(rawUrl, varMap);
+  const noQuery = resolved.split('?')[0];
+  const pathOnly = noQuery.replace(/^https?:\/\/[^/?#]+/i, '');
+
+  if (shouldSkipUrl(pathOnly)) return null;
+
+  if (pathOnly.startsWith('/services/apexrest')) {
+    let rest = pathOnly.slice('/services/apexrest'.length);
+    if (!rest || rest === '/') rest = '/{urlMapping}';
+    rest = rest.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, '{$1}');
+    return { urlKind: 'apex', path: rest };
+  }
+
+  if (pathOnly === '/services/data' || pathOnly === '/services/data/') {
+    return { urlKind: 'data-catalog', path: '/' };
+  }
+
+  if (!pathOnly.startsWith('/services/data/')) {
+    return { urlKind: 'versioned', path: pathOnly };
+  }
+
+  const afterData = pathOnly.slice('/services/data/'.length);
+  const m = afterData.match(/^(v[0-9.]+)(\/.*)?$/);
+  if (m) {
+    let rest = m[2] || '/';
+    if (rest === '') rest = '/';
+    rest = rest.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, '{$1}');
+    return { urlKind: 'versioned', path: rest };
+  }
+
+  return { urlKind: 'data-catalog', path: '/' };
+}
+
+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';
+}
+
+function descFromPostman(req, itemName) {
+  const d = req.description;
+  if (typeof d === 'string') return d.slice(0, 500);
+  if (d && typeof d === 'object' && d.content) return String(d.content).slice(0, 500);
+  return itemName;
+}
+
+function generateToolName(method, path, itemName) {
+  const clean = (itemName || '')
+    .replace(/[^a-zA-Z0-9_]+/g, '_')
+    .replace(/^_+|_+$/g, '')
+    .toLowerCase();
+  if (clean && !clean.includes('/') && clean.length < 60) return clean.slice(0, 60);
+
+  const prefix =
+    { GET: 'get', POST: 'create', PUT: 'update', PATCH: 'update', DELETE: 'delete' }[method] ||
+    method.toLowerCase();
+  let cleanPath = path
+    .replace(/\/v[0-9.]+\//g, '/')
+    .replace(/\{([^}]+)\}/g, 'by_$1')
+    .replace(/\//g, '_')
+    .replace(/^_+|_+$/g, '')
+    .replace(/_+/g, '_')
+    .toLowerCase()
+    .slice(0, 50);
+  return `${prefix}_${cleanPath}`.replace(/_+/g, '_').slice(0, 60);
+}
+
+function buildSchema(req, normalizedPath, varMap) {
+  const properties = {};
+  const required = [];
+
+  for (const [, name] of normalizedPath.matchAll(/\{([^}]+)\}/g)) {
+    properties[name] = { type: 'string', description: `Path parameter: ${name}` };
+    required.push(name);
+  }
+
+  const seen = new Set();
+  if (typeof req.url === 'object' && req.url?.query) {
+    for (const param of req.url.query) {
+      if (!param.key || param.disabled || seen.has(param.key)) continue;
+      seen.add(param.key);
+      if (properties[param.key]) continue;
+      properties[param.key] = {
+        type: inferType(param.value),
+        description: param.description || `Query: ${param.key}`,
+      };
+    }
+  }
+
+  if (req.body?.mode === 'raw' && req.body.raw) {
+    try {
+      const bodyJson = JSON.parse(req.body.raw);
+      for (const [key, value] of Object.entries(bodyJson)) {
+        if (properties[key]) continue;
+        properties[key] = { type: inferType(String(value)), description: `Body: ${key}` };
+      }
+    } catch {
+      /* not JSON */
+    }
+  }
+
+  if (req.body?.mode === 'urlencoded' || req.body?.mode === 'formdata') {
+    const items = req.body.urlencoded || req.body.formdata || [];
+    for (const item of items) {
+      if (!item.key || properties[item.key]) continue;
+      properties[item.key] = { type: 'string', description: item.description || item.key };
+    }
+  }
+
+  return { type: 'object', properties, required: [...new Set(required)] };
+}
+
+function extractRequests(items, varMap, out) {
+  for (const item of items || []) {
+    if (Array.isArray(item.item)) {
+      extractRequests(item.item, varMap, out);
+    } else if (item.request) {
+      const req = item.request;
+      const method = String(req.method || 'GET').toUpperCase();
+      if (['OPTIONS', 'HEAD', 'TRACE'].includes(method)) continue;
+
+      let rawUrl = typeof req.url === 'string' ? req.url : req.url?.raw || '';
+      const parsed = parseSalesforceUrl(rawUrl, varMap);
+      if (!parsed) continue;
+
+      const { urlKind, path } = parsed;
+      const name = generateToolName(method, path, item.name);
+      out.push({
+        name,
+        description: descFromPostman(req, item.name),
+        method,
+        path,
+        urlKind,
+        inputSchema: buildSchema(req, path, varMap),
+      });
+    }
+  }
+}
+
+const collection = JSON.parse(readFileSync(SPEC, 'utf8'));
+const varMap = buildVarMap(collection);
+const endpoints = [];
+extractRequests(collection.item, varMap, endpoints);
+
+const seenKeys = new Set();
+const deduped = [];
+for (const e of endpoints) {
+  const key = `${e.method}|${e.urlKind}|${e.path}`;
+  if (seenKeys.has(key)) continue;
+  seenKeys.add(key);
+  deduped.push(e);
+}
+
+const used = new Map();
+for (const e of deduped) {
+  let n = e.name;
+  let c = 1;
+  while (used.has(n)) {
+    c += 1;
+    n = `${e.name}_v${c}`;
+  }
+  used.set(n, true);
+  e.name = n;
+}
+
+writeFileSync(
+  OUT,
+  JSON.stringify({ generatedAt: new Date().toISOString(), endpoints: deduped }, null, 2)
+);
+console.error('Wrote', OUT, 'count', deduped.length);