open-index/open-npm huggingface dataset:
npm package: @m0xoo/server-waiting-room
Description: Waiting Room MCP App Server example using React
Latest version: 1.0.0

# 🛑 The Waiting Room (MCP App)


> **"Nothing to do while your AI agent is working?"**

We’ve all been there: You ask your coding assistant to build a massive new 100-file feature, and then... you wait. You stare at the spinner. You open Twitter. You close Twitter. You look at the spinner again. It's still spinning. 

Why waste your life staring at a loading bar when you could be building a massive baking empire? 🍪

**Waiting Room** is an MCP (Model Context Protocol) App that automatically intercepts moments of boredom. When your AI is taking forever, your agent can seamlessly trigger this app inside your editor to bring up a fun mini-game hub featuring a fully playable **Cookie Clicker** game, complete with upgrades, auto-clickers, and dopamine. 

![Screenshot](waiting-room.png)

---

## 🎮 Features

- **The Hub**: A slick, dark-mode selection screen to choose your distraction.
- **Cookie Clicker**: A fully-fledged clicker game built in React!
  - 🖱️ **Hover Click**: Increase your clicking power.
  - ⚙️ **Auto Clickers**: Sit back and let the machine bake for you.
  - 📈 Progressive scaling costs and beautiful UI feedback.
- **MCP Native**: Integrates seamlessly with any MCP client (like Cursor, VS Code, or your own custom agent environment).

---

## 🚀 Getting Started

To install and play the Waiting Room locally, add this configuration to your MCP client (using the `stdio` transport). 

*Note: Replace `/path/to/waiting-room` with the exact directory where you cloned this repo.*

```json
{
  "mcpServers": {
    "waiting-room-react": {
      "command": "bash",
      "args": [
        "-c",
        "cd /path/to/waiting-room && npm run build >&2 && node dist/index.js --stdio"
      ]
    }
  }
}
```

---

## 🛠️ Development & Customization

Want to add your own games to the Waiting Room? (Flappy Bird, anyone?) 

1. Install dependencies:
   ```bash
   npm install
   ```

2. Watch for changes during development:
   ```bash
   npm run dev
   ```

3. **How It Works**:
   - The server registers an MCP tool called `waiting-room`.
   - The tool contains UI metadata (`_meta.ui`) pointing to a bundled HTML app.
   - The host client intercepts the tool call and renders the React dashboard.
   - The UI communicates back with the host using the `@modelcontextprotocol/ext-apps` SDK.

---

### Give Your Agent Something To Do While You Play

Stop waiting. Start clicking. 🍪
npm package: @m100/core
Description: Shared TRS-80 Model 100/200 BASIC logic used by the CLI and VS Code extension.
Latest version: 0.15.0

# @m100/core

Shared TRS-80 Model 100/200 BASIC logic used by the CLI and VS Code extension.

Exported helpers cover tokenization/detokenization, packing, squashing, renumbering, and comment utilities.
npm package: @m110/m-design
Description: M Designs helps you create beautified radio and checkboxes, and also pre-designed CSS3 boxes, and by just typing out the tags and class, you get the radio, checkboxes, and also styled buttons immediately! Updated README.txt
Author: mrgeek484@gmail.com / m110
Latest version: 2.7.6

#m-design
DO NOT USE the Javascript
README update and fixed m.min.css 
M Designs helps you create beautified radio and checkboxes, and also pre-designed CSS3 boxes, and by just typing out the tags and class, you get the radio, checkboxes, and also styled buttons immediately!

For the default styled radio option (replace the name with your own name) -->
<label class="radio">Option Text
  <input type="radio" name="name"><span class="checkmark-radio"></span>
</label> 


For the default styled checkbox☑ (replace the name with your own name) -->
<label class="checkbox">Option Text
  <input type="checkbox" name="name" checked="checked"><span class="checkmark"></span>
</label>


For custom toggle switch (replace the name with your own one) -->
<label class="toggle">
  <input type="checkbox"><span class="slider round"></span>
</label>
npm package: @m110/node-game
Description: ![](400-250.png)
Latest version: 1.0.0

# \<Div>ine Descent
### a 13kb endless RPG adventure  

![](400-250.png)

