JavaScript Packaging¶

// rollup.config.js
import { nodeResolve } from '@rollup/plugin-node-resolve';
import { terser } from 'rollup-plugin-terser';
import commonjs from '@rollup/plugin-commonjs';
import json from '@rollup/plugin-json';

const isProduction = process.env.NODE_ENV === 'production';

export default [
  // ESM build
  {
    input: 'dist/index.js',
    output: {
      file: 'dist/index.esm.js',
      format: 'esm',
      sourcemap: true
    },
    plugins: [
      nodeResolve({ preferBuiltins: true }),
      json(),
      isProduction && terser()
    ].filter(Boolean),
    external: [
      '@modelcontextprotocol/sdk',
      'node:fs',
      'node:path',
      'node:process'
    ]
  },
  
  // CommonJS build
  {
    input: 'dist/index.js', 
    output: {
      file: 'dist/index.cjs',
      format: 'cjs',
      sourcemap: true
    },
    plugins: [
      nodeResolve({ preferBuiltins: true }),
      commonjs(),
      json(),
      isProduction && terser()
    ].filter(Boolean),
    external: [
      '@modelcontextprotocol/sdk'
    ]
  },

  // Binary executable
  {
    input: 'dist/server.js',
    output: {
      file: 'bin/server.js',
      format: 'cjs',
      banner: '#!/usr/bin/env node',
      sourcemap: false
    },
    plugins: [
      nodeResolve({ preferBuiltins: true }),
      commonjs(),
      json(),
      terser()
    ],
    external: []
  }
];

#!/usr/bin/env node
// bin/server.js

import { fileURLToPath } from 'node:url';
import { dirname, join } from 'node:path';
import { readFileSync } from 'node:fs';

const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);

// Load package.json for version info
const packageJson = JSON.parse(
  readFileSync(join(__dirname, '../package.json'), 'utf8')
);

// CLI argument parsing
function parseArgs() {
  const args = process.argv.slice(2);
  const options = {
    version: false,
    help: false,
    config: null,
    port: process.env.PORT || 8000,
    transport: 'stdio'
  };

  for (let i = 0; i < args.length; i++) {
    switch (args[i]) {
      case '--version':
      case '-v':
        options.version = true;
        break;
      case '--help':
      case '-h':
        options.help = true;
        break;
      case '--config':
      case '-c':
        options.config = args[++i];
        break;
      case '--port':
      case '-p':
        options.port = parseInt(args[++i]);
        break;
      case '--transport':
      case '-t':
        options.transport = args[++i];
        break;
      default:
        console.error(`Unknown option: ${args[i]}`);
        process.exit(1);
    }
  }

  return options;
}

// Display help text
function showHelp() {
  console.log(`
${packageJson.name} v${packageJson.version}

Usage: mcp-server [options]

Options:
  -v, --version              Show version number
  -h, --help                 Show help
  -c, --config <file>        Configuration file path
  -p, --port <number>        Port number (default: 8000)
  -t, --transport <type>     Transport type: stdio|http (default: stdio)

Examples:
  mcp-server                 Start with stdio transport
  mcp-server -t http -p 8000 Start HTTP server on port 8000
  mcp-server -c config.json  Start with custom configuration
`);
}

// Main execution
async function main() {
  const options = parseArgs();

  if (options.version) {
    console.log(packageJson.version);
    process.exit(0);
  }

  if (options.help) {
    showHelp();
    process.exit(0);
  }

  try {
    const { MCPServer } = await import('../dist/index.js');
    
    const server = new MCPServer({
      name: packageJson.name,
      version: packageJson.version,
      configFile: options.config
    });

    console.log(`Starting ${packageJson.name} v${packageJson.version}`);
    console.log(`Transport: ${options.transport}`);
    
    if (options.transport === 'http') {
      console.log(`Port: ${options.port}`);
      await server.listen(options.port);
    } else {
      console.log('Using stdio transport');
      await server.run();
    }
    
  } catch (error) {
    console.error('Failed to start server:', error.message);
    process.exit(1);
  }
}

// Handle process signals
process.on('SIGINT', () => {
  console.log('\nReceived SIGINT, shutting down gracefully...');
  process.exit(0);
});

process.on('SIGTERM', () => {
  console.log('\nReceived SIGTERM, shutting down gracefully...');
  process.exit(0);
});

main().catch((error) => {
  console.error('Unhandled error:', error);
  process.exit(1);
});

