adoptai-mcp 1.0.0

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

@@ -0,0 +1,365 @@
+#!/usr/bin/env node
+/**
+ * Publish integrations/canva/tools.js (55 tools) to adopt.ai.
+ * See docs/publisher.md — env in repo root .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, 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_URL = 'https://api.canva.com/rest/v1';
+const APP_NAME = 'CANVA';
+
+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');
+
+/** Tools that do not call apiRequest(…) — explicit REST mapping */
+const PUBLISH_OVERRIDE = {
+  create_asset_upload_job: {
+    method: 'POST',
+    path: '/asset-uploads',
+    binary: true,
+    headerPlaceholders: {
+      'asset-upload-metadata': '{asset_upload_metadata}',
+    },
+  },
+  create_design_import_job: {
+    method: 'POST',
+    path: '/imports',
+    binary: true,
+    headerPlaceholders: {
+      'import-metadata': '{import_metadata}',
+    },
+  },
+};
+
+/**
+ * Custom body placeholder maps (schema arg name → API JSON field).
+ * Values are adopt placeholders "{schemaKey}".
+ */
+const SPECIAL_BODY = {
+  move_design_to_folder: {
+    to_folder_id: '{folder_id}',
+    item_id: '{item_id}',
+  },
+  duplicate_design: {
+    title: '{new_title}',
+    source_design_id: '{design_id}',
+  },
+};
+
+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 buildPayload(tool, publish) {
+  const { method, path: pathTemplate, binary, headerPlaceholders } = 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 (binary) {
+    // Octet-stream body is the file bytes; metadata lives in headers (see PUBLISH_OVERRIDE).
+    body = { body_base64: '{body_base64}' };
+  } 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}',
+    'content-type': binary ? 'application/octet-stream' : 'application/json',
+    ...(headerPlaceholders || {}),
+  };
+
+  return {
+    integration_id: INTEGRATION_ID,
+    name: `${APP_NAME}_${String(tool.name).toUpperCase()}`,
+    description: (tool.description || '').slice(0, 8000),
+    tool_spec: {
+      url: BASE_URL + pathTemplate,
+      method,
+      headers,
+      body,
+      query_params,
+    },
+    input_schema: {
+      args,
+      required,
+    },
+    is_custom_integration: false,
+    is_published: false,
+    is_browser_call: false,
+  };
+}
+
+function resolvePublishSpec(tool) {
+  const over = PUBLISH_OVERRIDE[tool.name];
+  if (over) {
+    return {
+      method: over.method,
+      path: over.path,
+      binary: over.binary,
+      headerPlaceholders: over.headerPlaceholders,
+    };
+  }
+  const ex = extractApiRequestFromHandler(tool.handler);
+  if (!ex) {
+    throw new Error('Could not infer method/path from handler');
+  }
+  return { method: ex.method, path: ex.path, binary: false, headerPlaceholders: null };
+}
+
+// create_design_import_job schema missing import_metadata — add synthetic prop for publish args only
+function toolWithPublishSchema(tool) {
+  if (tool.name !== 'create_design_import_job') return tool;
+  return {
+    ...tool,
+    inputSchema: {
+      ...tool.inputSchema,
+      properties: {
+        import_metadata: {
+          type: 'object',
+          description: 'Import job metadata (JSON) for Import-Metadata header.',
+        },
+        ...tool.inputSchema.properties,
+      },
+      required: ['import_metadata', ...(tool.inputSchema.required || [])],
+    },
+  };
+}
+
+async function publishAll() {
+  console.log(
+    `Publishing ${tools.length} Canva 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 rawTool of tools) {
+    const tool = toolWithPublishSchema(rawTool);
+    let payload;
+    try {
+      const spec = resolvePublishSpec(rawTool);
+      payload = buildPayload(tool, spec);
+    } catch (e) {
+      console.error(`❌ Skip: ${rawTool.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/canva/setup.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+import './env.js';
+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: 'canva-adoptai' });
+  console.log(`✅ Canva MCP removed from ${clientFlag}`);
+  process.exit(0);
+}
+
+if (isStatus) {
+  const creds = getCredentials('canva');
+  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('canva');
+
+  if (existing && !isTokenExpired('canva')) {
+    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: 'canva-adoptai',
+        command: 'node',
+        args: [resolve(__dirname, 'index.js')],
+        env: {},
+      });
+      process.exit(0);
+    }
+  }
+
+  await runAuth();
+
+  writeConfig({
+    client: clientFlag,
+    serverName: 'canva-adoptai',
+    command: 'node',
+    args: [resolve(__dirname, 'index.js')],
+    env: {},
+  });
+
+  console.log(`
+✅ Canva MCP is ready!
+────────────────────────────────────────
+Your AI (${clientFlag}) can now use ${toolCount} tools.
+
+Try asking:
+  "Use get_current_user_profile to confirm I'm connected to Canva"
+  "List my designs with list_all_designs"
+
+Run health check: node core/doctor.js --client ${clientFlag}
+  `);
+}
+
+main().catch((err) => {
+  console.error('❌ Setup failed:', err.message);
+  process.exit(1);
+});