adoptai-mcp 1.0.0

package/dist/core/doctor.js

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+/**
+ * @file doctor.js
+ * Health check CLI for adopt.ai MCP integrations.
+ * Usage: npx adoptai-doctor [--client cursor|claude|windsurf|vscode]
+ */
+
+const path = require('path');
+const { getConfigPath, listConfigs, SUPPORTED_CLIENTS } = require('./config-writer.js');
+const { getCredentials, isTokenExpired, listAllCredentials } = require('./auth-manager.js');
+
+const KNOWN_INTEGRATIONS = [
+  { appId: 'github', serverName: 'github-adoptai', setupCmd: 'npx adoptai-github-mcp --client' },
+  { appId: 'slack', serverName: 'slack-adoptai', setupCmd: 'npx adoptai-slack-mcp --client' },
+  { appId: '6sense', serverName: '6sense-adoptai', setupCmd: 'npx adoptai-6sense-mcp --client' },
+  { appId: 'zluri', serverName: 'zluri-adoptai', setupCmd: 'npx adoptai-zluri-mcp --client' },
+  { appId: 'hubspot', serverName: 'hubspot-adoptai', setupCmd: 'npx adoptai-hubspot-mcp --client' },
+  { appId: 'pipedrive', serverName: 'pipedrive-adoptai', setupCmd: 'npx adoptai-pipedrive-mcp --client' },
+];
+
+/**
+ * Parse argv for --client.
+ * @returns {{ client: string }}
+ */
+function parseArgs() {
+  const args = process.argv.slice(2);
+  let client = 'cursor';
+  for (let i = 0; i < args.length; i++) {
+    if ((args[i] === '--client' || args[i] === '-c') && args[i + 1]) {
+      client = args[i + 1].toLowerCase().trim();
+      break;
+    }
+  }
+  return { client };
+}
+
+/**
+ * Check a single integration: config, token, expiry. No API ping (would require integration-specific code).
+ * 6sense gets special handling: expiry in hours/minutes, expired = warning with fix cmd.
+ * @param {object} integration - { appId, serverName, setupCmd }
+ * @param {string} client - cursor | claude | windsurf | vscode
+ * @returns {{ status: 'healthy'|'warning'|'broken', message: string, fixCmd?: string }}
+ */
+function checkIntegration(integration, client) {
+  const { appId, serverName, setupCmd } = integration;
+  const configs = listConfigs({ client });
+  const hasConfig = configs.some((c) => c.name === serverName);
+  const creds = getCredentials(appId);
+  const hasToken = !!(creds && creds.token);
+  const expired = isTokenExpired(appId);
+
+  if (!hasConfig) {
+    return {
+      status: 'broken',
+      message: 'not in config — add with setup',
+      fixCmd: `${setupCmd} ${client}`,
+    };
+  }
+  if (!hasToken) {
+    return {
+      status: 'broken',
+      message: 'token not found — run setup',
+      fixCmd: `${setupCmd} ${client}`,
+    };
+  }
+
+  // 6sense: token expires ~24h; show warning when expired or <2h left
+  if (appId === '6sense') {
+    if (expired) {
+      return {
+        status: 'warning',
+        message: 'token EXPIRED — re-run setup',
+        fixCmd: `${setupCmd} ${client}`,
+      };
+    }
+    const expiresAt = creds.expiresAt;
+    if (expiresAt) {
+      const ms = new Date(expiresAt).getTime() - Date.now();
+      const hoursLeft = ms / (1000 * 60 * 60);
+      const minutesLeft = ms / (1000 * 60);
+      if (hoursLeft < 2 && minutesLeft > 0) {
+        const mins = Math.round(minutesLeft);
+        return { status: 'warning', message: `token expires in ${mins} minutes — refresh soon` };
+      }
+      if (minutesLeft <= 0) {
+        return {
+          status: 'warning',
+          message: 'token EXPIRED — re-run setup',
+          fixCmd: `${setupCmd} ${client}`,
+        };
+      }
+      const hours = Math.round(hoursLeft);
+      return { status: 'healthy', message: `token valid for ${hours} hours` };
+    }
+    return { status: 'healthy', message: 'token valid' };
+  }
+
+  // Zluri: handle refresh token; show "authenticated as <name>"
+  if (appId === 'zluri') {
+    const hasRefresh = !!(creds.refreshToken);
+    if (expired) {
+      if (hasRefresh) {
+        return {
+          status: 'warning',
+          message: 'token expired but refresh available — run refresh',
+          fixCmd: `node integrations/zluri/setup.js --refresh`,
+        };
+      }
+      return {
+        status: 'broken',
+        message: 'token expired, no refresh — re-run setup',
+        fixCmd: `${setupCmd} ${client}`,
+      };
+    }
+    const name = creds.name || creds.email || 'user';
+    const expiresAt = creds.expiresAt;
+    if (expiresAt) {
+      const ms = new Date(expiresAt).getTime() - Date.now();
+      const hours = Math.round(ms / (60 * 60 * 1000));
+      if (hours <= 2 && hours > 0) {
+        return { status: 'warning', message: `authenticated as ${name}, expires in ${hours} hour(s)` };
+      }
+      if (hours <= 0) {
+        return {
+          status: 'broken',
+          message: 'token expired — re-run setup',
+          fixCmd: `${setupCmd} ${client}`,
+        };
+      }
+      return { status: 'healthy', message: `authenticated as ${name}, expires in ${hours} hours` };
+    }
+    return { status: 'healthy', message: `authenticated as ${name}` };
+  }
+
+  // Other integrations (GitHub, Slack)
+  if (expired) {
+    return {
+      status: 'warning',
+      message: 'token expired — re-run setup',
+      fixCmd: `${setupCmd} ${client}`,
+    };
+  }
+  const expiresAt = creds.expiresAt;
+  if (expiresAt) {
+    const ms = new Date(expiresAt).getTime() - Date.now();
+    const hours = Math.round(ms / (60 * 60 * 1000));
+    if (hours <= 2 && hours > 0) {
+      return { status: 'warning', message: `token expires in ${hours} hour(s)` };
+    }
+    if (hours <= 0) {
+      return {
+        status: 'warning',
+        message: 'token expired',
+        fixCmd: `${setupCmd} ${client}`,
+      };
+    }
+  }
+  if (appId === 'github') {
+    return { status: 'healthy', message: `authenticated as @${creds.username || 'user'}` };
+  }
+  if (appId === 'slack') {
+    return { status: 'healthy', message: `connected to ${creds.workspace || 'Slack'}` };
+  }
+  return { status: 'healthy', message: 'token valid' };
+}
+
+/**
+ * Run doctor for the given client and print report.
+ * @param {string} client - cursor | claude | windsurf | vscode
+ */
+function run(client) {
+  if (!SUPPORTED_CLIENTS.includes(client)) {
+    console.error(`Invalid client "${client}". Supported: ${SUPPORTED_CLIENTS.join(', ')}`);
+    process.exit(1);
+  }
+
+  console.log(`adopt.ai Doctor — ${client}`);
+  console.log('─────────────────────────────────────────');
+
+  let healthy = 0;
+  const lines = [];
+
+  for (const integration of KNOWN_INTEGRATIONS) {
+    const result = checkIntegration(integration, client);
+    const icon = result.status === 'healthy' ? '✅' : result.status === 'warning' ? '⚠️' : '❌';
+    const statusLabel = result.status === 'healthy' ? 'healthy' : result.status === 'warning' ? 'warning' : 'broken';
+    if (result.status === 'healthy') healthy++;
+    let msg = `${integration.appId.padEnd(10)} ${icon}  ${statusLabel.padEnd(8)} ${result.message}`;
+    if (result.fixCmd) msg += ` — run: ${result.fixCmd}`;
+    lines.push(msg);
+  }
+
+  lines.forEach((l) => console.log(l));
+  console.log('─────────────────────────────────────────');
+  console.log(`${healthy}/${KNOWN_INTEGRATIONS.length} integrations healthy`);
+}
+
+const { client } = parseArgs();
+run(client);