// webpack.config.js
const path = require('path');
const HtmlWebpackPlugin = require('html-webpack-plugin');
const { CleanWebpackPlugin } = require('clean-webpack-plugin');

module.exports = (env, argv) => {
  const isProduction = argv.mode === 'production';
  
  return {
    entry: {
      main: './src/browser/index.js',
      worker: './src/browser/worker.js'
    },
    
    output: {
      filename: isProduction ? '[name].[contenthash].js' : '[name].js',
      path: path.resolve(__dirname, 'dist/browser'),
      clean: true,
      library: {
        name: 'MCPClient',
        type: 'umd'
      }
    },
    
    module: {
      rules: [
        {
          test: /\.js$/,
          exclude: /node_modules/,
          use: {
            loader: 'babel-loader',
            options: {
              presets: [
                ['@babel/preset-env', {
                  targets: {
                    browsers: ['> 1%', 'last 2 versions']
                  }
                }]
              ]
            }
          }
        },
        {
          test: /\.css$/i,
          use: ['style-loader', 'css-loader']
        },
        {
          test: /\.(png|svg|jpg|jpeg|gif)$/i,
          type: 'asset/resource'
        }
      ]
    },
    
    plugins: [
      new CleanWebpackPlugin(),
      new HtmlWebpackPlugin({
        title: 'MCP Client',
        template: './src/browser/index.html',
        chunks: ['main']
      })
    ],
    
    optimization: {
      splitChunks: {
        chunks: 'all',
        cacheGroups: {
          vendor: {
            test: /[\\/]node_modules[\\/]/,
            name: 'vendors',
            chunks: 'all',
          }
        }
      }
    },
    
    devServer: {
      static: './dist/browser',
      port: 3000,
      hot: true,
      open: true
    },
    
    resolve: {
      fallback: {
        "buffer": require.resolve("buffer/"),
        "process": require.resolve("process/browser"),
        "stream": require.resolve("stream-browserify"),
        "util": require.resolve("util/")
      }
    }
  };
};

// scripts/publish.js
#!/usr/bin/env node

import { execSync } from 'child_process';
import { readFileSync, writeFileSync } from 'fs';

// Validate environment
if (!process.env.NPM_TOKEN) {
  console.error('NPM_TOKEN environment variable is required');
  process.exit(1);
}

// Read package.json
const packageJson = JSON.parse(readFileSync('package.json', 'utf8'));
const currentVersion = packageJson.version;

console.log(`Publishing ${packageJson.name} v${currentVersion}`);

try {
  // Run pre-publish checks
  console.log('Running pre-publish checks...');
  execSync('npm run lint', { stdio: 'inherit' });
  execSync('npm test', { stdio: 'inherit' });
  execSync('npm run build', { stdio: 'inherit' });
  
  // Publish to npm
  console.log('Publishing to npm...');
  execSync('npm publish --access public', { stdio: 'inherit' });
  
  // Create git tag
  console.log('Creating git tag...');
  execSync(`git tag v${currentVersion}`, { stdio: 'inherit' });
  execSync('git push origin --tags', { stdio: 'inherit' });
  
  console.log(`✅ Successfully published ${packageJson.name} v${currentVersion}`);
  
} catch (error) {
  console.error('❌ Publish failed:', error.message);
  process.exit(1);
}

// scripts/build-all.js
import { execSync } from 'child_process';
import { mkdirSync, existsSync } from 'fs';

// Ensure dist directory exists
if (!existsSync('dist')) {
  mkdirSync('dist', { recursive: true });
}

console.log('Building all distribution formats...');

// Build TypeScript
console.log('📦 Building TypeScript...');
execSync('tsc', { stdio: 'inherit' });

// Build ES modules
console.log('📦 Building ES modules...');
execSync('rollup -c --format es --file dist/index.esm.js', { stdio: 'inherit' });

// Build CommonJS
console.log('📦 Building CommonJS...');
execSync('rollup -c --format cjs --file dist/index.cjs', { stdio: 'inherit' });

// Build UMD for browsers
console.log('📦 Building UMD...');
execSync('rollup -c --format umd --name MCPServer --file dist/index.umd.js', { stdio: 'inherit' });

// Build minified version
console.log('📦 Building minified version...');
execSync('rollup -c --format umd --name MCPServer --file dist/index.umd.min.js --environment NODE_ENV:production', { stdio: 'inherit' });

// Build CLI executable
console.log('📦 Building CLI executable...');
execSync('rollup -c rollup.cli.config.js', { stdio: 'inherit' });

console.log('✅ All builds completed successfully!');