open-index/open-npm huggingface dataset:
npm package: @sulagnaaaaa/communication
Description: MCP Communication tools for email and WhatsApp
Author: MCP Utilities Team
Latest version: 1.0.0

# @mcp-utilities/communication

MCP Communication tools for email and WhatsApp messaging.

## Features

- **Email Communication**: Send professional emails via Gmail API with OAuth2 authentication
- **WhatsApp Communication**: Send WhatsApp messages via WhatsApp Business API
- **File Attachments**: Support for various file formats in both email and WhatsApp
- **HTML Formatting**: Rich email content with HTML formatting
- **Template Support**: WhatsApp template messages with dynamic parameters

## Installation

```bash
npm install @mcp-utilities/communication
```

## Usage

### As a Package

```typescript
import CommunicationPackage from '@mcp-utilities/communication';

// Initialize with configuration
await CommunicationPackage.initialize({
  oauth: {
    clientId: 'your_gmail_oauth_client_id',
    clientSecret: 'your_gmail_oauth_client_secret',
    accessToken: 'your_access_token',
    refreshToken: 'your_refresh_token'
  },
  whatsapp: {
    token: 'your_whatsapp_api_token',
    url: 'https://graph.facebook.com/v18.0/YOUR_PHONE_NUMBER_ID/messages'
  }
});

// Get available tools
const tools = CommunicationPackage.tools;

// Call a tool
const result = await CommunicationPackage.callTool('mail_communication', {
  subject: 'Test Email',
  content: '<h1>Hello</h1><p>This is a test email.</p>',
  recipient: ['test@example.com']
});
```

### Available Tools

#### mail_communication
Send formal emails with HTML content support, CC, and BCC capabilities.

**Parameters:**
- `subject` (string): Email subject line (max 100 characters)
- `content` (string): HTML email content with formatting support
- `recipient` (array): Main recipient email addresses
- `cc` (array, optional): Carbon copy recipients
- `bcc` (array, optional): Blind carbon copy recipients
- `attachment_paths` (array, optional): File paths to attachments

#### whatsapp_communication
Send quick WhatsApp messages to individual recipients.

**Parameters:**
- `content` (string): Plain text message content
- `recipient` (string): WhatsApp phone number (E.164 or local format)
- `attachment_path` (string, optional): File path to attachment

## Configuration

### Gmail OAuth Setup