package/dist/core/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/core/server-base.js

@@ -0,0 +1,81 @@
+/**
+ * @file server-base.js
+ * Factory that creates a configured MCP server. Every integration uses this
+ * instead of setting up the Server manually.
+ */
+
+const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
+const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
+const { ListToolsRequestSchema, CallToolRequestSchema } = require('@modelcontextprotocol/sdk/types.js');
+
+/**
+ * Create an MCP server with the given name, version, and tools.
+ * Sets up ListTools and CallTool handlers; wraps handlers in try/catch;
+ * connects to StdioServerTransport.
+ *
+ * @param {object} opts
+ * @param {string} opts.name - Server name (e.g. 'github-adoptai')
+ * @param {string} opts.version - Server version (e.g. '1.0.0')
+ * @param {Array<{name: string, description: string, inputSchema: object, handler: (params: object) => Promise<{content: Array<{type: 'text', text: string}>}>}>} opts.tools - Tool definitions
+ * @returns {{ server: import('@modelcontextprotocol/sdk').Server, start: () => Promise<void> }}
+ */
+function createMCPServer({ name, version, tools }) {
+  const server = new Server(
+    { name, version },
+    { capabilities: { tools: {} } }
+  );
+
+  const toolsList = tools.map((t) => ({
+    name: t.name,
+    description: t.description || '',
+    inputSchema: t.inputSchema || { type: 'object', properties: {} },
+  }));
+
+  const handlerMap = new Map(tools.map((t) => [t.name, t.handler]));
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: toolsList,
+  }));
+
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name: toolName, arguments: args } = request.params;
+    const handler = handlerMap.get(toolName);
+    if (!handler) {
+      return {
+        content: [{ type: 'text', text: JSON.stringify({ isError: true, message: `Unknown tool: ${toolName}` }) }],
+        isError: true,
+      };
+    }
+    try {
+      const params = typeof args === 'object' && args !== null ? args : {};
+      const result = await handler(params);
+      if (result && Array.isArray(result.content)) {
+        return result;
+      }
+      return {
+        content: [{ type: 'text', text: typeof result === 'string' ? result : JSON.stringify(result ?? {}) }],
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`[${name}] Tool ${toolName} error:`, message);
+      return {
+        content: [{ type: 'text', text: JSON.stringify({ isError: true, message }) }],
+        isError: true,
+      };
+    }
+  });
+
+  let transport = null;
+
+  return {
+    server,
+    async start() {
+      transport = new StdioServerTransport();
+      await server.connect(transport);
+    },
+  };
+}
+
+module.exports = {
+  createMCPServer,
+};

