adoptai-mcp 1.0.0

package/dist/cli/list.js

@@ -0,0 +1,19 @@
+import chalk from 'chalk';
+import { APP_SLUGS, countToolsForApp } from '../apps/registry.js';
+import { hasAppCredentials } from '../config/credentials.js';
+export async function runList() {
+    console.log(chalk.bold('\n  Available Apps'));
+    console.log(chalk.dim('  ──────────────────────────────────────────'));
+    let total = 0;
+    for (const app of APP_SLUGS) {
+        const n = await countToolsForApp(app);
+        total += n;
+        const ok = hasAppCredentials(app);
+        const mark = ok ? chalk.green('✅') : chalk.red('❌');
+        const auth = ok ? chalk.green('authenticated') : chalk.dim('not authenticated');
+        console.log(`  ${mark}  ${app.padEnd(12)} ${String(n).padStart(4)} tools   ${auth}`);
+    }
+    console.log(chalk.dim('  ──────────────────────────────────────────'));
+    console.log(chalk.bold(`  Total: ${total.toLocaleString()} tools across ${APP_SLUGS.length} apps\n`));
+    console.log(chalk.cyan('  Run: npx adoptai-mcp add --app <name> --client cursor\n'));
+}

package/dist/cli/remove.js

@@ -0,0 +1,37 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { isAppSlug } from '../apps/registry.js';
+import { getCredentialsStore } from '../config/credentials.js';
+import { isClientId, removeAdoptaiMcpServer } from '../config/clients.js';
+export async function runRemove(argv) {
+    const app = argv.app.trim().toLowerCase();
+    if (!isAppSlug(app)) {
+        console.error(chalk.red(`Unknown app "${argv.app}".`));
+        process.exit(1);
+    }
+    const clientRaw = argv.client;
+    if (!isClientId(clientRaw)) {
+        console.error(chalk.red(`Unknown client "${clientRaw}".`));
+        process.exit(1);
+    }
+    const client = clientRaw;
+    const removed = removeAdoptaiMcpServer(client, app);
+    if (!removed) {
+        console.log(chalk.yellow(`No ${app}-adoptai entry found for ${client}.`));
+    }
+    else {
+        console.log(chalk.green(`Removed ${app}-adoptai from ${client} config.`));
+    }
+    const { del } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'del',
+            message: 'Delete saved credentials too?',
+            default: false,
+        },
+    ]);
+    if (del) {
+        getCredentialsStore().delete(app);
+        console.log(chalk.green(`Deleted stored credentials for ${app}.`));
+    }
+}

package/dist/cli/serve.js

@@ -0,0 +1,27 @@
+import { isAppSlug } from '../apps/registry.js';
+import { getCredentialsStore } from '../config/credentials.js';
+import { applyCredentialsToEnv, loadToolsForApp } from '../server/tool-loader.js';
+import { runMcpServer } from '../server/mcp-server.js';
+function pickCredentials(app, store) {
+    const raw = store.get(app);
+    if (!raw || typeof raw !== 'object')
+        return null;
+    return raw;
+}
+export async function runServe(argv) {
+    const app = argv.app;
+    if (!isAppSlug(app)) {
+        console.error(`Unknown app "${app}".`);
+        process.exit(1);
+    }
+    const store = getCredentialsStore();
+    const creds = pickCredentials(app, store);
+    if (!creds) {
+        console.error(`No saved credentials for "${app}". Run:\n  npx adoptai-mcp add --app ${app} --client cursor`);
+        process.exit(1);
+    }
+    applyCredentialsToEnv(app, creds);
+    const tools = await loadToolsForApp(app);
+    const serverName = `${app}-adoptai`;
+    await runMcpServer({ name: serverName, version: '1.0.0', tools });
+}

package/dist/cli/status.js