Created for [js13kGames](http://js13kgames.com/) competition.  

Made out of divs only, no canvas involved. _11 kilobytes with all the dependencies._ 

Venture into the depths of an endless procedurally generated dungeon,
hunt for greater loot, earn gold and try to stay alive for as long as you can.

This is the very early release, many things should and must be improved, feel free to open an issue or a pull request.
Zipped game (with all the assets and deps) must not exceed **13k** bytes.

##### How to play:

- clone repo or download zip
- unzip
- run `index.html`  

Cursors to move.   
If you decide to equip a new piece of gear an old one will be replaced and sold.

First foe is the hardest so steel yourself.


##### How to develop:

- fork
- clone
- `npm install`
- `npm start`
npm package: @m1212e/s3minibun
Description: 👶 Tiny & fast S3 client for node and edge computing platforms
Author: good-lly
Latest version: 0.6.0

# s3minibun | Tiny & fast S3 client optimized for bun.

Fork of https://github.com/good-lly/s3mini optimized for bun. For more documentation, see the original repo.

## Installation

```bash
npm install @m1212e/s3minibun
yarn add @m1212e/s3minibun
pnpm add @m1212e/s3minibun
bun add @m1212e/s3minibun
```
## Usage

```typescript
import { S3mini, createOptimizedS3mini } from '@m1212e/s3minibun';

//original way of using S3mini
const s3client = new S3mini({
  accessKeyId: config.accessKeyId,
  secretAccessKey: config.secretAccessKey,
  endpoint: config.endpoint,
  region: config.region,
});

// or the bun optimized way this package offers over the original
const optimizeds3client = createOptimizedS3mini({
  accessKeyId: config.accessKeyId,
  secretAccessKey: config.secretAccessKey,
  endpoint: config.endpoint,
  region: config.region,
})

// ... do something with the clients ...
```
npm package: @m1212e/simple-transactions
Description: A simple transaction wrapper for JavaScript. Allows to register rollback functions during a transaction run. Rollback functions will be called in reverse order if the transaction throws an error.
Latest version: 1.0.2

# simple-transactions
A simple transaction wrapper for JavaScript. Allows to register rollback functions during a transaction run. Rollback functions will be called in reverse order if the transaction throws an error.

## Getting Started
```bash
bun add @m1212e/simple-transactions
npm i @m1212e/simple-transactions
```

## Usage
```ts
    import { transaction } from '@m1212e/simple-transactions';

    try {
      // create a transaction
      const returnOfTransactionIsReturnOfFn2 = await transaction((tx) => {
        // register a call with a rollback function
        // this could be an API fetch to create an entity
        // in case of failure, the delete call will be called to rollback the creation
        tx({ fn: workingCreationCall, rollback: workingDeletionCall });
        
        // you can register multiple functions with rollback functions inside one transaction
        tx({ fn: fn1, rollback: rollback1 });
        // the return value of fn2 will be returned by the transaction call
        const retOfFn2 = tx({ fn: fn2, rollback: rollback2 });
        
        // when this error is thrown, the rollback begins and after completing, the error will be thrown again by the transaction call
        throw new Error("test"); 
        
        // if there would be not error inside the call before the return statement, the transaction will be successful and the return value of fn2 will be returned
        return retOfFn2;
      });
    } catch (error) {
      // Before throwing the error we catch here, rollback2 -> rollback1 -> workingDeletionCall are called and awaited completely
      // at this point the transaction is already rolled back

      console.error(error.message); // test
    }
```
### Finalizers
Sometimes it might be useful to register some calls throughout the lifetime of a transaction, that are supposed to run at the end, after the transaction completed.
For this, you can use finalizers. They can be registered as part of a transaction call or manually at any time on a transaction object:
```ts
transaction((tx) => {
  tx.onFinalize(finalizer);         // manually
  tx({ fn, rollback, finalizer });  // as part of a transaction call
});
```
Both ways of registering do not differ in functionality. The finalizers receive the success or failure state of the transaction as parameter (boolean, true for success, false for failure).

## Configuration
You can configure the transaction with a few helpful options passed as the second parameter.
```ts
  const returnOfTransactionIsReturnOfFn2 = await transaction((tx) => {...}, 
    { timeout: 1000 } // error after 1 second if the transaction is not completed by then
  );
```