open-index/open-npm huggingface dataset:
npm package: @netfx/angular2-typescript-netfx
Description: angular 6.0.0+ typescript sdk for building on top of the netfx platform
Author: netfx.io
Latest version: 0.1.2

# NetFx.io's Angular SDK

> The official client library for Angular (6.0.0+) NetFx.io platform

This SDK aims to greatly improve developer productivity and reduce errors by providing discoverable, strongly-typed wrappers for all public endpoints and request/response models.

All included methods are a 1:1 reflection of the API with the *addition* of the `NetFxAuthService` for authentication and the `NetFxTokenService` exposed as a convenience service for setting and getting authentication tokens

### Acknowledgement

This Angular SDK is made possible by leveraging [Swagger's](https://swagger.io/) open source tools with our Open API Specification: `https://netfx.io/swagger`

### Requirements
* angular 6.0.0+
* [ngx-cookie](https://github.com/salemdar/ngx-cookie) 4.0.0+

### Installation

From the npm registry:

```
npm install --save @netfx/angular2-typescript-netfx
```

### Configuration

In your root app module:

```typescript
import { NetFxModule, Configuration } from '@netfx/angular2-typescript-netfx';

export function apiConfigFactory() {
  return new Configuration({
    authPath: `https:\\api.netfx.io\oauth\token`,
    basePath: `https:\\api.netfx.io`,
    cookiePrefix: `netfx`,
  });
}

@NgModule({
  declarations: [...],
  imports: [
    NetFxModule.forRoot(apiConfigFactory),
     ...
  ],
  providers: [...]
  bootstrap: [AppComponent]
})
export class AppModule {}
```

### Example API call for OAuth authentication

```typescript
import { Component, OnInit, Input } from '@angular/core';

import { ToastrService } from 'ngx-toastr';
import { TokenRequest } from './token-request';
import { NetFxAuthService, NetFxTokenService } from '@netfx/angular2-typescript-netfx';

@Component({
  selector: 'netfx-login',
  templateUrl: './login.component.html',
  styleUrls: ['./login.component.scss']
})
export class LoginComponent implements OnInit {
  @Input() credentials: TokenRequest = new TokenRequest();

  constructor(
    private toastr: ToastrService,
    private authService: NetFxAuthService,
    private tokenService: NetFxTokenService
  ) {
    this.credentials.username = 'example_username';
    this.credentials.password = 'XXXX';
    this.credentials.client_id = 'XXXX';
    this.credentials.grant_type = 'password';
    this.credentials.scope = ['FullAccess'];
  }

  ngOnInit() {
  }

  login(): void {
    this.authService.Get(this.credentials).subscribe(response => {
        this.tokenService.Set(response.access_token);
        this.toastr.success('Success', 'Login Attempt');
    });
  }

}
```
npm package: @netglade/mcp-sandbox
Description: MCP Sandbox on E2B
Author: NetGlade
Latest version: 0.0.11

# MCP Sandbox

<p align='center'><b>Run Model Context Protocol (MCP) servers in E2B's sandbox environment</b></p>

<p align='center'><b>🏆 <a href="https://www.linkedin.com/feed/update/urn:li:activity:7310193814466408448">Winner of the E2B Agents and AI Tools Hackathon</a></b></p>

<div align="center">

[![npm version](https://img.shields.io/npm/v/%40netglade%2Fmcp-sandbox)](https://www.npmjs.com/package/@netglade/mcp-sandbox)
[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)

[🎮 Live Demo](https://netglade.github.io/mcp-chat/) | [📦 Demo Repository](https://github.com/netglade/mcp-chat) | [📝 Blog Post](https://www.netglade.cz/en/blog/bringing-mcps-to-the-cloud-how-we-won-the-e2b-hackathon)

</div>

## Overview

MCP Sandbox enables you to run Model Context Protocol (MCP) servers directly in the browser using [E2B's sandbox environment](https://e2b.dev). This package makes it easy to integrate AI assistants with tools and data sources without requiring any local setup.


## Installation

```bash
npm install @netglade/mcp-sandbox
```

## Quick Start

```javascript
import { startMcpSandbox } from '@netglade/mcp-sandbox';

// Start the MCP sandbox
const mcpSandbox = await startMcpSandbox({
  command: 'npx -y @modelcontextprotocol/server-brave-search',
  apiKey: 'e2b_****',
});

// Get the MCP server URL to connect your AI assistant
const mcpUrl = mcpSandbox.getUrl();
console.log("MCP server URL:", mcpUrl);
```

## How It Works

1. **MCP Server Execution**: Uses [supergateway](https://github.com/supercorp-ai/supergateway) to run stdio-based MCP servers over SSE (Server-Sent Events)
2. **Sandbox Environment**: Runs in [E2B](https://e2b.dev)'s secure sandbox environment, providing isolated execution
3. **Tool Integration**: Seamlessly connects AI assistants with real-world tools and data sources
4. **Browser Support**: Everything runs directly in the browser without local dependencies

## Examples and Resources

- 🎮 [Live Demo](https://netglade.github.io/mcp-chat/) - Try it directly in your browser
- 📦 [Demo Repository](https://github.com/netglade/mcp-chat) - Full example implementation
- 📝 [Blog Post](https://www.netglade.cz/en/blog/bringing-mcps-to-the-cloud-how-we-won-the-e2b-hackathon) - Learn about the project's journey

## Contributing

We welcome contributions! Feel free to open issues and pull requests.

## License

[MIT](LICENSE)
npm package: @netglade/vite-plugin-root-redirect
Description: Redirect Vite's development server root to custom URL
Author: NetGlade s.r.o.
Latest version: 0.0.10

<br/>

<h1 align='center'>vite-plugin-root-redirect</h1>

<p align='center'><b>Redirect Vite's development server root to custom URL</b></p>

<p align='center'>Useful for projects with nested or multiple entry points.</p>

<br/>

## Installation

```shell
npm install -D @netglade/vite-plugin-root-redirect
```

## Example

How to launch Vite in development aimed at `src/views/Dashboard/index.html`:

Example folder structure:

```
├── src
│   ├── views
│   │   ├── Dashboard
│   │   │   ├── index.html
│   │   │   ├── index.ts
│   │   │   // other framework-specific files
```

Add plugin to your `vite.config.ts`:

```typescript
import { defineConfig } from 'vite'
import path from 'path'
// Import plugin
import { rootRedirect } from '@netglade/vite-plugin-root-redirect'

export default defineConfig({
  build: {
    rollupOptions: {
      input: {
        dashboard: path.resolve(__dirname, 'src/views/Dashboard/index.html'),
      }
    }
  },
  
  plugins: [
    // Use plugin
    rootRedirect({
      url: 'http://localhost:5173/src/views/Dashboard/index.html'
    }),
  ],
})
```
## rootRedirect API

**rootRedirect(options)**

Plugin options:

```typescript
{
  // `url` - the URL that Vite's root will redirect to
  url: string
}
```

## Motivation

This plugin is useful for projects with nested or multiple index.html entry points. It only helps during development while using the `vite` command.

[Vite supports multiple entry-points.](https://vitejs.dev/guide/build.html#multi-page-app) The starting URL can be somewhat modified, but it is defined in multiple places:

- You can [open the app automatically in the browser on launch.](https://vitejs.dev/config/server-options.html#server-open) This URL can be modified.

- When Vite starts, it prints a message into the terminal with the starting URL. This URL cannot be changed.

```shell
VITE v4.4.9  ready in 767 ms

➜  Local:   http://localhost:5173/
```

- You could have a back-end setup to proxy to the Vite server during development, where the starting URL might also have to be specified.
- The [Vite extension for VS Code](https://marketplace.visualstudio.com/items?itemName=antfu.vite) has its custom extension config for which URL it will start.

Some developers don't like to auto-open the browser when running Vite and want to open the app manually, this way their browser doesn't have to remember a URL specific to their project. This also helps when working with multiple projects.

## Possible improvements

- Only require relative path in URL and read the server host name and port dynamically from Vite config, e.g. `/src/views/Dashboard/index.html`. This would add support for when the port is already in use and the next one is taken instead.

## License

[MIT](LICENSE)