@evolvedqube/gmcp 0.1.0-alpha.5

package/dist/commands/market.js

@@ -0,0 +1,84 @@
+import inquirer from 'inquirer';
+import { fetchServers } from '../api-client.js';
+import { filterRemoteOnlyServers } from '../transform.js';
+import { addCommand } from './add.js';
+const EXIT_OPTION = '✓ Done (exit)';
+const SHOW_MORE_OPTION = '→ Show next 10 servers';
+const PAGE_SIZE = 10;
+/**
+ * Browse and install MCP servers from the registry
+ */
+export async function marketCommand() {
+    try {
+        console.log('Fetching servers from MCP Registry...');
+        // Fetch all servers from API
+        const allServers = await fetchServers();
+        // Filter out remote-only servers
+        const localServers = filterRemoteOnlyServers(allServers);
+        if (localServers.length === 0) {
+            console.log('No servers available.');
+            return;
+        }
+        // Deduplicate by server name (API may return multiple entries for same server with different packages)
+        const uniqueServers = Array.from(new Map(localServers.map(server => [server.name, server])).values());
+        // Sort alphabetically
+        const sortedServers = [...uniqueServers].sort((a, b) => a.name.localeCompare(b.name));
+        console.log(`\nFound ${sortedServers.length} unique server(s):\n`);
+        let currentPage = 0;
+        // Interactive loop with pagination
+        while (true) {
+            const startIndex = currentPage * PAGE_SIZE;
+            const endIndex = Math.min(startIndex + PAGE_SIZE, sortedServers.length);
+            const currentPageServers = sortedServers.slice(startIndex, endIndex);
+            const hasMore = endIndex < sortedServers.length;
+            console.log(`\nShowing ${startIndex + 1}-${endIndex} of ${sortedServers.length} servers:\n`);
+            // Format choices for current page
+            const choices = currentPageServers.map(server => ({
+                name: `${server.name} - ${server.description}`,
+                value: server.name,
+            }));
+            // Build options list
+            const allChoices = [
+                { name: EXIT_OPTION, value: EXIT_OPTION },
+                ...choices,
+            ];
+            // Add "Show more" option if there are more results
+            if (hasMore) {
+                allChoices.push({ name: SHOW_MORE_OPTION, value: SHOW_MORE_OPTION });
+            }
+            const answer = await inquirer.prompt([
+                {
+                    type: 'rawlist',
+                    name: 'server',
+                    message: 'Select an MCP server to install:',
+                    choices: allChoices,
+                    pageSize: 15,
+                },
+            ]);
+            // Handle exit
+            if (answer.server === EXIT_OPTION) {
+                return;
+            }
+            // Handle show more
+            if (answer.server === SHOW_MORE_OPTION) {
+                currentPage++;
+                continue;
+            }
+            // Install selected server
+            try {
+                await addCommand(answer.server, {});
+            }
+            catch (error) {
+                console.error('Installation failed:', error instanceof Error ? error.message : String(error));
+            }
+            console.log(''); // Add spacing
+        }
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.error(`Error: ${error.message}`);
+            process.exit(1);
+        }
+        throw error;
+    }
+}

package/dist/commands/platforms.js