@@ -0,0 +1,24 @@
+import chalk from 'chalk';
+import { APP_SLUGS, countToolsForApp } from '../apps/registry.js';
+import { hasAppCredentials } from '../config/credentials.js';
+import { CLIENT_IDS, clientConfigPath, listAdoptaiAppsInClient } from '../config/clients.js';
+export async function runStatus() {
+    console.log(chalk.bold('\n  Clients'));
+    console.log(chalk.dim('  ──────────────────────────────────────────'));
+    for (const c of CLIENT_IDS) {
+        const apps = listAdoptaiAppsInClient(c);
+        const p = clientConfigPath(c);
+        const line = apps.length ? apps.join(', ') : chalk.dim('(none)');
+        console.log(`  ${chalk.bold(c)}: ${line}`);
+        if (p)
+            console.log(chalk.dim(`    ${p}`));
+    }
+    const connected = APP_SLUGS.filter((a) => hasAppCredentials(a));
+    let toolTotal = 0;
+    for (const a of connected) {
+        toolTotal += await countToolsForApp(a);
+    }
+    console.log(chalk.bold('\n  Stored credentials (connected apps)'));
+    console.log(`  ${connected.length ? connected.join(', ') : chalk.dim('none')}`);
+    console.log(chalk.bold(`\n  Total tools (authenticated apps): ${toolTotal.toLocaleString()}\n`));
+}

package/dist/config/clients.js

