adoptai-mcp 1.0.0

package/dist/integrations/figma/auth.js

@@ -0,0 +1,48 @@
+import { saveCredentials, getCredentials } from '../../core/auth-manager.js';
+import readline from 'readline';
+
+const APP_ID = 'figma';
+
+export async function runAuth() {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+  console.log(`
+┌─────────────────────────────────────────────┐
+│  Figma Authentication                        │
+│                                             │
+│  Use a Personal Access Token (PAT).         │
+│  Figma → Settings → Security →             │
+│  Personal access tokens → Generate new token │
+└─────────────────────────────────────────────┘
+  `);
+
+  const token = await new Promise((resolve) => {
+    rl.question('Paste your Figma personal access token: ', (a) => {
+      rl.close();
+      resolve(a.trim());
+    });
+  });
+
+  if (!token || token.length < 10) throw new Error('Invalid token');
+
+  saveCredentials(APP_ID, {
+    token,
+    tokenType: 'bearer',
+    expiresAt: null,
+    savedAt: new Date().toISOString(),
+  });
+
+  console.log('✅ Token saved for Figma');
+}
+
+export function getToken() {
+  return getCredentials(APP_ID)?.token || null;
+}
+
+export function buildAuthHeaders() {
+  const token = getToken();
+  if (!token) {
+    throw new Error('Not authenticated. Run: npx adoptai-figma-mcp --client cursor');
+  }
+  return { 'X-Figma-Token': token };
+}

package/dist/integrations/figma/index.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import { createMCPServer } from '../../core/server-base.js';
+import { tools } from './tools.js';
+
+const { start } = createMCPServer({
+  name: 'figma-adoptai',
+  version: '1.0.0',
+  tools,
+});
+
+start();

package/dist/integrations/figma/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "adoptai-figma-mcp",
+  "version": "1.0.0",
+  "description": "MCP server for the Figma REST API (OpenAPI). Exposes Figma files, components, comments, variables, webhooks, and more as MCP tools.",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "adoptai-figma-mcp": "./setup.js"
+  },
+  "scripts": {
+    "start": "node index.js",
+    "setup": "node setup.js"
+  },
+  "keywords": ["mcp", "figma", "ai", "cursor", "claude", "adopt.ai"],
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "axios": "^1.6.0"
+  },
+  "adoptai": {
+    "appId": "figma",
+    "toolCount": 63,
+    "sourceFormat": "openapi_3.1",
+    "authType": "bearer",
+    "generatedAt": "2025-03-27T00:00:00.000Z"
+  }
+}

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