@@ -0,0 +1,71 @@
+import { readUserConfig } from '../config.js';
+import { getAdapter } from '../adapters/index.js';
+function padRight(str, width) {
+    return str + ' '.repeat(Math.max(0, width - str.length));
+}
+export async function platformsCommand() {
+    // Task 2.1: Load config
+    const userConfig = readUserConfig();
+    // Tasks 2.2 & 2.3: Handle missing or empty config
+    if (!userConfig || !userConfig.platforms || userConfig.platforms.length === 0) {
+        console.log('No platforms configured. Run `gmcp init` first.');
+        process.exit(1);
+    }
+    // Task 2.4: Extract platforms array
+    const configuredPlatforms = userConfig.platforms;
+    // Task 4.2: Platform ID to human-readable name mapping
+    const platformNames = {
+        'claude-code': 'Claude Code',
+        'copilot-cli': 'Copilot CLI',
+        'windsurf': 'Windsurf',
+    };
+    const tableRows = [];
+    // Tasks 3.1-3.4: Process each configured platform
+    for (const platformId of configuredPlatforms) {
+        const humanName = platformNames[platformId] || platformId;
+        // Task 3.2: Get adapter for this platform
+        const adapter = getAdapter(platformId);
+        let detectedStatus;
+        if (!adapter) {
+            // Task 4.4: Handle unrecognized platform
+            detectedStatus = 'Unknown platform';
+        }
+        else {
+            // Task 3.3: Call adapter's detect() method with error handling
+            try {
+                // Task 3.4: Wrap in try-catch for graceful error handling
+                const isDetected = adapter.detect();
+                // Task 4.3: Format with symbols
+                detectedStatus = isDetected ? '✓' : '✗';
+            }
+            catch (error) {
+                // Task 4.4: Handle adapter errors
+                detectedStatus = 'Error';
+            }
+        }
+        tableRows.push({
+            platform: humanName,
+            configured: '✓',
+            detected: detectedStatus,
+        });
+    }
+    // Task 4.5: Print formatted table
+    const headers = ['Platform', 'Configured', 'Detected'];
+    const rows = [headers, ...tableRows.map(r => [r.platform, r.configured, r.detected])];
+    // Calculate column widths
+    const colWidths = headers.map((_, colIndex) => {
+        return Math.max(...rows.map(row => row[colIndex].length));
+    });
+    // Print table
+    console.log('\nConfigured Platforms:\n');
+    // Print header
+    const headerRow = headers.map((header, i) => padRight(header, colWidths[i])).join('  ');
+    console.log(headerRow);
+    console.log('─'.repeat(headerRow.length));
+    // Print data rows
+    for (let i = 1; i < rows.length; i++) {
+        const row = rows[i].map((cell, j) => padRight(cell, colWidths[j])).join('  ');
+        console.log(row);
+    }
+    console.log('');
+}

package/dist/commands/remove.js

@@ -0,0 +1,60 @@
+import inquirer from 'inquirer';
+import { readUserConfig } from '../config.js';
+import { getAdapter } from '../adapters/index.js';
+export async function removeCommand(name, options) {
+    const userConfig = readUserConfig();
+    if (!userConfig) {
+        console.error('No platforms configured. Run `gmcp init` first.');
+        process.exit(1);
+    }
+    let targetPlatforms = userConfig.platforms;
+    if (options.only) {
+        const onlyPlatforms = options.only.split(',').map(p => p.trim()).filter(p => p.length > 0);
+        const unconfigured = onlyPlatforms.filter(p => !userConfig.platforms.includes(p));
+        if (unconfigured.length > 0) {
+            console.warn(`Warning: ${unconfigured.join(', ')} not configured. Run \`gmcp init\` to add them.`);
+        }
+        targetPlatforms = onlyPlatforms.filter(p => userConfig.platforms.includes(p));
+        if (targetPlatforms.length === 0) {
+            console.error('No valid platforms specified.');
+            process.exit(1);
+        }
+    }
+    const installedOn = [];
+    for (const platformName of targetPlatforms) {
+        const adapter = getAdapter(platformName);
+        if (!adapter)
+            continue;
+        const servers = adapter.readServers();
+        if (servers.has(name)) {
+            installedOn.push(platformName);
+        }
+    }
+    if (installedOn.length === 0) {
+        console.log(`${name} is not installed on any platform.`);
+        return;
+    }
+    console.log(`${name} is installed on: ${installedOn.join(', ')}`);
+    const answer = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: `Remove ${name} from ${installedOn.length} platform(s)?`,
+            default: false,
+        },
+    ]);
+    if (!answer.confirm) {
+        console.log('Cancelled.');
+        return;
+    }
+    let removedCount = 0;
+    for (const platformName of installedOn) {
+        const adapter = getAdapter(platformName);
+        if (!adapter)
+            continue;
+        adapter.removeServer(name);
+        console.log(`- ${platformName}: removed`);
+        removedCount++;
+    }
+    console.log(`\nRemoved ${name} from ${removedCount} platform(s).`);
+}

package/dist/commands/search.js

