adoptai-mcp 1.0.0

package/dist/integrations/github/auth.js

@@ -0,0 +1,53 @@
+import { saveCredentials, getCredentials } from '../../core/auth-manager.js';
+import readline from 'readline';
+
+const APP_ID = 'github';
+
+export async function runAuth() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  console.log(`
+┌─────────────────────────────────────────────┐
+│  GitHub Authentication                      │
+│                                             │
+│  Use a GitHub Personal Access Token (PAT).  │
+│  Create one in Settings -> Developer        │
+│  settings -> Personal access tokens.        │
+└─────────────────────────────────────────────┘
+  `);
+
+  const token = await new Promise((resolve) => {
+    rl.question('Paste your GitHub PAT: ', (answer) => {
+      rl.close();
+      resolve(answer.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 GitHub');
+}
+
+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-github-mcp --client cursor');
+  }
+  return { Authorization: 'Bearer ' + token };
+}

package/dist/integrations/github/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: 'github-adoptai',
+  version: '1.0.0',
+  tools,
+});
+
+start();

package/dist/integrations/github/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "adoptai-github-mcp",
+  "version": "1.0.0",
+  "description": "Unified GitHub MCP server aggregating all generated GitHub category tools.",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "adoptai-github-mcp": "./setup.js"
+  },
+  "scripts": {
+    "start": "node index.js",
+    "setup": "node setup.js",
+    "publish-adopt": "node publish-to-adoptai.js"
+  },
+  "keywords": ["mcp", "github", "ai", "cursor", "claude", "adopt.ai"],
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "axios": "^1.6.0"
+  },
+  "adoptai": {
+    "appId": "github",
+    "toolCount": 845,
+    "sourceFormat": "openapi_3.1_aggregated",
+    "authType": "bearer",
+    "generatedAt": "2026-03-26T12:00:00.000Z"
+  }
+}

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

@@ -0,0 +1,240 @@
+#!/usr/bin/env node
+/**
+ * Publish integrations/github/tools.js (aggregated GitHub REST tools) 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, 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);
+    }
+    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.github.com';
+const APP_NAME = 'GITHUB';
+
+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;
+}
+
+/**
+ * Mirrors submodule apiRequest routing (see integrations/github-* /tools.js).
+ * @param {{ name: string, description?: string, method: string, path: string, deleteSendsJsonBody?: boolean, inputSchema?: object }} tool
+ */
+function buildPayload(tool) {
+  if (!tool.method || !tool.path) {
+    throw new Error(
+      `Tool "${tool.name}" is missing method/path — ensure submodule tools export them.`
+    );
+  }
+
+  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' && !tool.deleteSendsJsonBody);
+
+  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',
+      },
+      body,
+      query_params,
+    },
+    input_schema: {
+      args,
+      required: tool.inputSchema?.required || [],
+    },
+    is_custom_integration: false,
+    is_published: false,
+    is_browser_call: false,
+  };
+}
+
+async function publishAll() {
+  console.log(
+    `Publishing ${tools.length} GitHub 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 {
+      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: ${tools.length} tools`);
+}
+
+publishAll();

package/dist/integrations/github/setup.js

@@ -0,0 +1,103 @@
+#!/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';
+
+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_CLIENTS = ['cursor', 'claude', 'windsurf', 'vscode'];
+
+if (isRemove) {
+  removeConfig({ client: clientFlag, serverName: 'github-adoptai' });
+  console.log(`✅ GitHub MCP removed from ${clientFlag}`);
+  process.exit(0);
+}
+
+if (isStatus) {
+  const creds = getCredentials('github');
+  if (!creds) {
+    console.log('❌ Not authenticated');
+  } else {
+    console.log('✅ Authenticated');
+    console.log(`   Token: ${creds.token?.substring(0, 12)}...`);
+    console.log(`   Saved: ${creds.savedAt}`);
+  }
+  process.exit(0);
+}
+
+if (!SUPPORTED_CLIENTS.includes(clientFlag)) {
+  console.error(`Invalid client: ${clientFlag}`);
+  console.error(`Supported: ${SUPPORTED_CLIENTS.join(', ')}`);
+  process.exit(1);
+}
+
+async function main() {
+  const existing = getCredentials('github');
+
+  if (existing && !isTokenExpired('github')) {
+    console.log('✅ Already authenticated');
+
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    const answer = await new Promise((resolveAns) => {
+      rl.question('Re-authenticate? (y/n): ', (a) => {
+        rl.close();
+        resolveAns(a.trim().toLowerCase());
+      });
+    });
+
+    if (answer !== 'y') {
+      writeConfig({
+        client: clientFlag,
+        serverName: 'github-adoptai',
+        command: 'node',
+        args: [resolve(__dirname, 'index.js')],
+        env: {},
+      });
+      process.exit(0);
+    }
+  }
+
+  await runAuth();
+
+  const indexPath = resolve(__dirname, 'index.js');
+
+  writeConfig({
+    client: clientFlag,
+    serverName: 'github-adoptai',
+    command: 'node',
+    args: [indexPath],
+    env: {},
+  });
+
+  console.log(`
+✅ GitHub MCP is ready!
+────────────────────────────────────────
+Your AI (${clientFlag}) can now use 845 tools.
+
+Try asking:
+  "List open pull requests for owner/repo"
+  "Search repositories matching mcp server"
+
+Run health check: node core/doctor.js --client ${clientFlag}
+  `);
+}
+
+main().catch((err) => {
+  console.error('❌ Setup failed:', err.message);
+  process.exit(1);
+});