package/dist/integrations/canva/.env

@@ -0,0 +1,3 @@
+CANVA_REDIRECT_URI=http://127.0.0.1:3000/callback
+CANVA_CLIENT_ID=OC-AZ0q7TlCXhBe
+CANVA_CLIENT_SECRET=cnvcaXU4a8SBhzB1df_yC13mEVJfZrMLpDfmhl8S0NwZ5cd45f891314

package/dist/integrations/canva/auth.js

@@ -0,0 +1,287 @@
+import './env.js';
+import { randomBytes, createHash } from 'node:crypto';
+import { createServer } from 'node:http';
+import { spawn } from 'node:child_process';
+import axios from 'axios';
+import { saveCredentials, getCredentials, isTokenExpired } from '../../core/auth-manager.js';
+
+const APP_ID = 'canva';
+
+const AUTH_URL = 'https://www.canva.com/api/oauth/authorize';
+const TOKEN_URL = 'https://api.canva.com/rest/v1/oauth/token';
+
+/** Default scopes aligned with Canva Connect dashboard / authorize URL. Override with CANVA_SCOPES (space-separated). */
+const DEFAULT_SCOPES = [
+  'design:permission:read',
+  'brandtemplate:content:write',
+  'folder:permission:write',
+  'app:read',
+  'comment:write',
+  'asset:write',
+  'profile:read',
+  'brandtemplate:meta:read',
+  'asset:read',
+  'design:content:read',
+  'app:write',
+  'design:content:write',
+  'design:permission:write',
+  'brandtemplate:content:read',
+  'comment:read',
+  'folder:permission:read',
+  'folder:write',
+  'folder:read',
+].join(' ');
+
+function scopeString() {
+  return process.env.CANVA_SCOPES?.trim() || DEFAULT_SCOPES;
+}
+
+function requireEnv(name) {
+  const v = process.env[name]?.trim();
+  if (!v) {
+    throw new Error(
+      `${name} is not set. Add it to your environment (e.g. export ${name}=...) before running setup.`
+    );
+  }
+  return v;
+}
+
+function pkcePair() {
+  const codeVerifier = randomBytes(32).toString('base64url');
+  const codeChallenge = createHash('sha256').update(codeVerifier).digest('base64url');
+  return { codeVerifier, codeChallenge };
+}
+
+function openBrowser(url) {
+  if (process.platform === 'darwin') {
+    spawn('open', [url], { detached: true, stdio: 'ignore' }).unref();
+  } else if (process.platform === 'win32') {
+    spawn('cmd', ['/c', 'start', '""', url], { detached: true, stdio: 'ignore' }).unref();
+  } else {
+    spawn('xdg-open', [url], { detached: true, stdio: 'ignore' }).unref();
+  }
+}
+
+async function exchangeCodeForTokens({ code, codeVerifier, redirectUri, clientId, clientSecret }) {
+  const body = new URLSearchParams({
+    grant_type: 'authorization_code',
+    code,
+    redirect_uri: redirectUri,
+    code_verifier: codeVerifier,
+    client_id: clientId,
+    client_secret: clientSecret,
+  });
+
+  const res = await axios.post(TOKEN_URL, body.toString(), {
+    headers: { 'Content-Type': 'application/x-www-form-urlencoded', Accept: 'application/json' },
+    timeout: 60000,
+    validateStatus: () => true,
+  });
+
+  if (res.status < 200 || res.status >= 300) {
+    const hint = typeof res.data === 'object' ? JSON.stringify(res.data) : String(res.data);
+    throw new Error(`Canva token exchange failed (${res.status}): ${hint}`);
+  }
+
+  const d = res.data;
+  const accessToken = d.access_token;
+  const refreshToken = d.refresh_token;
+  const expiresIn = Number(d.expires_in) || 14_400;
+  if (!accessToken || !refreshToken) {
+    throw new Error('Token response missing access_token or refresh_token');
+  }
+
+  const expiresAt = new Date(Date.now() + expiresIn * 1000).toISOString();
+  return { accessToken, refreshToken, expiresAt, scopes: d.scope ? String(d.scope).split(/\s+/) : [] };
+}
+
+async function refreshTokens(refreshToken, clientId, clientSecret) {
+  const body = new URLSearchParams({
+    grant_type: 'refresh_token',
+    refresh_token: refreshToken,
+    client_id: clientId,
+    client_secret: clientSecret,
+  });
+
+  const res = await axios.post(TOKEN_URL, body.toString(), {
+    headers: { 'Content-Type': 'application/x-www-form-urlencoded', Accept: 'application/json' },
+    timeout: 60000,
+    validateStatus: () => true,
+  });
+
+  if (res.status < 200 || res.status >= 300) {
+    const hint = typeof res.data === 'object' ? JSON.stringify(res.data) : String(res.data);
+    throw new Error(`Canva token refresh failed (${res.status}): ${hint}`);
+  }
+
+  const d = res.data;
+  const accessToken = d.access_token;
+  const newRefresh = d.refresh_token || refreshToken;
+  const expiresIn = Number(d.expires_in) || 14_400;
+  if (!accessToken) throw new Error('Refresh response missing access_token');
+  const expiresAt = new Date(Date.now() + expiresIn * 1000).toISOString();
+  return { accessToken, refreshToken: newRefresh, expiresAt };
+}
+
+export async function runAuth() {
+  const clientId = requireEnv('CANVA_CLIENT_ID');
+  const clientSecret = requireEnv('CANVA_CLIENT_SECRET');
+
+  const { codeVerifier, codeChallenge } = pkcePair();
+  const state = randomBytes(16).toString('hex');
+
+  const fixedRedirect = process.env.CANVA_REDIRECT_URI?.trim();
+  let redirectUri;
+  let callbackPathname = '/callback';
+  let listenPort;
+
+  if (fixedRedirect) {
+    const ru = new URL(fixedRedirect);
+    if (!['127.0.0.1', 'localhost'].includes(ru.hostname)) {
+      throw new Error('CANVA_REDIRECT_URI must use host 127.0.0.1 or localhost');
+    }
+    listenPort = Number(ru.port);
+    if (!Number.isFinite(listenPort) || listenPort <= 0) {
+      throw new Error('CANVA_REDIRECT_URI must include an explicit port (e.g. http://127.0.0.1:3000/callback)');
+    }
+    redirectUri = fixedRedirect;
+    callbackPathname = ru.pathname || '/callback';
+  }
+
+  const server = await new Promise((resolve, reject) => {
+    const s = createServer();
+    s.once('error', reject);
+    s.listen(fixedRedirect ? listenPort : 0, '127.0.0.1', () => resolve(s));
+  });
+
+  if (!fixedRedirect) {
+    listenPort = server.address().port;
+    redirectUri = `http://127.0.0.1:${listenPort}/callback`;
+  }
+
+  const authParams = new URLSearchParams({
+    response_type: 'code',
+    client_id: clientId,
+    redirect_uri: redirectUri,
+    scope: scopeString(),
+    state,
+    code_challenge: codeChallenge,
+    // Canva documents lowercase s256 in authorize URLs (RFC 7636 allows case-insensitive; use their form).
+    code_challenge_method: 's256',
+  });
+
+  const authorizeFull = `${AUTH_URL}?${authParams.toString()}`;
+
+  console.log(`
+┌─────────────────────────────────────────────┐
+│  Canva Authentication (OAuth2 + PKCE)       │
+│                                             │
+│  Ensure this redirect URI is allowed in   │
+│  your Canva integration:                    │
+│    ${redirectUri}
+│                                             │
+│  Opening browser to authorize…              │
+└─────────────────────────────────────────────┘
+  `);
+
+  const result = new Promise((resolve, reject) => {
+    server.on('request', (req, res) => {
+      try {
+        const u = new URL(req.url || '/', `http://127.0.0.1:${listenPort}`);
+        if (u.pathname !== callbackPathname) {
+          res.writeHead(404);
+          res.end();
+          return;
+        }
+        const code = u.searchParams.get('code');
+        const returned = u.searchParams.get('state');
+        const err = u.searchParams.get('error');
+        if (err) {
+          res.writeHead(400, { 'Content-Type': 'text/plain' });
+          res.end(`Error: ${err}`);
+          server.close();
+          reject(new Error(u.searchParams.get('error_description') || err));
+          return;
+        }
+        if (!code || returned !== state) {
+          res.writeHead(400, { 'Content-Type': 'text/plain' });
+          res.end('Invalid callback');
+          server.close();
+          reject(new Error('Invalid OAuth callback'));
+          return;
+        }
+        res.writeHead(200, { 'Content-Type': 'text/html' });
+        res.end('<html><body>You can close this window and return to the terminal.</body></html>');
+        server.close();
+        resolve(code);
+      } catch (e) {
+        reject(e);
+      }
+    });
+  });
+
+  openBrowser(authorizeFull);
+
+  let code;
+  try {
+    code = await result;
+  } catch (e) {
+    server.close();
+    throw e;
+  }
+
+  const tokens = await exchangeCodeForTokens({
+    code,
+    codeVerifier,
+    redirectUri,
+    clientId,
+    clientSecret,
+  });
+
+  saveCredentials(APP_ID, {
+    token: tokens.accessToken,
+    refreshToken: tokens.refreshToken,
+    tokenType: 'bearer',
+    expiresAt: tokens.expiresAt,
+    scopes: tokens.scopes,
+    savedAt: new Date().toISOString(),
+  });
+
+  console.log('✅ Canva tokens saved (access + refresh).');
+}
+
+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-canva-mcp --client cursor');
+  }
+  return { Authorization: `Bearer ${token}` };
+}
+
+export async function ensureAccessToken() {
+  const creds = getCredentials(APP_ID);
+  if (!creds?.token) {
+    throw new Error('Not authenticated. Run: npx adoptai-canva-mcp --client cursor');
+  }
+  if (!isTokenExpired(APP_ID)) return;
+
+  const clientId = requireEnv('CANVA_CLIENT_ID');
+  const clientSecret = requireEnv('CANVA_CLIENT_SECRET');
+  if (!creds.refreshToken) {
+    throw new Error('Access token expired and no refresh token. Run setup again.');
+  }
+
+  const next = await refreshTokens(creds.refreshToken, clientId, clientSecret);
+  saveCredentials(APP_ID, {
+    ...creds,
+    token: next.accessToken,
+    refreshToken: next.refreshToken,
+    tokenType: 'bearer',
+    expiresAt: next.expiresAt,
+    savedAt: new Date().toISOString(),
+  });
+}