1. Go to [Google Cloud Console](https://console.cloud.google.com/)
2. Create a new project or select existing
3. Enable the Gmail API
4. Create OAuth 2.0 credentials (Desktop application)
5. Set authorized redirect URIs: `http://localhost:3000/oauth2callback`

### WhatsApp Business API Setup

1. Set up WhatsApp Business API account
2. Create a message template named "whatsapp_template"
3. Get your phone number ID and access token

## Dependencies

- `@modelcontextprotocol/sdk`: MCP protocol support
- `googleapis`: Gmail API integration
- `google-auth-library`: OAuth2 authentication
- `axios`: HTTP client for WhatsApp API
- `form-data`: File upload support
- `pdfkit`: PDF generation
- `mime-types`: MIME type detection

## License

MIT License
npm package: @sulcata/eslint-config
Description: Some ESLint configs
Author: sulcata
Latest version: 1.0.0

# @sulcata/eslint-config

![npm latest version](https://img.shields.io/npm/v/@sulcata/eslint-config)
![npm weekly downloads](https://img.shields.io/npm/dw/@sulcata/eslint-config)
![GitHub](https://img.shields.io/github/license/sulcata/sulcata-eslint-config)
![GitHub Workflow Deployment Status](https://img.shields.io/github/workflow/status/sulcata/sulcata-eslint-config/Node.js%20Package?label=deployment)
![GitHub Workflow Integration Status](https://img.shields.io/github/workflow/status/sulcata/sulcata-eslint-config/Node.js%20CI?label=integration)
![supported node versions](https://img.shields.io/node/v/@sulcata/eslint-config)

A shareable set of [ESLint](https://eslint.org/) configurations for [TypeScript](https://www.typescriptlang.org/), [React](https://reactjs.org/), and more. Intended to be opinionated in practices, not style.

If you're looking for opinionated style, I highly recommend [Prettier](https://github.com/prettier/prettier).

## Install

```bash
npm install @sulcata/eslint-config
```

Sadly because of the way the configuration system currently works, you'll also need to install the following peer dependencies for now.

```bash
npm install eslint-plugin-jest eslint-plugin-jsx-a11y eslint-plugin-react eslint-plugin-react-hooks
```

Once ESLint starts rolling out the [new configuration system](https://github.com/eslint/rfcs/pull/9), this package will be changed to bundle them transparently.

## Usage

Writing your ESLint `.eslintrc.js` config file can be as simple as:

```js
"use strict";

module.exports = {
  root: true,
  parserOptions: {
    tsconfigRootDir: __dirname,
    project: ["./tsconfig.json"],
  },
  extends: ["@sulcata/eslint-config"],
};
```

This package exports a number of shareable configs that can be imported into your configuration using the ESLint config [`"extends"`](https://eslint.org/docs/user-guide/configuring/configuration-files#extending-configuration-files) key.

- `@sulcata/eslint-config` The kitchen sink, most likely what you want for minimal configuration. Pre-configured using the overrides feature to match file extensions to the appropriate configs. Includes `recommended`, `typescript`, `react`, and `jest`. Requires `tsconfigRootDir` and `project` to be configured in `parserOptions` for type information.
- `@sulcata/eslint-config/recommended` for general JavaScript linting.
- `@sulcata/eslint-config/typescript` for TypeScript linting. Requires `tsconfigRootDir` and `project` to be configured in `parserOptions` for type information.
- `@sulcata/eslint-config/react` for React apps.
- `@sulcata/eslint-config/jest` for Jest test suites.

## Issues

Raise an issue (or a PR) if you notice any styling related rules bubbling up.

[GitHub Issues](https://github.com/sulcata/sulcata-eslint-config/issues)

## License

[MIT License](LICENSE)
npm package: @suldashi/lame
Description: NodeJS native bindings to libmp3lame & libmpg123. Fixed bindings for Node 12
Author: Nathan Rajlich
Latest version: 1.2.5

node-lame
=========
### NodeJS native bindings to libmp3lame & libmpg123
[![Build Status](https://travis-ci.org/TooTallNate/node-lame.svg?branch=master)](https://travis-ci.org/TooTallNate/node-lame)

For all your async streaming MP3 encoding/decoding needs, there's `node-lame`!
This module hooks into libmp3lame, the library that the `lame` command uses, to
provide `Encoder` and `Decoder` streams to NodeJS.


Installation
------------

`node-lame` comes bundled with its own copy of `libmp3lame` and `libmpg123`, so
there's no need to have them installed on your system.

Simply compile and install `node-lame` using `npm`:

``` bash
$ npm install lame
```


Example
-------

Here's an example of using `node-lame` to encode some raw PCM data coming from
`process.stdin` to an MP3 file that gets piped to `process.stdout`:

``` javascript
var lame = require('lame');

// create the Encoder instance
var encoder = new lame.Encoder({
  // input
  channels: 2,        // 2 channels (left and right)
  bitDepth: 16,       // 16-bit samples
  sampleRate: 44100,  // 44,100 Hz sample rate

  // output
  bitRate: 128,
  outSampleRate: 22050,
  mode: lame.STEREO // STEREO (default), JOINTSTEREO, DUALCHANNEL or MONO
});

// raw PCM data from stdin gets piped into the encoder
process.stdin.pipe(encoder);

// the generated MP3 file gets piped to stdout
encoder.pipe(process.stdout);
```

See the `examples` directory for some more example code.

API
---

### Decoder class

The `Decoder` class is a `Stream` subclass that accepts MP3 data written to it,
and outputs raw PCM data. It also emits a `"format"` event when the format of
the MP3 file is determined (usually right at the beginning).

### Encoder class

The `Encoder` class is a `Stream` subclass that accepts raw PCM data written to
it, and outputs a valid MP3 file. You must specify the PCM data format when
creating the encoder instance. Only 16-bit signed samples are currently
supported (rescale before passing to the encoder if necessary)...
npm package: @suldashi/node-opus
Description: NodeJS native binding to OPUS. Fixed dependencies to enable compilation in Node 12.
Author: Mikko Rantanen
Latest version: 0.3.5

node-opus
=========
### NodeJS native bindings to libopus

This module implements bindings for Opus v1.1 for Node.js.

```js
var opus = require('node-opus');

// Create the encoder.
// Specify 48kHz sampling rate and 10ms frame size.
// NOTE: The decoder must use the same values when decoding the packets.
var rate = 48000;
var encoder = new opus.OpusEncoder( rate );

// Encode and decode.
var frame_size = rate/100;
var encoded = encoder.encode( buffer, frame_size );
var decoded = encoder.decode( encoded, frame_size );

// or create streams
var channels = 2;
var opusEncodeStream = new opus.Encoder(rate, channels, frame_size);
var opusDecodeStream = new opus.Decoder(rate, channels, frame_size);
// see examples folder for a more complete example
```

Platform support
----------------

Supported platforms:
- Linux x64 & ia32
- Linux ARM (Raspberry Pi 1 & 2)
- Linux ARM64 (Raspberry Pi 3)
- Mac OS X x64
- Windows x64


Add new supported platforms by running ./autogen.sh and ./configure in
deps/opus and copying the resulting config.h to deps/config/opus/[os]/[arch].

Use the following flags with configure:

    ./configure --enable-static --disable-shared --with-pic

On a clean debian-based system, the full flow looks approximately like:

	sudo apt-get update
	sudo apt-get install autoconf
	sudo apt-get install libtool
	cd deps/opus
	./autogen.sh
	./configure --enable-static --disable-shared --with-pic
	mkdir -p ../config/opus/[os]/[arch]
	cp config.h ../config/opus/[os]/[arch]

And, then, the last step is to add the OS/Arch to `package.json`.
npm package: @suldashi/ogg-packet
Description: Manually construct `ogg_packet` struct instances. Fixed Node 12 builds
Author: Nathan Rajlich
Latest version: 1.0.3

node-ogg-packet
===============
### Manually construct `ogg_packet` struct instances

This module lets you construct your own `ogg_packet` struct instances using
JavaScript and Buffers. You'll most likely not need to use this module for any
practical purposes, but it is useful for testing purposes.

The more common way to get _proper_ `ogg_packet` structs is via a decoded OGG file
and node-ogg's `ogg.Decoder` class, or one of the codec's encoder classes like
node-vorbis' `vorbis.Encoder` class.


Installation
------------

``` bash
$ npm install ogg-packet
```


Example
-------

``` javascript
var ogg_packet = require('ogg-packet');

// create an `ogg_packet` struct instance
var packet = new ogg_packet();

// the contents of the "packet"
var buf = new Buffer('hello world');
packet.packet = buf;
packet.bytes = buf.length;

// this will be the first packet in the ogg stream
packet.b_o_s = 1;

// there will be more `ogg_packet`s after this one in the ogg stream
packet.e_o_s = 0;

// the "granulepos" is a time-constant value used by the codec decoder
packet.granulepos = 12345;

// the "packetno" should increment by one for each packet in the ogg stream
packet.packetno = 0;

// now send the packet off to an `ogg.Encoder` or
// a codec-specific decoder like `vorbis.Decoder`...
stream.packetin(packet.buffer, function (err) { /* ... */ });
```


API
---

### ogg_packet class

A `ref-struct` class that mirrors the `ogg_packet` fields in the `ogg.h` file.

``` c
typedef struct {
  unsigned char *packet;
  long  bytes;
  long  b_o_s;
  long  e_o_s;
  ogg_int64_t  granulepos;
  ogg_int64_t  packetno;
} ogg_packet;
 ```
npm package: @sulekaustubh/easy-api
Description: A simple wrapper around axios for easier API calls
Author: Kaustubh Sule
Latest version: 1.0.2

# easy-api

A simple wrapper around axios for easier GET API calls.

## Installation

```bash
npm install easy-api
```

## Usage

### Basic Usage

```javascript
import { api_get } from "easy-api";

// Simple GET request
const getData = async () => {
	try {
		// Just provide the endpoint
		const data = await api_get("/users");
		console.log(data);
	} catch (error) {
		console.error(error);
	}
};
```

### With Authentication

```javascript
import { api_get } from "easy-api";

// GET request with authentication
const getProtectedData = async () => {
	try {
		// Set requiresAuth to true to use the token from localStorage
		const data = await api_get("/protected-resource", true);
		console.log(data);
	} catch (error) {
		console.error(error);
	}
};
```

### With React

```javascript
import React, { useEffect, useState } from "react";
import { api_get } from "easy-api";

function UserList() {
	const [users, setUsers] = useState([]);
	const [loading, setLoading] = useState(true);
	const [error, setError] = useState(null);

	useEffect(() => {
		const fetchUsers = async () => {
			try {
				const data = await api_get("/users", true);
				setUsers(data);
			} catch (err) {
				setError(err.message || "Failed to fetch users");
			} finally {
				setLoading(false);
			}
		};

		fetchUsers();
	}, []);

	if (loading) return <div>Loading...</div>;
	if (error) return <div>Error: {error}</div>;

	return (
		<div>
			<h1>Users</h1>
			<ul>
				{users.map((user) => (
					<li key={user.id}>{user.name}</li>
				))}
			</ul>
		</div>
	);
}

export default UserList;
```

## API

### Function

-   `api_get(endpoint, requiresAuth, options)`

### Parameters

-   `endpoint`: The API endpoint to call
-   `requiresAuth`: Whether the request requires authentication (will use token from localStorage)
-   `options`: Additional axios options

## Configuration

This package uses the following environment variables:

-   `NEXT_PUBLIC_BACKEND_URL`: Base URL for the API

## License

MIT