open-index/open-npm huggingface dataset:
npm package: @iflow-mcp/lciesielski-mcp-salesforce
Description: This project provides a basic example of integrating with Salesforce using the Model Context Protocol (MCP). It allows interaction with Salesforce features like sending emails and deploying Apex code through MCP tools.
Latest version: 1.0.0

# Salesforce MCP Sample Integration

This project provides a basic example of integrating with Salesforce using the Model Context Protocol (MCP). It allows interaction with Salesforce features like sending emails and deploying Apex code through MCP tools.

## Prerequisites

*   Node.js and npm (or yarn) installed.
*   A Salesforce org where you can create a Connected App.

## Setup

1.  **Install Dependencies:**
    ```bash
    npm install
    # or
    yarn install
    ```

2.  **Configure Salesforce Credentials:**
    *   You MUST create a `credentials.js` file inside a `utils` folder (`./utils/credentials.js`).
    *   This file needs to export a function `getSalesforceCredentials()` which returns your Salesforce connection details necessary for JWT Bearer Flow authentication.
    *   **Important:** Ensure you have a [Connected App configured in Salesforce](https://help.salesforce.com/s/articleView?id=sf.connected_app_create_api_integration.htm&type=5) for JWT authentication, allowing the appropriate scopes and pre-authorizing the relevant user profile.

    **`utils/credentials.js` Example:**

    ```javascript
    import fs from 'fs';
    import path from 'path';
    // You might load these from environment variables, a config file, etc.

    export function getSalesforceCredentials() {
        // --- IMPLEMENT YOUR LOGIC HERE to securely load credentials ---
        const loginUrl = "YOUR_SALESFORCE_LOGIN_URL"; // e.g., https://login.salesforce.com or https://yourdomain.my.salesforce.com
        const username = "YOUR_SALESFORCE_USERNAME";
        const clientId = "YOUR_CONNECTED_APP_CONSUMER_KEY";
        // Load your private key used to sign the JWT assertion
        // Ensure the key is formatted correctly, including BEGIN/END lines.
        const privateKey = fs.readFileSync(path.resolve(__dirname, 'path/to/your/server.key'), 'utf8'); 
        // Example: const privateKey = process.env.SF_PRIVATE_KEY;

        if (!loginUrl || !username || !clientId || !privateKey) {
             throw new Error("Missing required Salesforce credentials in utils/credentials.js");
        }

        return {
            loginUrl,
            username,
            clientId,
            privateKey
        };
    }
    ```

3.  **Configuration File:**
    *   The repository includes a sample `claude_desktop_config.json` file that can be used as a template for configuring your MCP server.
    *   Update the paths and credentials in this file according to your environment setup.

## Running the Server

```bash
node server.js
```

## Demo

https://github.com/user-attachments/assets/08c8015a-bc57-4c5e-9f3d-4a9d9d310f4c

[Video in higher quality](https://www.youtube.com/watch?v=T883nXqatZ4).
npm package: @iflow-mcp/leomercier-mcp-tunnel
Description: MCP server for accessing VM command line with web tunneling
Latest version: 1.0.0

# MCP Tunnel

A simple MCP (Model Context Protocol) server that allows accessing the command line of a VM machine. When started, it also tunnels the host to the web so it can be accessed via MCP.

## Features

- Execute shell commands on a VM through MCP
- Web-based terminal interface for VM interaction
- Automatic tunneling to make the VM accessible from anywhere
- WebSocket-based real-time communication

## Prerequisites

- Node.js (v18 or newer)

## Installation and Usage

### Running with npx (no installation)

```bash
npx mcp-cli
```

### Global Installation

```bash
npm install -g mcp-cli
mcp-cli
```

### Local Development

```bash
# Clone repository
git clone [repository-url]
cd mcp-cli

# Install dependencies
npm install
```

## Development

Run the development server with hot-reloading for both backend and frontend:

```bash
npm run dev
```

## Building

Build both the frontend and backend for production:

```bash
npm run build-all
```

## Usage

1. Start the MCP server:

```bash
# Start with automatic tunneling
npm start

# Start without automatic tunneling
npm start -- --no-tunnel
```

This will build the project and start the server. By default, a tunnel will be created automatically. Use the `--no-tunnel` flag to disable automatic tunneling.

2. The server will start and provide output on stderr (to avoid interfering with MCP communication on stdout)

3. Use MCP to interact with the server using the following tools:

### Available MCP Tools

- `execute_command`: Run a shell command on the VM
  - Parameters: `{ "command": "your shell command" }`
- `start_tunnel`: Create a web tunnel to access the VM interface
  - Parameters: `{ "port": 8080, "subdomain": "optional-subdomain" }`

## Web Interface

After starting the tunnel, you can access the web-based terminal interface at the URL provided by the tunnel. This interface allows you to:

- Execute commands directly in the VM
- See command outputs in real-time
- Interact with the VM from any device with web access

## Environment Variables

Create a `.env` file to configure the server:

```
# Server configuration
PORT=8080

# Localtunnel configuration
LOCALTUNNEL_SUBDOMAIN=your-preferred-subdomain
```

## Security Considerations

This tool provides direct access to your VM's command line. Consider these security practices:

- Use strong authentication mechanisms before exposing the tunnel
- Limit the commands that can be executed through proper validation
- Consider running in a restricted environment
- Do not expose sensitive information through the tunnel