@@ -0,0 +1,118 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { spawnSync } from 'node:child_process';
+export const CLIENT_IDS = ['cursor', 'claude', 'windsurf', 'vscode'];
+export function clientConfigPath(client) {
+    switch (client) {
+        case 'cursor':
+            return join(homedir(), '.cursor', 'mcp.json');
+        case 'claude':
+            return join(homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+        case 'windsurf':
+            return join(homedir(), '.codeium', 'windsurf', 'mcp_config.json');
+        case 'vscode':
+            return null;
+        default:
+            return null;
+    }
+}
+export function adoptaiServerKey(app) {
+    return `${app}-adoptai`;
+}
+export function mcpServerEntryForApp(app) {
+    return {
+        command: 'npx',
+        args: ['-y', 'adoptai-mcp', 'serve', '--app', app],
+        env: {},
+    };
+}
+export function readClientConfigFile(client) {
+    const p = clientConfigPath(client);
+    if (!p || !existsSync(p))
+        return {};
+    try {
+        return JSON.parse(readFileSync(p, 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+export function readMcpServers(client) {
+    const j = readClientConfigFile(client);
+    const mcp = j.mcpServers;
+    if (mcp && typeof mcp === 'object' && !Array.isArray(mcp)) {
+        return mcp;
+    }
+    return {};
+}
+function writeClientConfigRaw(client, data) {
+    const p = clientConfigPath(client);
+    if (!p) {
+        throw new Error('No config path for this client');
+    }
+    const dir = dirname(p);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+    writeFileSync(p, JSON.stringify(data, null, 2) + '\n', { mode: 0o600 });
+}
+export function upsertAdoptaiMcpServer(client, app) {
+    if (client === 'vscode') {
+        const entry = mcpServerEntryForApp(app);
+        const r = spawnSync('code', ['--add-mcp', adoptaiServerKey(app), entry.command, ...entry.args], {
+            encoding: 'utf8',
+        });
+        if (r.error || (r.status !== 0 && r.status !== null)) {
+            throw new Error('Could not run `code --add-mcp`. Add this server manually in VS Code MCP settings:\n' +
+                JSON.stringify({ [adoptaiServerKey(app)]: entry }, null, 2));
+        }
+        return 'VS Code (via code --add-mcp)';
+    }
+    const base = readClientConfigFile(client);
+    const mcpServers = { ...readMcpServers(client) };
+    mcpServers[adoptaiServerKey(app)] = mcpServerEntryForApp(app);
+    base.mcpServers = mcpServers;
+    writeClientConfigRaw(client, base);
+    return clientConfigPath(client) ?? '';
+}
+export function removeAdoptaiMcpServer(client, app) {
+    if (client === 'vscode') {
+        spawnSync('code', ['--remove-mcp', adoptaiServerKey(app)], { encoding: 'utf8' });
+        return true;
+    }
+    const p = clientConfigPath(client);
+    if (!p || !existsSync(p))
+        return false;
+    const base = readClientConfigFile(client);
+    const mcpServers = { ...readMcpServers(client) };
+    const key = adoptaiServerKey(app);
+    if (!mcpServers[key])
+        return false;
+    delete mcpServers[key];
+    base.mcpServers = mcpServers;
+    writeClientConfigRaw(client, base);
+    return true;
+}
+export function listAdoptaiAppsInClient(client) {
+    const servers = readMcpServers(client);
+    const apps = [];
+    for (const name of Object.keys(servers)) {
+        if (!name.endsWith('-adoptai'))
+            continue;
+        const entry = servers[name];
+        if (!entry?.args || !Array.isArray(entry.args))
+            continue;
+        const i = entry.args.indexOf('--app');
+        if (i >= 0 && entry.args[i + 1]) {
+            apps.push(String(entry.args[i + 1]));
+        }
+        else {
+            apps.push(name.replace(/-adoptai$/, ''));
+        }
+    }
+    return [...new Set(apps)];
+}
+export function isClientId(s) {
+    return CLIENT_IDS.includes(s);
+}

package/dist/config/credentials.js

@@ -0,0 +1,34 @@
+import Conf from 'conf';
+import { randomBytes } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const ADOPTAI_DIR = join(homedir(), '.adoptai');
+function getOrCreateEncryptionKey() {
+    if (!existsSync(ADOPTAI_DIR)) {
+        mkdirSync(ADOPTAI_DIR, { recursive: true, mode: 0o700 });
+    }
+    const keyPath = join(ADOPTAI_DIR, '.encryption-key');
+    if (existsSync(keyPath)) {
+        return readFileSync(keyPath, 'utf8').trim();
+    }
+    const key = randomBytes(32).toString('hex');
+    writeFileSync(keyPath, key, { mode: 0o600 });
+    return key;
+}
+let _store = null;
+export function getCredentialsStore() {
+    if (!_store) {
+        _store = new Conf({
+            projectName: 'adoptai-mcp',
+            cwd: ADOPTAI_DIR,
+            configName: 'credentials',
+            encryptionKey: getOrCreateEncryptionKey(),
+        });
+    }
+    return _store;
+}
+export function hasAppCredentials(app) {
+    const store = getCredentialsStore();
+    return store.has(String(app));
+}

package/dist/core/auth-manager.js

@@ -0,0 +1,237 @@
+/**
+ * @file auth-manager.js
+ * Unified token storage, retrieval, expiry detection, and refresh for adopt.ai MCP integrations.
+ * Storage: ~/.adoptai/<appId>_creds.json
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const ADOPTAI_DIR = path.join(os.homedir(), '.adoptai');
+const CREDS_SUFFIX = '_creds.json';
+
+/**
+ * Ensure ~/.adoptai directory exists.
+ * @returns {string} Path to .adoptai directory
+ */
+function ensureAdoptaiDir() {
+  if (!fs.existsSync(ADOPTAI_DIR)) {
+    fs.mkdirSync(ADOPTAI_DIR, { recursive: true, mode: 0o700 });
+  }
+  return ADOPTAI_DIR;
+}
+
+/**
+ * Get path to credentials file for an app.
+ * @param {string} appId - Application id (e.g. 'github', 'slack')
+ * @returns {string} Full path to creds file
+ */
+function getCredsPath(appId) {
+  ensureAdoptaiDir();
+  return path.join(ADOPTAI_DIR, `${appId}${CREDS_SUFFIX}`);
+}
+
+/**
+ * Save credentials for an app.
+ * @param {string} appId - Application id
+ * @param {object} credObject - Credentials to store
+ * @param {string} [credObject.token] - Access token
+ * @param {string} [credObject.tokenType] - e.g. 'bearer'
+ * @param {string|null} [credObject.expiresAt] - ISO date or null if never expires
+ * @param {string|null} [credObject.refreshToken] - Refresh token if applicable
+ * @param {string[]} [credObject.scopes] - OAuth scopes
+ * @param {string} [credObject.endUserId] - 6sense end_user_id
+ * @param {object} [credObject.extra] - Any other keys (e.g. id_token)
+ */
+function saveCredentials(appId, credObject) {
+  if (process.env.ADOPTAI_MCP_SERVE === '1') {
+    const prev = memoryCreds.get(appId) || syntheticCredentialsFromEnv(appId) || {};
+    memoryCreds.set(appId, { ...prev, ...credObject, appId });
+    return;
+  }
+
+  const credsPath = getCredsPath(appId);
+  const payload = {
+    appId,
+    token: credObject.token ?? null,
+    tokenType: credObject.tokenType ?? 'bearer',
+    expiresAt: credObject.expiresAt ?? null,
+    refreshToken: credObject.refreshToken ?? null,
+    scopes: credObject.scopes ?? [],
+    endUserId: credObject.endUserId ?? null,
+    savedAt: new Date().toISOString(),
+    ...credObject,
+  };
+  fs.writeFileSync(credsPath, JSON.stringify(payload, null, 2), { mode: 0o600 });
+}
+
+/** In-memory credentials when adoptai-mcp serve runs (refresh / session updates). */
+const memoryCreds = new Map();
+
+function trimEnv(v) {
+  if (typeof v !== 'string') return '';
+  return v.trim();
+}
+
+/**
+ * When ADOPTAI_MCP_SERVE=1, prefer env-injected tokens (from ~/.adoptai credentials store)
+ * so all integration auth.js modules work without per-app cred files.
+ * @param {string} appId
+ * @returns {object|null}
+ */
+function syntheticCredentialsFromEnv(appId) {
+  if (process.env.ADOPTAI_MCP_SERVE !== '1') return null;
+
+  if (appId === 'github' || appId.startsWith('github-')) {
+    const token = trimEnv(process.env.GITHUB_TOKEN);
+    if (!token) return null;
+    return {
+      appId,
+      token,
+      tokenType: 'bearer',
+      expiresAt: null,
+      savedAt: new Date().toISOString(),
+    };
+  }
+
+  if (appId === 'notion') {
+    const token = trimEnv(process.env.NOTION_TOKEN);
+    if (!token) return null;
+    return {
+      appId,
+      token,
+      tokenType: 'bearer',
+      expiresAt: null,
+      savedAt: new Date().toISOString(),
+    };
+  }
+
+  if (appId === 'figma') {
+    const token = trimEnv(process.env.FIGMA_TOKEN);
+    if (!token) return null;
+    return {
+      appId,
+      token,
+      tokenType: 'bearer',
+      expiresAt: null,
+      savedAt: new Date().toISOString(),
+    };
+  }
+
+  if (appId === 'salesforce') {
+    const token = trimEnv(process.env.SALESFORCE_ACCESS_TOKEN);
+    if (!token) return null;
+    const instanceUrl = trimEnv(process.env.SALESFORCE_INSTANCE_URL);
+    const exp = trimEnv(process.env.SALESFORCE_EXPIRES_AT);
+    return {
+      appId,
+      token,
+      tokenType: 'bearer',
+      instanceUrl: instanceUrl || null,
+      refreshToken: trimEnv(process.env.SALESFORCE_REFRESH_TOKEN) || null,
+      expiresAt: exp || null,
+      savedAt: new Date().toISOString(),
+    };
+  }
+
+  if (appId === 'canva') {
+    const token = trimEnv(process.env.CANVA_ACCESS_TOKEN);
+    if (!token) return null;
+    const exp = trimEnv(process.env.CANVA_EXPIRES_AT);
+    return {
+      appId,
+      token,
+      tokenType: 'bearer',
+      refreshToken: trimEnv(process.env.CANVA_REFRESH_TOKEN) || null,
+      expiresAt: exp || null,
+      scopes: [],
+      savedAt: new Date().toISOString(),
+    };
+  }
+
+  return null;
+}
+
+/**
+ * Get credentials for an app.
+ * @param {string} appId - Application id
+ * @returns {object|null} Stored credentials or null if not found
+ */
+function getCredentials(appId) {
+  if (process.env.ADOPTAI_MCP_SERVE === '1') {
+    if (memoryCreds.has(appId)) return memoryCreds.get(appId);
+    const syn = syntheticCredentialsFromEnv(appId);
+    if (syn) {
+      memoryCreds.set(appId, syn);
+      return syn;
+    }
+  }
+
+  const credsPath = getCredsPath(appId);
+  if (!fs.existsSync(credsPath)) return null;
+  try {
+    const raw = fs.readFileSync(credsPath, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if the token for an app is expired.
+ * @param {string} appId - Application id
+ * @returns {boolean} True if expired or missing, false if valid
+ */
+function isTokenExpired(appId) {
+  const creds = getCredentials(appId);
+  if (!creds || !creds.token) return true;
+  if (creds.expiresAt == null) return false;
+  try {
+    const expiresAt = new Date(creds.expiresAt).getTime();
+    return Date.now() >= expiresAt;
+  } catch {
+    return true;
+  }
+}
+
+/**
+ * Clear stored credentials for an app.
+ * @param {string} appId - Application id
+ */
+function clearCredentials(appId) {
+  if (process.env.ADOPTAI_MCP_SERVE === '1') {
+    memoryCreds.delete(appId);
+  }
+  const credsPath = getCredsPath(appId);
+  if (fs.existsSync(credsPath)) {
+    fs.unlinkSync(credsPath);
+  }
+}
+
+/**
+ * List all adopt.ai credential files and their status.
+ * @returns {Array<{appId: string, hasToken: boolean, expired: boolean}>}
+ */
+function listAllCredentials() {
+  ensureAdoptaiDir();
+  const files = fs.readdirSync(ADOPTAI_DIR).filter((f) => f.endsWith(CREDS_SUFFIX));
+  return files.map((f) => {
+    const appId = f.replace(CREDS_SUFFIX, '');
+    const creds = getCredentials(appId);
+    const hasToken = !!(creds && creds.token);
+    const expired = isTokenExpired(appId);
+    return { appId, hasToken, expired };
+  });
+}
+
+module.exports = {
+  ADOPTAI_DIR,
+  ensureAdoptaiDir,
+  getCredsPath,
+  saveCredentials,
+  getCredentials,
+  isTokenExpired,
+  clearCredentials,
+  listAllCredentials,
+};

package/dist/core/config-writer.js

@@ -0,0 +1,161 @@
+/**
+ * @file config-writer.js
+ * Writes MCP server config to supported AI clients (Cursor, Claude, Windsurf, VS Code).
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const SUPPORTED_CLIENTS = ['cursor', 'claude', 'claude-code', 'windsurf', 'vscode'];
+
+/**
+ * Get config file path for a client. Uses platform-specific paths.
+ * @param {string} client - One of: cursor, claude, claude-code, windsurf, vscode
+ * @returns {{ path: string, isMcpJson: boolean }} Path; isMcpJson true means we read/write the `mcpServers` object (Cursor, Claude Desktop, Claude Code, etc.)
+ */
+function getConfigPath(client) {
+  const home = os.homedir();
+  const normalized = String(client).toLowerCase().trim();
+  if (normalized === 'cursor') {
+    return { path: path.join(home, '.cursor', 'mcp.json'), isMcpJson: true };
+  }
+  if (normalized === 'claude-code') {
+    return { path: path.join(home, '.claude.json'), isMcpJson: true };
+  }
+  if (normalized === 'claude') {
+    const base = process.platform === 'win32'
+      ? path.join(process.env.APPDATA || home, 'Claude')
+      : path.join(home, 'Library', 'Application Support', 'Claude');
+    // Claude Desktop expects camelCase `mcpServers` (same as Cursor). Legacy snake_case `mcp_servers` is ignored by the app.
+    return { path: path.join(base, 'claude_desktop_config.json'), isMcpJson: true };
+  }
+  if (normalized === 'windsurf') {
+    return { path: path.join(home, '.windsurf', 'mcp.json'), isMcpJson: true };
+  }
+  if (normalized === 'vscode') {
+    return { path: path.join(home, '.vscode', 'mcp.json'), isMcpJson: true };
+  }
+  return { path: '', isMcpJson: false };
+}
+
+/**
+ * Read existing config or return default structure.
+ * @param {string} configPath - Full path to config file
+ * @param {boolean} isMcpJson - True: use `mcpServers`. False: legacy `mcp_servers` only (unused for current clients).
+ * @returns {object} Config object
+ */
+function readConfig(configPath, isMcpJson) {
+  if (!fs.existsSync(configPath)) {
+    return isMcpJson ? { mcpServers: {} } : { mcp_servers: {} };
+  }
+  try {
+    const raw = fs.readFileSync(configPath, 'utf8');
+    const data = JSON.parse(raw);
+    if (isMcpJson) {
+      if (!data.mcpServers) data.mcpServers = {};
+      const legacy = data.mcp_servers;
+      if (legacy && typeof legacy === 'object' && !Array.isArray(legacy)) {
+        data.mcpServers = { ...legacy, ...data.mcpServers };
+        delete data.mcp_servers;
+      }
+    } else if (!data.mcp_servers) {
+      data.mcp_servers = {};
+    }
+    return data;
+  } catch {
+    return isMcpJson ? { mcpServers: {} } : { mcp_servers: {} };
+  }
+}
+
+/**
+ * Write MCP server entry to AI client config.
+ * @param {object} opts
+ * @param {string} opts.client - cursor | claude | claude-code | windsurf | vscode
+ * @param {string} opts.serverName - Key for the server (e.g. 'github-adoptai')
+ * @param {string} opts.command - e.g. 'node'
+ * @param {string[]} opts.args - e.g. ['/path/to/index.js']
+ * @param {object} [opts.env] - Env vars for the server
+ * @returns {string} Human-readable integration name for success message
+ */
+function writeConfig({ client, serverName, command, args, env }) {
+  const normalized = String(client).toLowerCase().trim();
+  if (!SUPPORTED_CLIENTS.includes(normalized)) {
+    const msg = `Invalid client "${client}". Supported: ${SUPPORTED_CLIENTS.join(', ')}`;
+    throw new Error(msg);
+  }
+
+  const { path: configPath, isMcpJson } = getConfigPath(normalized);
+  const dir = path.dirname(configPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  const config = readConfig(configPath, isMcpJson);
+  const servers = isMcpJson ? config.mcpServers : config.mcp_servers;
+  const entry = { command, args, env: env || {} };
+  if (normalized === 'claude-code') {
+    entry.type = 'stdio';
+  }
+  servers[serverName] = entry;
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+
+  const label = serverName.replace(/-adoptai$/, '');
+  return label.charAt(0).toUpperCase() + label.slice(1);
+}
+
+/**
+ * Remove an MCP server entry from client config.
+ * @param {object} opts
+ * @param {string} opts.client - cursor | claude | claude-code | windsurf | vscode
+ * @param {string} opts.serverName - Key to remove (e.g. 'github-adoptai')
+ */
+function removeConfig({ client, serverName }) {
+  const normalized = String(client).toLowerCase().trim();
+  if (!SUPPORTED_CLIENTS.includes(normalized)) {
+    throw new Error(`Invalid client "${client}". Supported: ${SUPPORTED_CLIENTS.join(', ')}`);
+  }
+
+  const { path: configPath, isMcpJson } = getConfigPath(normalized);
+  if (!fs.existsSync(configPath)) return;
+
+  const config = readConfig(configPath, isMcpJson);
+  const servers = isMcpJson ? config.mcpServers : config.mcp_servers;
+  delete servers[serverName];
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+}
+
+/**
+ * List adopt.ai MCP entries for a client (entries whose key ends with -adoptai or contains adoptai).
+ * @param {object} opts
+ * @param {string} opts.client - cursor | claude | claude-code | windsurf | vscode
+ * @returns {Array<{ name: string, command: string, args: string[] }>}
+ */
+function listConfigs({ client }) {
+  const normalized = String(client).toLowerCase().trim();
+  if (!SUPPORTED_CLIENTS.includes(normalized)) {
+    throw new Error(`Invalid client "${client}". Supported: ${SUPPORTED_CLIENTS.join(', ')}`);
+  }
+
+  const { path: configPath, isMcpJson } = getConfigPath(normalized);
+  if (!fs.existsSync(configPath)) return [];
+
+  const config = readConfig(configPath, isMcpJson);
+  const servers = isMcpJson ? config.mcpServers : config.mcp_servers;
+  return Object.entries(servers)
+    .filter(([name]) => /adoptai/i.test(name))
+    .map(([name, entry]) => ({
+      name,
+      command: entry.command || '',
+      args: entry.args || [],
+    }));
+}
+
+module.exports = {
+  SUPPORTED_CLIENTS,
+  getConfigPath,
+  readConfig,
+  writeConfig,
+  removeConfig,
+  listConfigs,
+};