package/dist/integrations/github/tools.js

@@ -0,0 +1,78 @@
+import { tools as actionsTools } from '../github-actions/tools.js';
+import { tools as activityTools } from '../github-activity/tools.js';
+import { tools as appsTools } from '../github-apps/tools.js';
+import { tools as billingTools } from '../github-billing/tools.js';
+import { tools as checksTools } from '../github-checks/tools.js';
+import { tools as codeScanningTools } from '../github-code-scanning/tools.js';
+import { tools as dependabotTools } from '../github-dependabot/tools.js';
+import { tools as gistsTools } from '../github-gists/tools.js';
+import { tools as gitTools } from '../github-git/tools.js';
+import { tools as issuesTools } from '../github-issues/tools.js';
+import { tools as orgsTools } from '../github-orgs/tools.js';
+import { tools as packagesTools } from '../github-packages/tools.js';
+import { tools as pullsTools } from '../github-pulls/tools.js';
+import { tools as reactionsTools } from '../github-reactions/tools.js';
+import { tools as reposTools } from '../github-repos/tools.js';
+import { tools as searchTools } from '../github-search/tools.js';
+import { tools as teamsTools } from '../github-teams/tools.js';
+import { tools as usersTools } from '../github-users/tools.js';
+
+const SERVER_NAME = 'github-adoptai';
+const MAX_COMBINED_NAME_LEN = 60;
+const MAX_TOOL_NAME_LEN = Math.max(12, MAX_COMBINED_NAME_LEN - (SERVER_NAME.length + 1));
+
+function shortHash(input) {
+  let h = 2166136261;
+  for (let i = 0; i < input.length; i += 1) {
+    h ^= input.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(36).slice(0, 6);
+}
+
+function compactName(name) {
+  if (name.length <= MAX_TOOL_NAME_LEN) return name;
+  const hash = shortHash(name);
+  const headLen = Math.max(1, MAX_TOOL_NAME_LEN - (hash.length + 1));
+  return `${name.slice(0, headLen)}_${hash}`;
+}
+
+function normalizeToolNames(toolList) {
+  const used = new Set();
+  return toolList.map((tool) => {
+    const base = compactName(tool.name);
+    let candidate = base;
+    let i = 2;
+    while (used.has(candidate)) {
+      const suffix = `_${i}`;
+      const headLen = Math.max(1, MAX_TOOL_NAME_LEN - suffix.length);
+      candidate = `${base.slice(0, headLen)}${suffix}`;
+      i += 1;
+    }
+    used.add(candidate);
+    return { ...tool, name: candidate };
+  });
+}
+
+const allTools = [
+  ...actionsTools,
+  ...activityTools,
+  ...appsTools,
+  ...billingTools,
+  ...checksTools,
+  ...codeScanningTools,
+  ...dependabotTools,
+  ...gistsTools,
+  ...gitTools,
+  ...issuesTools,
+  ...orgsTools,
+  ...packagesTools,
+  ...pullsTools,
+  ...reactionsTools,
+  ...reposTools,
+  ...searchTools,
+  ...teamsTools,
+  ...usersTools,
+];
+
+export const tools = normalizeToolNames(allTools);

package/dist/integrations/github-actions/auth.js

@@ -0,0 +1,53 @@
+import { saveCredentials, getCredentials } from '../../core/auth-manager.js';
+import readline from 'readline';
+
+const APP_ID = 'github-actions';
+
+export async function runAuth() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  console.log(`
+┌─────────────────────────────────────────────┐
+│  GitHub Actions Authentication              │
+│                                             │
+│  Use a GitHub Personal Access Token (PAT).  │
+│  Create one in Settings → Developer         │
+│  settings → Personal access tokens.          │
+└─────────────────────────────────────────────┘
+  `);
+
+  const token = await new Promise((resolve) => {
+    rl.question('Paste your GitHub PAT: ', (answer) => {
+      rl.close();
+      resolve(answer.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 GitHub Actions');
+}
+
+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-github-actions-mcp --client cursor');
+  }
+  return { Authorization: 'Bearer ' + token };
+}

package/dist/integrations/github-actions/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: 'github-actions-adoptai',
+  version: '1.0.0',
+  tools,
+});
+
+start();

package/dist/integrations/github-actions/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "adoptai-github-actions-mcp",
+  "version": "1.0.0",
+  "description": "GitHub's v3 REST API — Actions workflows, runs, artifacts, caches, runners, and related endpoints (OpenAPI-derived).",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "adoptai-github-actions-mcp": "./setup.js"
+  },
+  "scripts": {
+    "start": "node index.js",
+    "setup": "node setup.js"
+  },
+  "keywords": ["mcp", "github", "github-actions", "actions", "ci", "ai", "cursor", "claude", "adopt.ai"],
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "axios": "^1.6.0"
+  },
+  "adoptai": {
+    "appId": "github-actions",
+    "toolCount": 184,
+    "sourceFormat": "openapi_3.1",
+    "authType": "bearer",
+    "generatedAt": "2026-03-26T12:00:00.000Z"
+  }
+}