@evolvedqube/gmcp 0.1.0-alpha.5

package/dist/commands/add.js

@@ -0,0 +1,525 @@
+import inquirer from 'inquirer';
+import { searchServers } from '../api-client.js';
+import { transformToRegistryEntries, filterRemoteOnlyServers } from '../transform.js';
+import { promptForPackageType } from '../package-selection.js';
+import { readUserConfig } from '../config.js';
+import { getAdapter } from '../adapters/index.js';
+/**
+ * DUPLICATE DETECTION WORKFLOW:
+ *
+ * When adding a server (registry or manual), we detect duplicates by normalizing
+ * package names from command arguments and comparing across all platforms.
+ *
+ * Flow:
+ * 1. User runs `gmcp add <name>` or `gmcp add --manual`
+ * 2. Collect env vars (registry) or prompt for details (manual)
+ * 3. Call findAllDuplicates() to scan all platforms
+ * 4. If duplicates found:
+ *    a. Show warning with duplicate names and platforms
+ *    b. Prompt: Skip or Replace
+ *    c. Skip: exit without changes
+ *    d. Replace: show confirmation, then remove duplicates and add new entry
+ * 5. If no duplicates: proceed with normal add logic
+ *
+ * Package Extraction (Normalization):
+ * - Extract first positional arg by skipping known runner flags (e.g., -y, --yes, -p)
+ * - Strip version suffixes (e.g., "@org/pkg@latest" → "@org/pkg")
+ * - Works for npx/npm/uvx/uv with or without flags, handles trailing args
+ * - Use last segment of package (e.g., "@org/server-name" → "server-name")
+ * - Fallback to command+args fingerprint if extraction fails (unknown runtimes)
+ */
+/**
+ * Known runner flags for npx/npm and uvx/uv commands.
+ * Used to skip flags when extracting the package name from arguments.
+ */
+const NPX_BOOLEAN_FLAGS = ['-y', '--yes', '-q', '--quiet', '--no-install', '--prefer-online', '--prefer-offline'];
+const NPX_VALUE_FLAGS = ['-p', '--package', '-c', '--call'];
+const UVX_BOOLEAN_FLAGS = ['--quiet', '--verbose'];
+const UVX_VALUE_FLAGS = ['--python', '--from'];
+/**
+ * Sanitize a registry server name to be compatible with all platforms.
+ *
+ * Copilot CLI enforces strict validation: server names must only contain
+ * alphanumeric characters, underscores, and hyphens.
+ *
+ * This function:
+ * 1. Extracts the last segment after the final '/'
+ * 2. Replaces '.' with '-' to ensure compatibility
+ * 3. Removes any remaining invalid characters
+ *
+ * Examples:
+ * - "io.github.upstash/context7" → "context7"
+ * - "ai.smithery/example-server" → "example-server"
+ * - "server.name" → "server-name"
+ *
+ * @param registryName - The full registry name (e.g., "io.github.upstash/context7")
+ * @returns Sanitized server name safe for all platforms
+ */
+function sanitizeServerName(registryName) {
+    // Extract last segment after final '/'
+    const segments = registryName.split('/');
+    let name = segments[segments.length - 1];
+    // Replace '.' with '-' for compatibility
+    name = name.replace(/\./g, '-');
+    // Remove any remaining invalid characters (keep only alphanumeric, underscore, hyphen)
+    name = name.replace(/[^a-zA-Z0-9_-]/g, '');
+    return name;
+}
+/**
+ * Normalize package name from command arguments using first-positional-arg detection.
+ *
+ * This function extracts the package name by:
+ * 1. Identifying the runtime (npx/npm, uvx/uv, or unknown)
+ * 2. Skipping known runner flags (boolean flags and value flags with their values)
+ * 3. Extracting the first positional argument (the package name)
+ * 4. Stripping version suffixes (e.g., @latest, @^1.0.0) to normalize versioning
+ *
+ * Examples:
+ * - ["@upstash/context7-mcp"] → "@upstash/context7-mcp"
+ * - ["-y", "@org/pkg@latest"] → "@org/pkg"
+ * - ["--yes", "@playwright/mcp"] → "@playwright/mcp"
+ * - ["mcp-server", "--key", "VALUE"] → "mcp-server" (uvx with trailing flags)
+ *
+ * @param command - The runtime command (e.g., "npx", "uvx")
+ * @param args - The argument array
+ * @returns Normalized package name, or null for unknown runtimes/no args
+ */
+function normalizePackageName(command, args) {
+    // Identify runtime and its flags
+    let booleanFlags;
+    let valueFlags;
+    if (command === 'npx' || command === 'npm') {
+        booleanFlags = NPX_BOOLEAN_FLAGS;
+        valueFlags = NPX_VALUE_FLAGS;
+    }
+    else if (command === 'uvx' || command === 'uv') {
+        booleanFlags = UVX_BOOLEAN_FLAGS;
+        valueFlags = UVX_VALUE_FLAGS;
+    }
+    else {
+        // Unknown runtime - return null for fingerprint fallback
+        return null;
+    }
+    // Skip known flags and extract first positional arg
+    let i = 0;
+    while (i < args.length) {
+        const arg = args[i];
+        // Skip boolean flags
+        if (booleanFlags.includes(arg)) {
+            i++;
+            continue;
+        }
+        // Skip value flags and their values
+        if (valueFlags.includes(arg)) {
+            i += 2; // Skip the flag and its value
+            continue;
+        }
+        // Skip any other flags (start with -)
+        if (arg.startsWith('-')) {
+            i++;
+            continue;
+        }
+        // First positional arg found - this is the package
+        let packageName = arg;
+        // Strip version suffix: @latest, @^1.0.0, etc.
+        // Only strip trailing @<version>, not the scope @org
+        packageName = packageName.replace(/@[^/@]+$/, '');
+        return packageName;
+    }
+    // No positional args found
+    return null;
+}
+/**
+ * Extract package name from command arguments using normalization.
+ *
+ * This function:
+ * 1. Normalizes the package name (strips version suffixes, handles flags)
+ * 2. Extracts the last segment (after final /) for compatibility with registry entries
+ *
+ * The normalization handles:
+ * - npx/npm with or without -y/--yes flags
+ * - uvx/uv with trailing arguments/flags
+ * - Version suffixes like @latest, @^1.0.0
+ *
+ * Returns the last segment of the package name for duplicate detection.
+ * Returns null for unknown runtimes or extraction failures.
+ */
+function extractPackageFromArgs(command, args) {
+    // Normalize the package name (handles flags, version suffixes)
+    const normalized = normalizePackageName(command, args);
+    if (!normalized) {
+        // Unknown runtime or no args - return null for fingerprint fallback
+        return null;
+    }
+    // Extract last segment for compatibility with registry entries
+    // e.g., "@modelcontextprotocol/server-fetch" → "server-fetch"
+    const lastSegment = normalized.split('/').pop();
+    return lastSegment || null;
+}
+/**
+ * Check if two server entries are duplicates by comparing extracted package names.
+ * Falls back to exact command+args fingerprint if package extraction fails.
+ */
+function isDuplicateServer(target, existing) {
+    // Extract package names from both entries
+    const targetPackage = extractPackageFromArgs(target.runtime, target.args);
+    const existingPackage = extractPackageFromArgs(existing.command, existing.args);
+    // Compare extracted package names (last segment)
+    if (targetPackage && existingPackage && targetPackage === existingPackage) {
+        return true;
+    }
+    // Fallback to exact command+args fingerprint if extraction failed
+    const targetFingerprint = `${target.runtime}|${target.args.join('|')}`;
+    const existingFingerprint = `${existing.command}|${existing.args.join('|')}`;
+    return targetFingerprint === existingFingerprint;
+}
+/**
+ * Find all duplicate servers across all platforms.
+ * Returns array of all duplicate instances with platform, name, and entry info.
+ */
+function findAllDuplicates(targetEntry, platforms) {
+    const duplicates = [];
+    for (const platform of platforms) {
+        const adapter = getAdapter(platform);
+        if (!adapter)
+            continue;
+        const servers = adapter.readServers();
+        for (const [name, entry] of servers.entries()) {
+            if (isDuplicateServer(targetEntry, entry)) {
+                duplicates.push({ platform, name, entry });
+            }
+        }
+    }
+    return duplicates;
+}
+/**
+ * Interactive prompt for handling duplicate servers.
+ * Shows all duplicates with platform info and offers Skip or Replace options.
+ * Returns: 'skip', 'replace', or 'cancel' (if user declines replace confirmation)
+ */
+async function handleDuplicatePrompt(duplicates, newName, allPlatforms) {
+    // Extract package name for display
+    const firstDupe = duplicates[0];
+    const packageName = extractPackageFromArgs(firstDupe.entry.command, firstDupe.entry.args) || 'unknown';
+    // Format duplicate list
+    console.log('\nWarning: This server is already installed:');
+    for (const dupe of duplicates) {
+        console.log(`- "${dupe.name}" on ${dupe.platform}`);
+    }
+    console.log(`Package: ${packageName}\n`);
+    // Prompt for action using rawlist (shows numbered options upfront)
+    const actionAnswer = await inquirer.prompt([
+        {
+            type: 'rawlist',
+            name: 'action',
+            message: 'What would you like to do?',
+            choices: [
+                {
+                    name: 'Skip (don\'t add, keep existing)',
+                    value: 'skip',
+                },
+                {
+                    name: 'Replace (remove existing, add new)',
+                    value: 'replace',
+                },
+            ],
+            default: 0,
+        },
+    ]);
+    if (actionAnswer.action === 'skip') {
+        return 'skip';
+    }
+    // Replace option - show confirmation
+    if (actionAnswer.action === 'replace') {
+        console.log('\nReplace will:');
+        for (const dupe of duplicates) {
+            console.log(`- Remove "${dupe.name}" from ${dupe.platform}`);
+        }
+        console.log(`- Add "${newName}" to all configured platforms (${allPlatforms.join(', ')})\n`);
+        const confirmAnswer = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: 'Proceed?',
+                default: false,
+            },
+        ]);
+        if (confirmAnswer.confirm) {
+            return 'replace';
+        }
+        else {
+            return 'cancel';
+        }
+    }
+    return 'cancel';
+}
+/**
+ * Replace duplicates: remove all duplicate entries, then add new entry to all platforms.
+ * Phase 1: Remove duplicates from their respective platforms
+ * Phase 2: Add new entry to all configured platforms
+ */
+async function replaceDuplicates(duplicates, newName, newEntry, env, allPlatforms) {
+    // Phase 1: Remove duplicates
+    for (const dupe of duplicates) {
+        const adapter = getAdapter(dupe.platform);
+        if (!adapter) {
+            console.error(`Error: Could not get adapter for ${dupe.platform}`);
+            continue;
+        }
+        try {
+            adapter.removeServer(dupe.name);
+            console.log(`- Removed "${dupe.name}" from ${dupe.platform}`);
+        }
+        catch (error) {
+            console.error(`Error removing "${dupe.name}" from ${dupe.platform}:`, error);
+            // Continue with other removals even if one fails
+        }
+    }
+    // Phase 2: Add new entry to all platforms
+    let addedCount = 0;
+    for (const platformName of allPlatforms) {
+        const adapter = getAdapter(platformName);
+        if (!adapter) {
+            console.error(`Error: Could not get adapter for ${platformName}`);
+            continue;
+        }
+        try {
+            adapter.addServer(newName, newEntry, env);
+            console.log(`- Added "${newName}" to ${platformName}`);
+            addedCount++;
+        }
+        catch (error) {
+            console.error(`Error adding "${newName}" to ${platformName}:`, error);
+        }
+    }
+    console.log(`\nReplaced ${duplicates.length} duplicate(s), added "${newName}" to ${addedCount} platform(s).`);
+}
+export async function addCommand(name, options) {
+    if (options.manual) {
+        await addManualServer(options.only);
+        return;
+    }
+    // Search for server using API
+    let apiServers;
+    try {
+        apiServers = await searchServers(name);
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : 'Failed to search registry'}`);
+        process.exit(1);
+    }
+    // Filter remote-only servers
+    const localServers = filterRemoteOnlyServers(apiServers);
+    // Find exact match by name
+    const exactMatch = localServers.find(s => s.name === name);
+    if (!exactMatch) {
+        console.error(`Server "${name}" not found in registry.`);
+        console.error('Use `gmcp search <query>` to find servers or `gmcp add --manual` to add a custom server.');
+        process.exit(1);
+    }
+    // Transform to RegistryEntries
+    const entries = transformToRegistryEntries(exactMatch);
+    if (entries.length === 0) {
+        console.error(`Server "${name}" has no supported package types (npm or Docker).`);
+        process.exit(1);
+    }
+    // Let user select package type if multiple options
+    const entry = await promptForPackageType(entries);
+    // Sanitize the server name for platform compatibility
+    // Copilot CLI requires alphanumeric, underscores, and hyphens only
+    const sanitizedName = sanitizeServerName(name);
+    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 env = {};
+    for (const envVar of entry.env) {
+        if (envVar.required || await shouldPromptOptional(envVar.name, envVar.description)) {
+            const answer = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'value',
+                    message: `${envVar.name}: ${envVar.description}`,
+                    validate: (input) => {
+                        if (envVar.required && !input.trim()) {
+                            return 'This environment variable is required.';
+                        }
+                        return true;
+                    },
+                },
+            ]);
+            if (answer.value.trim()) {
+                env[envVar.name] = answer.value.trim();
+            }
+        }
+    }
+    // Check for duplicates by package name before adding
+    const duplicates = findAllDuplicates(entry, targetPlatforms);
+    if (duplicates.length > 0) {
+        const action = await handleDuplicatePrompt(duplicates, sanitizedName, targetPlatforms);
+        if (action === 'skip') {
+            const dupeList = duplicates.map(d => `"${d.name}" on ${d.platform}`).join(', ');
+            console.log(`\nSkipped (already installed as ${dupeList})`);
+            return;
+        }
+        if (action === 'replace') {
+            await replaceDuplicates(duplicates, sanitizedName, entry, env, targetPlatforms);
+            return;
+        }
+        if (action === 'cancel') {
+            console.log('\nCancelled');
+            return;
+        }
+    }
+    // Original per-platform logic for name collision checking
+    let addedCount = 0;
+    let skippedCount = 0;
+    for (const platformName of targetPlatforms) {
+        const adapter = getAdapter(platformName);
+        if (!adapter)
+            continue;
+        const servers = adapter.readServers();
+        if (servers.has(sanitizedName)) {
+            console.log(`- ${platformName}: already installed (skipped)`);
+            skippedCount++;
+            continue;
+        }
+        adapter.addServer(sanitizedName, entry, env);
+        console.log(`- ${platformName}: added`);
+        addedCount++;
+    }
+    console.log(`\nAdded "${sanitizedName}" to ${addedCount} platform(s), skipped ${skippedCount}.`);
+}
+async function shouldPromptOptional(name, description) {
+    const answer = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'prompt',
+            message: `Set optional environment variable ${name}?`,
+            default: false,
+        },
+    ]);
+    return answer.prompt;
+}
+async function addManualServer(only) {
+    const answers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'name',
+            message: 'Server name:',
+            validate: (input) => input.trim() ? true : 'Name is required',
+        },
+        {
+            type: 'input',
+            name: 'command',
+            message: 'Command (e.g., npx, node):',
+            validate: (input) => input.trim() ? true : 'Command is required',
+        },
+        {
+            type: 'input',
+            name: 'args',
+            message: 'Arguments (space-separated):',
+        },
+    ]);
+    const env = {};
+    let addMore = true;
+    while (addMore) {
+        const envAnswer = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'key',
+                message: 'Environment variable name (leave empty to skip):',
+            },
+        ]);
+        if (!envAnswer.key.trim()) {
+            addMore = false;
+            break;
+        }
+        const valueAnswer = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'value',
+                message: `Value for ${envAnswer.key}:`,
+            },
+        ]);
+        env[envAnswer.key] = valueAnswer.value;
+    }
+    const userConfig = readUserConfig();
+    if (!userConfig) {
+        console.error('No platforms configured. Run `gmcp init` first.');
+        process.exit(1);
+    }
+    let targetPlatforms = userConfig.platforms;
+    if (only) {
+        const onlyPlatforms = 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);
+        }
+    }
+    // Sanitize the server name for platform compatibility
+    const sanitizedName = sanitizeServerName(answers.name);
+    const manualEntry = {
+        name: sanitizedName,
+        description: 'Manually added server',
+        runtime: answers.command,
+        args: answers.args.trim().split(/\s+/),
+        env: [],
+        tags: [],
+    };
+    // Check for duplicates by package name before adding
+    const duplicates = findAllDuplicates(manualEntry, targetPlatforms);
+    if (duplicates.length > 0) {
+        const action = await handleDuplicatePrompt(duplicates, sanitizedName, targetPlatforms);
+        if (action === 'skip') {
+            const dupeList = duplicates.map(d => `"${d.name}" on ${d.platform}`).join(', ');
+            console.log(`\nSkipped (already installed as ${dupeList})`);
+            return;
+        }
+        if (action === 'replace') {
+            await replaceDuplicates(duplicates, sanitizedName, manualEntry, env, targetPlatforms);
+            return;
+        }
+        if (action === 'cancel') {
+            console.log('\nCancelled');
+            return;
+        }
+    }
+    // Original add logic with name collision checking
+    let addedCount = 0;
+    let skippedCount = 0;
+    for (const platformName of targetPlatforms) {
+        const adapter = getAdapter(platformName);
+        if (!adapter)
+            continue;
+        const servers = adapter.readServers();
+        if (servers.has(sanitizedName)) {
+            console.log(`- ${platformName}: already installed (skipped)`);
+            skippedCount++;
+            continue;
+        }
+        adapter.addServer(sanitizedName, manualEntry, env);
+        console.log(`- ${platformName}: added`);
+        addedCount++;
+    }
+    console.log(`\nAdded "${sanitizedName}" to ${addedCount} platform(s), skipped ${skippedCount}.`);
+}

package/dist/commands/enable-disable.js

@@ -0,0 +1,72 @@
+import { readUserConfig } from '../config.js';
+import { getAdapter } from '../adapters/index.js';
+export async function enableCommand(name) {
+    const userConfig = readUserConfig();
+    if (!userConfig) {
+        console.error('No platforms configured. Run `gmcp init` first.');
+        process.exit(1);
+    }
+    let found = false;
+    let enabledCount = 0;
+    let unsupportedCount = 0;
+    for (const platformName of userConfig.platforms) {
+        const adapter = getAdapter(platformName);
+        if (!adapter)
+            continue;
+        const servers = adapter.readServers();
+        if (!servers.has(name))
+            continue;
+        found = true;
+        const result = adapter.enableServer(name);
+        if (result === null) {
+            console.log(`- ${platformName}: does not support enable/disable — server is already active`);
+            unsupportedCount++;
+        }
+        else {
+            console.log(`- ${platformName}: enabled`);
+            enabledCount++;
+        }
+    }
+    if (!found) {
+        console.log(`${name} is not installed on any platform. Use \`gmcp add ${name}\` to install.`);
+        return;
+    }
+    if (enabledCount > 0) {
+        console.log(`\nEnabled ${name} on ${enabledCount} platform(s).`);
+    }
+}
+export async function disableCommand(name) {
+    const userConfig = readUserConfig();
+    if (!userConfig) {
+        console.error('No platforms configured. Run `gmcp init` first.');
+        process.exit(1);
+    }
+    let found = false;
+    let disabledCount = 0;
+    let unsupportedCount = 0;
+    for (const platformName of userConfig.platforms) {
+        const adapter = getAdapter(platformName);
+        if (!adapter)
+            continue;
+        const servers = adapter.readServers();
+        if (!servers.has(name))
+            continue;
+        found = true;
+        const result = adapter.disableServer(name);
+        if (result === null) {
+            console.log(`- ${platformName}: does not support disable — server remains active`);
+            unsupportedCount++;
+        }
+        else {
+            console.log(`- ${platformName}: disabled`);
+            disabledCount++;
+        }
+    }
+    if (!found) {
+        console.log(`${name} is not installed on any platform.`);
+        return;
+    }
+    if (disabledCount > 0) {
+        console.log(`\nDisabled ${name} on ${disabledCount} platform(s).`);
+    }
+}