@@ -0,0 +1,86 @@
+import inquirer from 'inquirer';
+import { searchServers } from '../api-client.js';
+import { filterRemoteOnlyServers } from '../transform.js';
+import { addCommand } from './add.js';
+const EXIT_OPTION = '✓ Done (exit)';
+const SHOW_MORE_OPTION = '→ Show next 10 servers';
+const PAGE_SIZE = 10;
+/**
+ * Search for MCP servers by name and optionally install
+ */
+export async function searchCommand(query) {
+    try {
+        console.log(`Searching for "${query}"...`);
+        // Search using API
+        const results = await searchServers(query);
+        // Filter out remote-only servers
+        const localServers = filterRemoteOnlyServers(results);
+        if (localServers.length === 0) {
+            console.log('No servers found.');
+            return;
+        }
+        // Deduplicate by server name (API may return multiple entries for same server with different packages)
+        const uniqueServers = Array.from(new Map(localServers.map(server => [server.name, server])).values());
+        // Sort alphabetically
+        const sortedServers = [...uniqueServers].sort((a, b) => a.name.localeCompare(b.name));
+        console.log(`\nFound ${sortedServers.length} server(s) matching '${query}':\n`);
+        let currentPage = 0;
+        // Interactive loop with pagination
+        while (true) {
+            const startIndex = currentPage * PAGE_SIZE;
+            const endIndex = Math.min(startIndex + PAGE_SIZE, sortedServers.length);
+            const currentPageServers = sortedServers.slice(startIndex, endIndex);
+            const hasMore = endIndex < sortedServers.length;
+            if (currentPage > 0) {
+                console.log(`\nShowing ${startIndex + 1}-${endIndex} of ${sortedServers.length} servers:\n`);
+            }
+            // Format choices for current page
+            const choices = currentPageServers.map(server => ({
+                name: `${server.name} - ${server.description}`,
+                value: server.name,
+            }));
+            // Build options list
+            const allChoices = [
+                { name: EXIT_OPTION, value: EXIT_OPTION },
+                ...choices,
+            ];
+            // Add "Show more" option if there are more results
+            if (hasMore) {
+                allChoices.push({ name: SHOW_MORE_OPTION, value: SHOW_MORE_OPTION });
+            }
+            const answer = await inquirer.prompt([
+                {
+                    type: 'rawlist',
+                    name: 'server',
+                    message: 'Select an MCP server to install (or exit):',
+                    choices: allChoices,
+                    pageSize: 15,
+                },
+            ]);
+            // Handle exit
+            if (answer.server === EXIT_OPTION) {
+                return;
+            }
+            // Handle show more
+            if (answer.server === SHOW_MORE_OPTION) {
+                currentPage++;
+                continue;
+            }
+            // Install selected server
+            try {
+                await addCommand(answer.server, {});
+            }
+            catch (error) {
+                console.error('Installation failed:', error instanceof Error ? error.message : String(error));
+            }
+            console.log(''); // Add spacing
+        }
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.error(`Error: ${error.message}`);
+            process.exit(1);
+        }
+        throw error;
+    }
+}

package/dist/commands/sync.js

@@ -0,0 +1,84 @@
+import inquirer from 'inquirer';
+import { readUserConfig } from '../config.js';
+import { getAdapter } from '../adapters/index.js';
+export async function syncCommand() {
+    const userConfig = readUserConfig();
+    if (!userConfig) {
+        console.error('No platforms configured. Run `gmcp init` first.');
+        process.exit(1);
+    }
+    const allServers = new Map();
+    for (const platformName of userConfig.platforms) {
+        const adapter = getAdapter(platformName);
+        if (!adapter)
+            continue;
+        const servers = adapter.readServers();
+        for (const [name, entry] of servers.entries()) {
+            if (!allServers.has(name)) {
+                allServers.set(name, new Map());
+            }
+            allServers.get(name).set(platformName, entry);
+        }
+    }
+    const drift = [];
+    for (const [serverName, platforms] of allServers.entries()) {
+        const missingFrom = userConfig.platforms.filter(p => !platforms.has(p));
+        if (missingFrom.length > 0) {
+            const sourcePlatform = Array.from(platforms.keys())[0];
+            const sourceEntry = platforms.get(sourcePlatform);
+            drift.push({
+                serverName,
+                missingFrom,
+                sourceEntry,
+                sourcePlatform,
+            });
+        }
+    }
+    if (drift.length === 0) {
+        console.log('All platforms are in sync.');
+        return;
+    }
+    console.log(`\nFound ${drift.length} server(s) with drift:\n`);
+    for (const entry of drift) {
+        console.log(`${entry.serverName} — missing from: ${entry.missingFrom.join(', ')}`);
+    }
+    const choices = drift.map(d => ({
+        name: `${d.serverName} → ${d.missingFrom.join(', ')}`,
+        value: d.serverName,
+        checked: true,
+    }));
+    const answers = await inquirer.prompt([
+        {
+            type: 'checkbox',
+            name: 'servers',
+            message: 'Select servers to sync:',
+            choices,
+        },
+    ]);
+    if (answers.servers.length === 0) {
+        console.log('No servers selected.');
+        return;
+    }
+    let syncedCount = 0;
+    for (const serverName of answers.servers) {
+        const driftEntry = drift.find(d => d.serverName === serverName);
+        for (const platformName of driftEntry.missingFrom) {
+            const adapter = getAdapter(platformName);
+            if (!adapter)
+                continue;
+            const mockEntry = {
+                name: serverName,
+                description: 'Synced from another platform',
+                runtime: driftEntry.sourceEntry.command,
+                args: driftEntry.sourceEntry.args,
+                env: [],
+                tags: [],
+            };
+            const env = driftEntry.sourceEntry.env || {};
+            adapter.addServer(serverName, mockEntry, env);
+            console.log(`- ${serverName} → ${platformName}: synced`);
+            syncedCount++;
+        }
+    }
+    console.log(`\nSynced ${syncedCount} server(s) across platforms.`);
+}