@@ -0,0 +1,384 @@
+#!/usr/bin/env node
+/**
+ * Publish integrations/figma/tools.js (63 tools) to adopt.ai.
+ * See docs/publisher.md — root .env:
+ *   ADOPTAI_BEARER_TOKEN, ADOPTAI_INTEGRATION_ID, ADOPTAI_API_BASE_URL (optional)
+ *
+ * Figma REST uses X-Figma-Token; adopt payload also includes authorization per publisher.md.
+ *
+ *   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 { 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);
+    }
+    if (process.env[key] === undefined) process.env[key] = val;
+  }
+}
+
+loadEnvFile(resolve(__dirname, '../../.env'));
+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_ORIGIN = 'https://api.figma.com';
+const APP_NAME = 'FIGMA';
+
+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');
+
+const spec = JSON.parse(readFileSync(join(__dirname, '../../specs/figma-api.json'), 'utf8'));
+
+/** Tool names that only exist in MCP (multi-step / URL parse); single GET /v1/me as catalog anchor. */
+const COMPOSITE_TOOL_NAMES = new Set([
+  'discover_figma_resources',
+  'extract_design_tokens',
+  'convert_tokens_to_tailwind',
+  'convert_tokens_to_css_variables',
+  'get_file_full_structure',
+  'get_node_with_children',
+  'export_design_spec',
+  'search_nodes_by_name',
+  'get_prototype_flows',
+  'compare_file_versions',
+]);
+
+/** Custom multipliers / renames: tool name → { method, path } (path includes /v1 or /v2). */
+const FIGMA_ROUTE_OVERRIDES = {
+  get_file_pages: { method: 'GET', path: '/v1/files/{file_key}' },
+  get_file_components_summary: { method: 'GET', path: '/v1/files/{file_key}/components' },
+  get_node_css: { method: 'GET', path: '/v1/files/{file_key}/nodes' },
+  export_node_as_png: { method: 'GET', path: '/v1/images/{file_key}' },
+  export_node_as_svg: { method: 'GET', path: '/v1/images/{file_key}' },
+  export_node_as_pdf: { method: 'GET', path: '/v1/images/{file_key}' },
+  export_multiple_nodes: { method: 'GET', path: '/v1/images/{file_key}' },
+  get_file_comments: { method: 'GET', path: '/v1/files/{file_key}/comments' },
+  add_comment: { method: 'POST', path: '/v1/files/{file_key}/comments' },
+  resolve_comment: { method: 'PUT', path: '/v1/files/{file_key}/comments/{comment_id}' },
+  create_variables: { method: 'POST', path: '/v1/files/{file_key}/variables' },
+  update_variables: { method: 'POST', path: '/v1/files/{file_key}/variables' },
+  get_frame_by_name: { method: 'GET', path: '/v1/files/{file_key}' },
+};
+
+/** POST bodies: adopt placeholder keys → API JSON keys (MCP uses friendlier arg names). */
+const SPECIAL_BODY = {
+  add_comment: {
+    message: '{message}',
+    client_meta: '{client_meta}',
+    comment_id: '{comment_id}',
+  },
+  create_variables: {
+    variableCollections: '{collections}',
+    variableModes: '{modes}',
+    variables: '{variables}',
+    variableModeValues: '{variableModeValues}',
+  },
+  update_variables: {
+    variables: '{variables}',
+    variableCollections: '{variableCollections}',
+    variableModes: '{variableModes}',
+    variableModeValues: '{variableModeValues}',
+  },
+};
+
+function operationIdToName(operationId) {
+  if (!operationId) return null;
+  return operationId
+    .replace(/([A-Z])/g, '_$1')
+    .toLowerCase()
+    .replace(/^_/, '')
+    .replace(/[^a-z0-9_]/g, '_')
+    .replace(/_+/g, '_')
+    .substring(0, 60);
+}
+
+function buildOpenApiRouteByToolName() {
+  const map = new Map();
+  const HTTP_METHODS = ['get', 'post', 'put', 'patch', 'delete'];
+  for (const [specPath, pathItem] of Object.entries(spec.paths || {})) {
+    for (const method of HTTP_METHODS) {
+      const op = pathItem[method];
+      if (!op || op.deprecated) continue;
+      const M = method.toUpperCase();
+      const n = operationIdToName(op.operationId);
+      if (n) map.set(n, { method: M, path: specPath });
+    }
+  }
+  return map;
+}
+
+const openApiRoutes = buildOpenApiRouteByToolName();
+
+function pathParamsFromTemplate(pathTemplate) {
+  return [...String(pathTemplate).matchAll(/\{([^}]+)\}/g)].map((m) => m[1]);
+}
+
+function camelToSnake(p) {
+  return p.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toLowerCase();
+}
+
+function schemaKeyForPathParam(param, propertyKeys) {
+  if (propertyKeys.includes(param)) return param;
+  const snake = camelToSnake(param);
+  if (propertyKeys.includes(snake)) return snake;
+  return null;
+}
+
+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 extractApiRequestFromHandler(handler) {
+  if (typeof handler !== 'function') return null;
+  const src = Function.prototype.toString.call(handler);
+  const re = /apiRequest\s*\(\s*['"]([A-Z]+)['"]\s*,\s*['"]([^'"]+)['"]/is;
+  const m = src.match(re);
+  if (!m) return null;
+  return { method: m[1].toUpperCase(), path: m[2] };
+}
+
+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 buildAlignedArgsAndRequired(pathTemplate, inputSchema) {
+  const pathParams = pathParamsFromTemplate(pathTemplate);
+  const properties = inputSchema?.properties || {};
+  const requiredIn = inputSchema?.required || [];
+  const pkeys = Object.keys(properties);
+
+  const args = {};
+  const requiredOut = [];
+
+  for (const pp of pathParams) {
+    const sk = schemaKeyForPathParam(pp, pkeys);
+    if (sk) {
+      args[pp] = mapArgType(properties[sk]);
+      if (requiredIn.includes(sk)) requiredOut.push(pp);
+    } else {
+      args[pp] = 'string';
+      if (requiredIn.includes(pp)) requiredOut.push(pp);
+    }
+  }
+
+  for (const [k, v] of Object.entries(properties)) {
+    const usedAsPath = pathParams.some((pp) => schemaKeyForPathParam(pp, pkeys) === k);
+    if (usedAsPath) continue;
+    args[k] = mapArgType(v);
+  }
+
+  for (const r of requiredIn) {
+    const pp = pathParams.find((p) => schemaKeyForPathParam(p, pkeys) === r);
+    const outKey = pp || r;
+    if (!requiredOut.includes(outKey)) requiredOut.push(outKey);
+  }
+
+  return { args, required: [...new Set(requiredOut)] };
+}
+
+function resolvePublishSpec(tool) {
+  if (COMPOSITE_TOOL_NAMES.has(tool.name)) {
+    return { method: 'GET', path: '/v1/me', composite: true };
+  }
+  const over = FIGMA_ROUTE_OVERRIDES[tool.name];
+  if (over) return { ...over, composite: false };
+  const fromSpec = openApiRoutes.get(tool.name);
+  if (fromSpec) return { ...fromSpec, composite: false };
+  const ex = extractApiRequestFromHandler(tool.handler);
+  if (ex) return { ...ex, composite: false };
+  throw new Error('Could not resolve method/path (no OpenAPI route, override, or handler literal)');
+}
+
+function buildPayload(tool, publish) {
+  const { method, path: pathTemplate, composite } = publish;
+  const properties = tool.inputSchema?.properties || {};
+  const pathParams = new Set(pathParamsFromTemplate(pathTemplate));
+  const pkeys = Object.keys(properties);
+
+  const { args, required } = buildAlignedArgsAndRequired(pathTemplate, tool.inputSchema);
+
+  const nonPathKeys = pkeys.filter((k) => {
+    for (const pp of pathParams) {
+      if (schemaKeyForPathParam(pp, pkeys) === k) return false;
+    }
+    return !pathParams.has(k);
+  });
+
+  const useQuery = method === 'GET' || method === 'DELETE';
+
+  let body = null;
+  let query_params = null;
+
+  if (composite) {
+    body = null;
+    query_params = null;
+  } else if (SPECIAL_BODY[tool.name]) {
+    body = { ...SPECIAL_BODY[tool.name] };
+  } else if (useQuery) {
+    query_params = placeholderMap(nonPathKeys);
+  } else {
+    body = placeholderMap(nonPathKeys);
+    if (body && Object.keys(body).length === 0) body = null;
+  }
+
+  const headers = {
+    authorization: '{secrets.bearer_token}',
+    'x-figma-token': '{secrets.bearer_token}',
+    'content-type': 'application/json',
+  };
+
+  return {
+    integration_id: INTEGRATION_ID,
+    name: `${APP_NAME}_${String(tool.name).toUpperCase()}`,
+    description: (tool.description || '').slice(0, 8000),
+    tool_spec: {
+      url: BASE_ORIGIN + pathTemplate,
+      method,
+      headers,
+      body,
+      query_params,
+    },
+    input_schema: {
+      args,
+      required,
+    },
+    // Keep false: adopt returns 404 "Org integration not found" when true for standard MCP integrations.
+    is_custom_integration: false,
+    is_published: false,
+    is_browser_call: false,
+  };
+}
+
+async function publishAll() {
+  console.log(`Publishing ${tools.length} Figma 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 tools) {
+    let payload;
+    try {
+      const spec = resolvePublishSpec(tool);
+      payload = buildPayload(tool, spec);
+    } 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: ${tools.length} tools`);
+}
+
+publishAll();

package/dist/integrations/figma/setup.js

@@ -0,0 +1,90 @@
+#!/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'];
+
+if (isRemove) {
+  removeConfig({ client: clientFlag, serverName: 'figma-adoptai' });
+  console.log(`✅ Figma MCP removed from ${clientFlag}`);
+  process.exit(0);
+}
+
+if (isStatus) {
+  const creds = getCredentials('figma');
+  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('figma');
+
+  if (existing && !isTokenExpired('figma')) {
+    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: 'figma-adoptai',
+        command: 'node',
+        args: [resolve(__dirname, 'index.js')],
+        env: {},
+      });
+      process.exit(0);
+    }
+  }
+
+  await runAuth();
+
+  writeConfig({
+    client: clientFlag,
+    serverName: 'figma-adoptai',
+    command: 'node',
+    args: [resolve(__dirname, 'index.js')],
+    env: {},
+  });
+
+  console.log(`
+✅ Figma MCP is ready!
+────────────────────────────────────────
+Your AI (${clientFlag}) can now use ${tools.length} tools.
+
+Try asking:
+  "List pages in my Figma file ABC123"
+  "Export this frame as PNG from file key …"
+
+Get a PAT: Figma → Settings → Security → Personal access tokens → Generate new token.
+
+Run health check: node core/doctor.js --client ${clientFlag}
+  `);
+}
+
+main().catch((err) => {
+  console.error('❌ Setup failed:', err.message);
+  process.exit(1);
+});