package/dist/commands/init.js

@@ -0,0 +1,26 @@
+import inquirer from 'inquirer';
+import { getAllAdapters } from '../adapters/index.js';
+import { writeUserConfig } from '../config.js';
+export async function initCommand() {
+    const adapters = getAllAdapters();
+    const choices = adapters.map(adapter => ({
+        name: adapter.name,
+        value: adapter.name,
+        checked: adapter.detect(),
+    }));
+    const answers = await inquirer.prompt([
+        {
+            type: 'checkbox',
+            name: 'platforms',
+            message: 'Select platforms to manage:',
+            choices,
+        },
+    ]);
+    if (answers.platforms.length === 0) {
+        console.log('No platforms selected. Run `gmcp init` again to configure.');
+        return;
+    }
+    writeUserConfig({ platforms: answers.platforms });
+    console.log(`\nConfigured platforms: ${answers.platforms.join(', ')}`);
+    console.log('You can now use gmcp to manage MCP servers across these platforms.');
+}

package/dist/commands/list.js

@@ -0,0 +1,65 @@
+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 listCommand() {
+    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);
+        }
+    }
+    if (allServers.size === 0) {
+        console.log('No MCP servers found on any platform.');
+        return;
+    }
+    // Build table data
+    const rows = [];
+    const headers = ['Server', ...userConfig.platforms];
+    rows.push(headers);
+    for (const [serverName, platforms] of allServers.entries()) {
+        const row = [serverName];
+        for (const platformName of userConfig.platforms) {
+            const entry = platforms.get(platformName);
+            if (!entry) {
+                row.push('—');
+            }
+            else if (entry.disabled) {
+                row.push('disabled');
+            }
+            else {
+                row.push('active');
+            }
+        }
+        rows.push(row);
+    }
+    // Calculate column widths
+    const colWidths = headers.map((_, colIndex) => {
+        return Math.max(...rows.map(row => row[colIndex].length));
+    });
+    // Print table
+    console.log('\nMCP Servers:\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('');
+}