package/dist/commands/update.js

@@ -0,0 +1,34 @@
+import { spawn, exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+async function getInstalledVersion() {
+    try {
+        const { stdout } = await execAsync('npm list -g gmcp --depth=0 --json');
+        const data = JSON.parse(stdout);
+        return data.dependencies?.gmcp?.version || null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function updateCommand() {
+    console.log('Updating gmcp...\n');
+    const child = spawn('npm', ['update', '-g', 'gmcp'], {
+        stdio: 'inherit',
+        shell: true,
+    });
+    child.on('close', async (code) => {
+        if (code === 0) {
+            console.log('\ngmcp has been updated successfully.');
+            // Display the installed version
+            const version = await getInstalledVersion();
+            if (version) {
+                console.log(`Installed version: ${version}`);
+            }
+        }
+        else {
+            console.error('\nFailed to update gmcp.');
+            process.exit(code || 1);
+        }
+    });
+}

package/dist/config.js

@@ -0,0 +1,34 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+const GMCP_DIR = path.join(os.homedir(), '.gmcp');
+const CONFIG_FILE = path.join(GMCP_DIR, 'config.json');
+export function ensureGmcpDir() {
+    if (!fs.existsSync(GMCP_DIR)) {
+        fs.mkdirSync(GMCP_DIR, { recursive: true });
+    }
+}
+export function readUserConfig() {
+    if (!fs.existsSync(CONFIG_FILE)) {
+        return null;
+    }
+    try {
+        const content = fs.readFileSync(CONFIG_FILE, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        throw new Error(`Failed to read config at ${CONFIG_FILE}: ${error}`);
+    }
+}
+export function writeUserConfig(config) {
+    ensureGmcpDir();
+    try {
+        fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8');
+    }
+    catch (error) {
+        throw new Error(`Failed to write config at ${CONFIG_FILE}: ${error}`);
+    }
+}
+export function isInitialized() {
+    return fs.existsSync(CONFIG_FILE);
+}

package/dist/package-selection.js

@@ -0,0 +1,35 @@
+import inquirer from 'inquirer';
+/**
+ * Prompt user to select between multiple package types (npm vs Docker)
+ * Returns the selected RegistryEntry
+ */
+export async function promptForPackageType(entries) {
+    // If only one package type, return it without prompting
+    if (entries.length === 1) {
+        return entries[0];
+    }
+    // Build choices for inquirer
+    const choices = entries.map((entry, index) => {
+        const label = entry.runtime === 'npx' ? 'npm (via npx)' : 'Docker (via OCI)';
+        return {
+            name: `${index + 1}. ${label}`,
+            value: index,
+        };
+    });
+    console.log('\nThis server offers multiple runtimes:');
+    const answer = await inquirer.prompt([
+        {
+            type: 'rawlist',
+            name: 'selection',
+            message: 'Select runtime:',
+            choices,
+            validate: (input) => {
+                if (input >= 0 && input < entries.length) {
+                    return true;
+                }
+                return 'Please select a valid option';
+            },
+        },
+    ]);
+    return entries[answer.selection];
+}

package/dist/pagination.js

@@ -0,0 +1,57 @@
+import inquirer from 'inquirer';
+/**
+ * Display results with pagination (20 per page)
+ * Shows "Show more? (y/n)" prompt when there are more results
+ */
+export async function displayWithPagination(items, pageSize = 20, contextMessage) {
+    if (items.length === 0) {
+        console.log('No servers found.');
+        return;
+    }
+    let currentIndex = 0;
+    while (currentIndex < items.length) {
+        const endIndex = Math.min(currentIndex + pageSize, items.length);
+        const currentPage = items.slice(currentIndex, endIndex);
+        // Display header
+        if (contextMessage) {
+            console.log(`\nShowing ${currentIndex + 1}-${endIndex} of ${items.length} ${contextMessage}:`);
+        }
+        else {
+            console.log(`\nShowing ${currentIndex + 1}-${endIndex} of ${items.length} servers:`);
+        }
+        // Display items
+        console.log('');
+        currentPage.forEach((item, index) => {
+            const number = currentIndex + index + 1;
+            const description = truncateDescription(item.description);
+            console.log(`${number}. ${item.name} - ${description}`);
+        });
+        // Move to next page
+        currentIndex = endIndex;
+        // If more results exist, prompt to continue
+        if (currentIndex < items.length) {
+            console.log('');
+            const answer = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'showMore',
+                    message: 'Show more?',
+                    default: true,
+                },
+            ]);
+            if (!answer.showMore) {
+                break;
+            }
+        }
+    }
+    console.log('');
+}
+/**
+ * Truncate description to 80 characters if needed
+ */
+function truncateDescription(description, maxLength = 80) {
+    if (description.length <= maxLength) {
+        return description;
+    }
+    return description.substring(0, maxLength - 3) + '...';
+}

package/dist/transform.js

@@ -0,0 +1,78 @@
+/**
+ * Transform API server data to internal RegistryEntry format
+ * Returns an array because one server can have multiple package types
+ * Filters out remote-only servers (no local packages)
+ */
+export function transformToRegistryEntries(apiServer) {
+    const entries = [];
+    // Skip servers with no packages or empty packages array
+    if (!apiServer.packages || apiServer.packages.length === 0) {
+        return entries;
+    }
+    // Transform each package to a RegistryEntry
+    for (const pkg of apiServer.packages) {
+        // Only support npm and oci package types
+        if (pkg.registryType !== 'npm' && pkg.registryType !== 'oci') {
+            continue;
+        }
+        const entry = {
+            name: apiServer.name,
+            description: apiServer.description || '',
+            runtime: transformRuntime(pkg.registryType),
+            args: transformArgs(pkg.registryType, pkg.identifier),
+            env: transformEnvVars(pkg.environmentVariables || []),
+            tags: [],
+        };
+        entries.push(entry);
+    }
+    return entries;
+}
+/**
+ * Transform registryType to runtime command
+ */
+function transformRuntime(registryType) {
+    switch (registryType) {
+        case 'npm':
+            return 'npx';
+        case 'oci':
+            return 'docker';
+    }
+}
+/**
+ * Transform package identifier to command arguments
+ */
+function transformArgs(registryType, identifier) {
+    switch (registryType) {
+        case 'npm':
+            return ['-y', identifier];
+        case 'oci':
+            return ['run', '-i', '--rm', identifier];
+    }
+}
+/**
+ * Transform API environment variables to RegistryEntry format
+ */
+function transformEnvVars(apiEnvVars) {
+    return apiEnvVars.map(env => ({
+        name: env.name,
+        description: env.description,
+        required: env.isRequired || false,
+    }));
+}
+/**
+ * Check if server has local packages (npm or oci)
+ */
+export function hasLocalPackages(apiServer) {
+    if (!apiServer.packages || apiServer.packages.length === 0) {
+        return false;
+    }
+    // Check if any package is npm or oci
+    return apiServer.packages.some(pkg => pkg.registryType === 'npm' || pkg.registryType === 'oci');
+}
+/**
+ * Filter out servers that only offer remote transport (HTTP/SSE)
+ * Returns only servers with local packages (npm/oci)
+ */
+export function filterRemoteOnlyServers(apiServers) {
+    return apiServers.filter(hasLocalPackages);
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils.js

@@ -0,0 +1,33 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+export function readJsonFile(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return {};
+    }
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse JSON from ${filePath}: ${error}`);
+    }
+}
+export function writeJsonFile(filePath, data) {
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    try {
+        fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8');
+    }
+    catch (error) {
+        throw new Error(`Failed to write JSON to ${filePath}: ${error}`);
+    }
+}
+export function expandHomeDir(filePath) {
+    if (filePath.startsWith('~/')) {
+        return path.join(os.homedir(), filePath.slice(2));
+    }
+    return filePath;
+}