package/dist/integrations/canva/env.js

@@ -0,0 +1,9 @@
+/**
+ * Load integrations/canva/.env before auth reads CANVA_* variables.
+ */
+import dotenv from 'dotenv';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+dotenv.config({ path: join(__dirname, '.env') });

package/dist/integrations/canva/index.js

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

package/dist/integrations/canva/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "adoptai-canva-mcp",
+  "version": "1.0.0",
+  "description": "Canva Connect API — designs, assets, folders, brand templates, exports, comments, users.",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "adoptai-canva-mcp": "./setup.js"
+  },
+  "scripts": {
+    "start": "node index.js",
+    "setup": "node setup.js",
+    "generate:tools": "node ../../scripts/generate-canva-tools.mjs",
+    "publish:adoptai": "node publish-to-adoptai.js"
+  },
+  "keywords": ["mcp", "canva", "ai", "cursor", "claude", "adopt.ai"],
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "axios": "^1.6.0",
+    "dotenv": "^16.6.1"
+  },
+  "adoptai": {
+    "appId": "canva",
+    "toolCount": 55,
+    "sourceFormat": "openapi_3",
+    "authType": "oauth2",
+    "specSources": ["specs/canva-api.json"],
+    "generatedAt": "2026-03-26T15:51:24Z"
+  }
+}