open-index/open-npm huggingface dataset:
npm package: @remote-object/core
Description: [![MIT License](https://img.shields.io/badge/license-MIT-999999?style=flat-square)](./LICENSE) [![Discord](https://img.shields.io/badge/chat-discord-5662f6?style=flat-square)](https://discord.gg/vanVrDwSkS)
Author: vilicvane
Latest version: 0.0.1-alpha.1

[![MIT License](https://img.shields.io/badge/license-MIT-999999?style=flat-square)](./LICENSE)
[![Discord](https://img.shields.io/badge/chat-discord-5662f6?style=flat-square)](https://discord.gg/vanVrDwSkS)

# @remote-object/core

Just another awesome magic.

## License

MIT License.
npm package: @remote-ui/htm
Description: This library provides a binding that converts [`htm`](https://github.com/developit/htm) templates into operations on a [`@remote-ui/core` `ReactRoot`](../core#remoteroot).
Latest version: 2.3.5

# `@remote-ui/htm`

This library provides a binding that converts [`htm`](https://github.com/developit/htm) templates into operations on a [`@remote-ui/core` `ReactRoot`](../core#remoteroot).

## Installation

Using `yarn`:

```
yarn add @remote-ui/htm
```

or, using `npm`:

```
npm install @remote-ui/htm --save
```

## Usage

`@remote-ui/htm` provides two functions. The first, `createHtm`, is a factory function that takes a [`@remote-ui/core` `RemoteRoot`](../core#remoteroot), and returns a [tagged template](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals#Tagged_templates). This tagged template binds the main function from the `htm` library into creating a tree of `@remote-ui/core` `RemoteComponent` and `RemoteText` objects. The second function, `append`, is a helper to call `appendChild()` on a `RemoteRoot` or `RemoteComponent` for each node in the tree returned by the tagged template.

```ts
import {createRemoteRoot} from '@remote-ui/core';
import {createHtm, append} from '@remote-ui/htm';

const root = createRemoteRoot(() => {});
const htm = createHtm(root);

const onPress = () => {};

append(htm`<Button primary onPress=${onPress}>Submit</Button>`, root);
```

This library only helps you create the initial structure of remote components. Any subsequent updates to that structure (for example, responding to a button press by changing its content) would be performed with the [`RemoteRoot` and `RemoteComponent` APIs](../core).

`htm` supports [many handy syntax features](https://github.com/developit/htm#syntax-like-jsx-but-also-lit). Notably, if you have external definitions of the remote components available in your system, you can interpolate them as the type name within your markup.

```tsx
import {createRemoteRoot} from '@remote-ui/core';
import {createHtm, append} from '@remote-ui/htm';
import {BlockStack, Button, Text} from 'my-remote-components';

const root = createRemoteRoot(() => {});
const htm = createHtm(root);
const stack = root.createComponent(BlockStack);

append(
  htm`
    <${Button} onPress=${() => console.log('Pressed!')}>Submit<//>
    <${Text} subdued>You’ll have a chance to review your purchase<//>
  `,
  stack,
);
```
npm package: @remote-ui/mini-react
Description: This package has been deprecated. We suggest using the `@remote-ui/react` package instead, and are working on a DOM adaptor for remote-ui that will allow you to use smaller alternatives to React (like [Preact](https://preactjs.com/)) instead.
Latest version: 2.0.0
Deprecated: This package is deprecated. Use @remote-ui/react instead.

# `@remote-ui/mini-react`

This package has been deprecated. We suggest using the `@remote-ui/react` package instead, and are working on a DOM adaptor for remote-ui that will allow you to use smaller alternatives to React (like [Preact](https://preactjs.com/)) instead.
npm package: @remote-ui/traversal
Description: This package provides a set of utility functions for finding components within a [`@remote-ui/core` `RemoteRoot`](../core#remoteroot).
Latest version: 1.4.5

# `@remote-ui/traversal`

This package provides a set of utility functions for finding components within a [`@remote-ui/core` `RemoteRoot`](../core#remoteroot).

## Installation

Using `yarn`:

```
yarn add @remote-ui/traversal
```

or, using `npm`:

```
npm install @remote-ui/traversal --save
```

## Usage

### `find()`

Returns the nearest descendant [`RemoteComponent`](../core#remotecomponent) whose type matches the passed type.

```ts
import {createRemoteRoot} from '@remote-ui/core';
import {find} from '@remote-ui/traversal';

const root = createRemoteRoot(() => {});
const buttonGroup = root.createComponent('ButtonGroup');

buttonGroup.append(root.createComponent('Button'));
root.append(buttonGroup);

const button = find(root, 'Button');
```

You can optionally pass a `props` argument as the third parameter. This will find a matching component with a matching subset of props.

```ts
import {createRemoteRoot} from '@remote-ui/core';
import {find} from '@remote-ui/traversal';

const root = createRemoteRoot(() => {});
const buttonGroup = root.createComponent('ButtonGroup');
const buttonOne = root.createComponent('Button', {id: 'one'});

buttonGroup.append(buttonOne);
buttonGroup.append(root.createComponent('Button', {id: 'two'}));
root.append(buttonGroup);

const buttonTwo = find(root, 'Button', {id: 'two'});
```

### `findAll()`

Like `find()`, but returns all matching components in an array.

### `closest()`

Returns the component passed as the first argument, if it matches the type (and optional props) passed to this function, or returns the first matching ancestor that does match by traversing recursively through all parents.

```ts
import {createRemoteRoot} from '@remote-ui/core';
import {closest} from '@remote-ui/traversal';

const root = createRemoteRoot(() => {});
const buttonGroup = root.createComponent('ButtonGroup');
const button = root.createComponent('Button');

buttonGroup.append(button);
root.append(buttonGroup);

const foundButtonGroup = closest(button, 'ButtonGroup'); // same as buttonGroup
```
npm package: @remote-ui/types
Description: This library provides a couple of utility types used in other remote-ui libraries. All of these types are re-exported from [`@remote-ui/core`](../core).
Latest version: 1.1.3

# `@remote-ui/types`

This library provides a couple of utility types used in other remote-ui libraries. All of these types are re-exported from [`@remote-ui/core`](../core).

## Types

### `RemoteComponentType<Type, Props, AllowedChildren>`

A “type” in remote-ui is represented with a humble string. You pass a string to [`RemoteRoot#createComponent](../core#remoterootcreatecomponent) in order to create a new component instance, and a string identifier for the component is the only required argument. However, many of the remote-ui libraries have support for a more strongly-typed version of that string, which is the purpose of `RemoteComponentType`. This type is still “just a string”, but includes additional type parameters for the type of the properties allowed for that component, and for the types of components this component accepts as children. The [`RemoteComponent` APIs](../core#remotecomponent), as well as a number of others, use these types to offer you editor autocompletion on property names, and other helpful type checking.

The `AllowedChildren` argument does not perform any runtime validation, it only provides compile-time checking to ensure value children are appended to a component. If your component accepts any child, including being able to accept text nodes as children, you can pass `true` for this type parameter (or leave it unset, as the default is `true`).

### `IdentifierForRemoteComponent<Type>`

If the `Type` parameter is a `RemoteComponentType`, this will extract the exact string type that is that component’s unique name.

```ts
type Button = RemoteComponent<'Button', {onPress(): void}>;
type ButtonType = IdentifierForRemoteComponent<Button>; // 'Button'
```

### `PropsForRemoteComponent<Type>`

If the `Type` parameter is a `RemoteComponentType`, this will extract the props type for that component

```ts
type Button = RemoteComponent<'Button', {onPress(): void}>;
type ButtonType = PropsForRemoteComponent<Button>; // {onPress(): void}
```
npm package: @remote-ui/web-workers
Description: This package has been deprecated. If you are looking for an ergonomic way to create web workers in a project using [`@remote-ui/rpc`](../rpc), Webpack, and Babel, we recommend you use [`@shopify/web-worker`](https://github.com/Shopify/quilt/tree/main/pack
Latest version: 2.0.0
Deprecated: This package has been deprecated. If you are looking for an ergonomic way to create web workers in a project using `@remote-ui/rpc`, Webpack, and Babel, we recommend you use [`@shopify/web-worker`](https://github.com/Shopify/quilt/tree/main/packages/web-worker), which has the same API as version `1.3.0` of this library.

# `@remote-ui/web-workers`

This package has been deprecated. If you are looking for an ergonomic way to create web workers in a project using [`@remote-ui/rpc`](../rpc), Webpack, and Babel, we recommend you use [`@shopify/web-worker`](https://github.com/Shopify/quilt/tree/main/packages/web-worker), which has the same API as version `1.3.0` of this library.
npm package: @remote.it/client
Description: remote.it JavaScript/node client library
Latest version: 0.1.4
Deprecated: Please use remote.it package on npm

# remote.it client

> JavaScript/node remote.it client library

## Install

```bash
npm install --save @remote.it/client
```

## Usage

...coming soon...

## Development

```bash
nvm install
nvm use
npm install
npm test
npm start
```
npm package: @remote.it/components
Description: A collection of remote.it React components
Latest version: 1.1.47

# @remote.it/components

## Install

```shell
npm i @remote.it/components
```

## Usage

```tsx
import { Button } from '@remote.it/components'

function MyComponent(): JSX.Element {
  return (
    <div>
      <Button>Click me!</Button>
    </div>
  )
}
```

## Development

Setup the project:

```shell
# Use the right version of node
nvm use

# Install dependencies
npm i
```

You need to add the fontawesome token to your config:
npm config set '//npm.fontawesome.com/:\_authToken' "<token>"

Useful commands:

- Link Desktop: `npm run link-desktop` to run the necessary commands to sym-link the components into the desktop app for rapid development. Then npm link back to this component from desktop `npm link ../../remote.it.js/packages/remoteit-components/`
- Test: `npm run verify` or watch with `npm run test-watch`
- Build: `npm run compile` (from the project root)
- Run Storybook: `npm run storybook`
- Version: `npm run version`
- Publish: `npm run release`
- Publish alpha: `npm run alpha-release`
- You must be a member of the `@remote.it` npm organization, have Two-Factor auth setup and have been granted access to this project before you can publish.

## License

MIT

## Contributing

PRs welcome! Please write tests, update docs and run ESLint on your changes (see `package.json` for scripts to help).
npm package: @remote.it/core
Description: Core remote.it JavasScript/TypeScript library
Author: Dana Woodman
Latest version: 0.43.7

# @remote.it/core

> Core remote.it Typescript library and companion cross-platform command line interface (CLI)

---

## 📖 Overview

The remote.it CLI (and associated JavaScript/TypeScript library) provide a simple and intuitive way to manage your remote.it devices (targets), services and connections (initiators). This library is used in our cross-platform Desktop and Mobile applications as well.

---

## ⚙️ Config file

The core of the remote.it CLI is the `config.json` file. This file stores all information about the current system's target, services and initiators.

If the config file changes for any reason (the CLI changes it, you change it manually, etc), the system service running for remote.it will compare the change with the currently running target/services/initiators and manage them accordingly. That means if a new service is added to the config, it will automatically be run as a system service by the watcher. If one is stopped or removed, it will also be changed automatically.

Generally speaking, you should not touch the config file directly unless you are doing bulk deployments/scripting with the file. Otherwise, just use the CLI or Desktop application to manage your configuration.

The default path for the config file for each operating system is:

- Windows: `C:\remoteit\config.json`
- Mac: `~/.remoteit/config.json`
- Linux: `~/.remoteit/config.json`

Here is what a sample config file looks like:

```json
{
  "target": {
    "hostname": "127.0.0.1",
    "multiport": true,
    "port": 65535,
    "name": "My Laptop",
    "secret": "...",
    "uid": "80:00:00:00:00:00:00:00",
    "services": [
      {
        "port": 3000,
        "name": "My Laptop - HTTP",
        "secret": "...",
        "type": "http",
        "uid": "80:00:00:00:00:00:00:01"
      }
    ]
  },
  "initiators": [
    {
      "autoStart": true,
      "uid": "80:00:00:00:00:00:00:02",
      "port": 33000,
      "hostname": "127.0.0.1",
      "name": "My AWS Server",
      "type": 40
    }
  ],
  "user": {
    "username": "user@example.com",
    "authHash": "..."
  }
}
```

---

---

## 💻 API Usage

### Setup

```shell
npm install --save @remote.it/core
```

### Usage

```ts
import { API, Device, ServiceTypes } from '@remote.it/core'

// Set your authentication token for API requests
API.token = token

// Register a device
const device = await Device.register('My Device Name')
console.log('UID:', device.uid)
console.log('secret:', device.secret)

// Add a service:
await device.addService(ServiceTypes.http, 3000)
```

## Development

### ‍️Building executables

To generate Windows, Mac and Linux executables, run:

```shell
npm run package
```

The entry point for the executables is `bin/remoteit` which can also be run by typing:

```shell
npm run build
./bin/remoteit -h
```
npm package: @remote.it/services
Description: ## Install
Author: Dana Woodman
Latest version: 0.9.16

# @remote.it/services

## Install

```shell
npm i @remote.it/services
```

## Usage

```ts
import { CognitoService } from '@remote.it/services'
import 'isomorphic-fetch' // needed if using in node and not browser

// Optional config:
const config = {
  /* ...see type definition for options... */
}

const cognito = new CognitoService(config)

async function signInUser() {
  const username = 'someuser@company.com'
  const password = 'sup3rsekret!'
  const [challenge, user] = await cognito.signIn(username, password)
  console.log('challenge:', challenge)
  console.log('user:', user)
}

signInUser()
```
npm package: @remotecash/remotecash
Description: Javascript sdk for RemoteCash APIs
Author: remotecash
Latest version: 1.0.0

# RemoteCash Javascript SDK

### About

This is the Javascript SDK for the RemoteCash API.

## Installation

via NPM:

`npm install @remotecash/remotecash`

via CDN:

`https://cdn.jsdelivr.net/npm/@remotecash/remotecash@{version_number}/build/remotecash.min.js`

or use the minified file in the `build` folder

## Getting started

### Client Side 

Initialize the SDK with: 

`window.remotecash = new RemoteCash(config);` 

or 

`const remotecash = new RemoteCash(config);`(NodeJS)

Your `config` object should contain:

* `storageMethod` - Options are `session` for `sessionStorage` and `local` for `localStorage`

* `apiVersion` - Default is `3` (Version 3 is the only currently supported version)

* `apiToken` - Your RemoteCash API token

Example:

```
	var config = {
		apiVersion: 3, 
		storageMethod: "local",
		apiToken: "authenticationTokenHere"
	}

```

### Server Side (NodeJS)

Initialize the sdk with: 
`const remotecash = new RemoteCash(config);`

Your `config` object should contain:

* `apiVersion` - Default is `3` (Version 3 is the only currently supported version)

* `apiToken` - Your RemoteCash API token

Example:

```
	var config = {
		apiVersion: 3, 
		apiToken: "authenticationTokenHere"
	}

```

### Custom API url

To use this SDK with a custom API url, your `config` object should contain `customAPIURL`

Example:

```
	var config = {
		...,
		customAPIURL: "https://whatever.stuff/
	}

```



### Documentation and usage

For more detailed documentation and usage [Docs](https://docs.remotecash.com/).

License
-------------
<a href=/LICENSE target="_blank">MIT</a> license.
npm package: @remotefull/commander
Description: Executing commands on remote servers made easy.
Latest version: 1.0.2

<center>
<h2>remotefull/commander</h2>
Executing commands on remote servers made easy.
</center>

<hr>

## Getting started

There is 1 available command remote right now:

- SshCmdRemote

All command remotes extend BaseCmdRemote. Feel free to implement your own.

## Usage

1. Install the `@remotefull/commander` package using Yarn or NPM
2. Import your desired command remote:

```ts
// Require
const { SshCmdRemote } = require("@remotefull/commander");

// ES6
import { SshCmdRemote } from "@remotefull/commander";
```

3. Use the command remote:

```ts
const config = {
  host: "",
  port: 22,
  username: "",
  password: "",
};

const remote = new SshCmdRemote(config);

await remote.connect();

const out = await remote.execute("whoami");
console.log("output", out);

await remote.disconnect();
```

## Example

This package really shines in the abstraction it creates. It provides functions that are the same no matter the remote. This means that you can implement your application logic without caring about the different remotes. For example

```ts
import * as Remotes from "@remotefull/commander";

// The application logic itself doesn't need to worry
// about what remote is used.
class YourApp {
  constructor(private remote: Remotes.BaseCmdRemote) {}

  public async run() {
    const cmd = `${
      (await this.isRoot()) ? "sudo " : ""
    } apt-get install docker-ce -y`;

    await this.client.connect();

    const stream = await this.remote.executeStream(cmd);
    stream.on("data", data => console.log("output:", data));
    stream.on("end", () => this.client.disconnect());
  }

  private async isRoot(): Promise<boolean> {
    return (await this.remote.execute("whoami")) === "root";
  }
}

// This is just a placeholder for credentials config
const config = {
  // ...
};

const remote = new Remotes.SshCmdRemote(config);
const app = new YourApp(remote);
```
npm package: @remotefull/file
Description: File managing on remote servers made easy.
Latest version: 1.0.1

<center>
<h2>remotefull/file</h2>
File managing on remote servers made easy.
</center>

<hr>

## Getting started

There are 2 available file remotes right now:

- FtpFileRemote
- SftpFileRemotes

All file remotes extend BaseFileRemote. Feel free to implement your own.

## Usage

1. Install the `@remotefull/file` package using Yarn or NPM
2. Import your desired file remote:

```ts
// Require
const { FtpFileRemote } = require("@remotefull/file");

// ES6
import { FtpFileRemote } from "@remotefull/file";
```

3. Use the file remote:

```
const config = {
    host: "",
    port: 21,
    username: "",
    password: ""
}

const remote = new FtpFileRemote(config)

await remote.connect();
await remote.createFile("hello", "world");
await remote.disconnect();
```

## Example

This package really shines in the abstraction it creates. It provides functions that are the same no matter the remote. This means that you can implement your application logic without caring about the different remotes. For example

```ts
import * as Remotes from "@remotefull/file";

// The application logic itself doesn't need to worry
// about what remote is used.
class YourApp {
  constructor(private remote: Remotes.BaseFileRemote) {}

  public run() {
    if (!(await remote.exists("hello"))) {
      await remote.createFile("hello", "world");
    }
  }
}

// This is just a placeholder for credentials config
const config = {
  // ...
};

const remote = new Remotes.FtpFileRemote(config);
const app = new YourApp(remote);
```
npm package: @remotego/remotego
Description: Expose any CLI tool as a public web terminal via tunnel
Author: zhanju
Latest version: 1.1.0

# remotego

Expose any CLI tool as a public web terminal via tunnel.

## Install

```bash
npm install -g @remotego/remotego
```

## Usage

```bash
remotego <command> [command-args...] [options]
```

### Options

| Option | Description | Default |
|--------|-------------|---------|
| `--port <port>` | Port to listen on | `7681` |
| `--cwd <dir>` | Working directory for the command | Current directory |
| `--domain <domain>` | Custom domain for localhost.run tunnel | Random subdomain |
| `--help, -h` | Show help | |

### Examples

```bash
# Mirror Claude Code
remotego claude

# Mirror a bash shell
remotego bash

# Mirror Python REPL
remotego python3 -i

# Mirror vim editor
remotego vim

# Custom port
remotego --port 9000 node

# Custom tunnel domain
remotego --domain myterm.localhost.run bash

# Pass flags to the command (use -- to separate)
remotego -- git log --oneline
```

## How It Works

1. Spawns the given command in a PTY (pseudo-terminal)
2. Starts a local HTTP server with a browser-based terminal (xterm.js)
3. Creates a public tunnel via localhost.run for remote access
4. Opens the browser automatically

### Security

- A random session UUID is generated on each start
- The session ID is embedded in the URL — only holders of the URL can connect
- Clients must authenticate within 5 seconds of connecting

## Claude Code Plugin

This project also works as a Claude Code plugin. Install it and use the `/remoting` slash command to mirror your Claude Code session in a browser.

## License

MIT
npm package: @remotemerge/ndc-node-sdk
Description: Modern JavaScript library to convert date from BS to AD and vice-versa.
Author: Madan Sapkota
Latest version: 1.0.3
Deprecated: This package has been deprecated. Please use @remotemerge/nepali-date-converter instead.

# 🔁 Nepali Date Converter (NDC)

[![Package](https://img.shields.io/npm/v/@remotemerge/ndc-node-sdk?logo=npm)](https://www.npmjs.com/package/@remotemerge/ndc-node-sdk)
![Build](https://img.shields.io/github/workflow/status/remotemerge/ndc-node-sdk/Publish?logo=github)
![Downloads](https://img.shields.io/npm/dt/@remotemerge/ndc-node-sdk)
![License](https://img.shields.io/npm/l/@remotemerge/ndc-node-sdk)

Modern JavaScript library to convert date from BS to AD and vice-versa.

## Features

**Date Range** — supports conversion between 1975-2099 BS or 1918-2043 AD.

**Size** — with massive 125 years of data and code, the size is tiny; plain *7.3 KB* and Gzip *2.2 KB*.

**TypeScript Support** — built-in types support, and it's written in TypeScript. The package seamlessly works on
browsers, JS/ESx, Node.js, and bundlers like Webpack, Rollup, etc.

**Conversion** — supports date conversion from BS to AD and vice-versa.

**Accurate** — from 1975-2099 BS, 100% of the data was tested and corrected. The package is ready to be used in
production.

**Fast** — localized data and optimized code; the outcomes are lightning fast!

## Installation

The library is available as a npm package. To install the package, run:

```shell
npm install @remotemerge/ndc-node-sdk
```

or, if you are using a Yarn package manager, run:

```shell
yarn add @remotemerge/ndc-node-sdk
```

## Quick Examples

Import the `DateConverter` module in your JS/TS code.

```javascript
// as ES module
import DateConverter from '@remotemerge/ndc-node-sdk';
```

*OR*

```javascript
const DateConverter = require('@remotemerge/ndc-node-sdk');
```

### Convert from BS to AD

Add BS date in `YYYY-MM-DD` format to convert from BS to AD.

```javascript
const converted = new DateConverter('2017-10-17').toAd();
console.log(converted);
```

outputs

```log
{ year: 1961, month: 1, date: 30, day: 'Monday' }
```

### Convert from AD to BS

Add AD date in `YYYY-MM-DD` format to convert from AD to BS.

```javascript
const converted = new DateConverter('2001-06-01').toBs();
console.log(converted);
```

outputs

```log
{ year: 2058, month: 2, date: 19, day: 'Friday' }
```

### Using CDN

You can also use the library directly in HTML from
the [jsDelivr CDN](https://www.jsdelivr.com/package/npm/@remotemerge/ndc-node-sdk).

```html

<script src='https://cdn.jsdelivr.net/npm/@remotemerge/ndc-node-sdk@1/ndc-iife.js'></script>
<script>
  const converted = new DateConverter('2044-01-08').toAd();
  console.log(converted);
</script>
```
npm package: @remotemonster/sdk
Description: RemoteMonster Web SDK
Author: RemoteMonster
Latest version: 2.7.3

[![npm](https://img.shields.io/npm/v/@remotemonster/sdk.svg)](https://www.npmjs.com/package/@remotemonster/sdk)

# RemoteMonster web SDK

RemoteMonster - Livecast Management in the Cloud

- [Website](https://remotemonster.com)

## Get SDK

### Package Manager

```bash
npm i @remotemonster/sdk
```

```html
<script src="node_modules/@remotemonster/sdk/remon.min.js"></script>
```

### Static import

From [jsDelivr](https://www.jsdelivr.com)

```html
<!-- Latest -->
<script src="https://cdn.jsdelivr.net/npm/@remotemonster/sdk/remon.min.js"></script>

<!-- Specific version -->
<script src="https://cdn.jsdelivr.net/npm/@remotemonster/sdk@2.0.8/remon.min.js"></script>
```

### Downloads

- [Downloads](https://github.com/RemoteMonster/web-sdk/releases/)

## Examples

### Studio

- [demo](https://studio.remotemonster.com/)
- [source](https://github.com/RemoteMonster/remon-studio)

### Full features - Livecast

- [demo](https://remotemonster.github.io/web-sdk/examples/full-livecast/)
- [source](https://github.com/RemoteMonster/web-sdk/tree/master/examples/full-livecast/)

### Full features - Communication

- [demo](https://remotemonster.github.io/web-sdk/examples/full-communication/)
- [source](https://github.com/RemoteMonster/web-sdk/tree/master/examples/full-communication/)

### Simple - Livecast

- [cast - demo](https://remotemonster.github.io/web-sdk/examples/simple-livecast-cast/)
- [cast - source](https://github.com/RemoteMonster/web-sdk/tree/master/examples/simple-livecast-cast/)
- [watch - demo](https://remotemonster.github.io/web-sdk/examples/simple-livecast-watch/)
- [watch - source](https://github.com/RemoteMonster/web-sdk/tree/master/examples/simple-livecast-watch/)

### Simple - Communication

- [demo](https://remotemonster.github.io/web-sdk/examples/simple-communication/)
- [source](https://github.com/RemoteMonster/web-sdk/tree/master/examples/simple-communication/)

## Documents

- [Guides](https://docs.remotemonster.com/)
- [API Reference](https://remotemonster.github.io/web-sdk/docs/)

## Changelog

- [Changelog](https://github.com/RemoteMonster/web-sdk/blob/master/CHANGELOG.md)
npm package: @remotemonster/show
Description: live streaming web stduio for RemoteMonster developers
Author: RemoteMonster
Latest version: 1.0.9

# RemonShow - Simple HTML5 Video Studio


> RemonShow is a web video studio built from the ground up for an HTML5 world. It support HTML5 and RemoteMonster SDK. It supports input devices control and many constraints on desktops and mobile devices. With RemonShow, You can make a live streaming service with *WebRTC* very easy.
![screen shot](screen.png)

## Table of Contents
* [Quick Start](#quick-start)
* [Parameters](#parameters)
* [License](#license)

## Quick Start
Add these tags to your document's `<head>`:

```html
<script src="https://cdn.jsdelivr.net/npm/@remotemonster/show/remonshow-mini.min.js"></script>
```
> For the latest version of RemonShow and URLs to use, check out the document page on our website.

Next, using RemonShow is as simple as creating a `<video>` element, but with an additional 'data-setup' attribute. At a minimum, this attribute must have a value of `'{serviceId, key}'`.

```html
<!-- remon-cast for live streaming cast -->
<remon-cast key="1234567890" serviceId="SERVICEID1" 
  listener="myListener" poster="img/poster.jpg">
</remon-cast>
<!-- remon-call for P2P call -->
<remon-call key="1234567890" serviceId="SERVICEID1" 
  listener="myListener" poster="img/poster.jpg">
</remon-call>
```

When the page loads, RemonShow will find this element and automatically setup a studio in its place.
You can set up additional parameters:
 * listener: You can register a function that can receive various events that occur in Remonshow.
 * poster: You can select the image you see on the screen when it is launched for the first time.
 * channelId: If there is no setting, the id of the channel will be made random. If you want to specify the id of the broadcast in advance, set the channelId.

## License

RemonShow is licensed under the MIT.
npm package: @remoteoss/ai-agent-toolkit
Description: Toolkit for integrating the Remote API into agentic workflows
Author: Remote.com
Latest version: 0.1.5

# Remote API Agent Toolkit for TypeScript

This package contains the TypeScript implementation of the Remote AI Agent Toolkit. It provides tools for integrating with the Remote API in agentic workflows.

## Installation

```bash
npm install @remoteoss/ai-agent-toolkit
```

## Requirements

- Node.js 18+
- A Remote API Key

## Usage

The library needs to be configured with your Remote API key.

### LangChain Toolkit

To use the toolkit with LangChain, you can instantiate `RemoteApiAgentToolkit` and pass the tools to your agent.

```typescript
import { RemoteApiAgentToolkit } from '@remoteoss/ai-agent-toolkit/langchain';
import { ChatOpenAI } from '@langchain/openai';
import { AgentExecutor, createStructuredChatAgent } from 'langchain/agents';
import { hub } from 'langchain/hub';

// Initialize the toolkit
const toolkit = new RemoteApiAgentToolkit({
  apiKey: process.env.REMOTE_API_KEY!,
});

const tools = toolkit.getTools();

// Initialize the LLM and agent
// This example uses OpenAI, but it's compatible with other models
const llm = new ChatOpenAI({ modelName: 'gpt-4o', temperature: 0 });
const prompt = await hub.pull<any>('hwchase17/structured-chat-agent');

const agent = await createStructuredChatAgent({
  llm,
  tools,
  prompt,
});

const agentExecutor = new AgentExecutor({
  agent,
  tools,
});

const result = await agentExecutor.invoke({
  input: 'Can you list the current employments?',
});

console.log(result);
```

### Tool Configuration

You can configure the tools available to the agent by passing the `allowedTools` array in the toolkit's constructor.

```typescript
const toolkit = new RemoteApiAgentToolkit({
  apiKey: process.env.REMOTE_API_KEY!,
  allowedTools: ['list_employments', 'create_time_off'],
});
```

### Model Context Protocol (MCP) Server

If you have cloned the repository, you can run the MCP server directly.

First, install the dependencies:

```bash
cd mcp
npm install
```

Then, run the server:

```bash
npm run start -- --api-key=YOUR_REMOTE_API_KEY
```

You can also set the `REMOTE_API_KEY` and `ALLOWED_TOOLS` environment variables instead of passing them as arguments.
npm package: @remoteoss/json-schema-form
Description: WIP V2 – Headless UI form powered by JSON Schemas
Author: Remote.com
Latest version: 1.2.11

<p align="center">
<img src=".github/media/jsf_logo_dark.png"  width="600" alt="json-schema-form">
</p>

<p align="center">
  <code>json-schema-form</code> is a headless UI form library powered by <a href="https://json-schema.org/">JSON Schemas</a>. 
<br/>
  It transforms JSON schemas into Javascript `fields` to be more easily consumed by your UI libraries.
</p>

---

### Why JSON Schemas for forms?

JSON Schemas are the SSoT (Single Source of Truth) that allows you to share form's data _structure_ and _validations_ between the server (backend) and the client (frontend), regardless of the language used.

You can use it beyond UI Forms, like lists, tables, and any other UI that needs structured JSON data.

## Installation

Available on [NPM](https://www.npmjs.com/package/@remoteoss/json-schema-form).

```bash
npm install @remoteoss/json-schema-form
# or

yarn install @remoteoss/json-schema-form
```

## Getting Started

Check the 📚 **[JSF website](https://json-schema-form.vercel.app/)** for documentation.

### Playground

Check the 🕹️ **[JSF Playground](https://json-schema-form.vercel.app/?path=/docs/playground--docs)** for demos.

## Contributing

Read [CONTRIBUTING](CONTRIBUTING.md) to get started.

## Migrating

If you're using `v0` and wish to migrate to `v1`, read [MIGRATING](MIGRATING.md) to get started.

_Backed by [Remote.com](https://remote.com/)_
npm package: @remotestorage/module-places
Description: Manage favorite/saved places
Author: Râu Cao
Latest version: 1.2.2

# @remotestorage/module-places

[![npm version](https://img.shields.io/npm/v/@remotestorage/module-places.svg)](https://www.npmjs.com/package/@remotestorage/module-places) [![Build Status](https://gitea.kosmos.org/raucao/remotestorage-module-places/actions/workflows/test.yaml/badge.svg)](https://gitea.kosmos.org/raucao/remotestorage-module-places/actions)

This module allows you to manage saved places (Points of Interest) using the [remoteStorage](https://remotestorage.io/) protocol.

It leverages [Geohashes](https://www.geohash.es/) to organize data, enabling efficient retrieval of places within specific geographic areas. This structure is particularly optimized for map applications that need to load data only for the visible viewport.

For a demo application, as well as source code using this module, check out [Marco](https://marco.kosmos.org).

## Installation

```bash
# npm
npm install @remotestorage/module-places

# pnpm
pnpm add @remotestorage/module-places

# yarn
yarn add @remotestorage/module-places

# bun
bun add @remotestorage/module-places
```

## Usage

```javascript
import RemoteStorage from 'remotestoragejs';
import PlacesModule from '@remotestorage/module-places';

const remoteStorage = new RemoteStorage({
  modules: [PlacesModule],
});

// Access the module
const places = remoteStorage.places;

// Store a place
await places.store({
  title: 'My Favorite Coffee Shop',
  lat: 52.520008,
  lon: 13.404954,
});

// List all places
const allPlaces = await places.getPlaces();
console.log(allPlaces);

// List places for specific geohash prefixes (e.g. for a map view)
const areaPlaces = await places.getPlaces(['u33d', 'u33e']);
console.log(areaPlaces);
```

## Lists

### Default lists

There are currently two default lists, which you can initiate like this:

```javascript
await places.lists.initDefaults();
```

This will create the lists if they don't exist yet (meaning the user hasn't yet
used an app that integrates this module).

The default lists are:

| Path | Default Name | Default Color |
| --- | --- | --- |
| `_lists/to-go` | Want to go | #2e9e4f (green) |
| `_lists/to-do` | To do | #2a7fff (blue) |

### Custom lists

```javascript
// Create a list
await places.lists.create('hiking', 'Hiking', '#74d3ba');

// Delete a list
await places.lists.delete('hiking');
```

### List membership

```javascript
// Add a place to a list (requires list ID, place ID, and place geohash)
await places.lists.addPlace('to-go', 'place-id-123', 'u33dc0');

// Remove from list
await places.lists.removePlace('to-go', 'place-id-123');
```

### Reading lists

```javascript
// Get all lists
await places.lists.getAll();

// Get specific list
await places.lists.get('to-do');
```

## API Reference

### Interfaces

- [PlacesClient](docs/interfaces/PlacesClient.md)

### Type Aliases

- [Place](docs/type-aliases/Place.md)
- [List](docs/type-aliases/List.md)
npm package: @remoteteam_dev/micro.css
Description: Pure CSS First, Tiny Sized, Dead Simple CSS Framework Less Than 20kb
Author: RemoteTeam
Latest version: 0.0.4

<div align="center">
<img src="https://i.ibb.co/H7SnbNm/Group-2.png">
</div>

<h1 align="center">Micro CSS</h1>

<p align="center">Pure CSS First, Tiny Sized, Dead Simple CSS Framework Only 3kb Gzipped!</p>


## Download

**Install with npm**

```sh
$ npm install @remoteteam_dev/micro.css
```

**Install with Yarn**

```sh
$ yarn add @remoteteam_dev/micro.css
```

## TODO
- [x] Grid System
- [x] Typography
- [x] Modal
- [x] Forms
- [x] Documentation
- [x] Deploy NPM & Yarn

### What's next ?
- [ ] Responsive Menu
- [ ] Cards


## License

This project is released under the [MIT License](LICENSE).
npm package: @remotezygote/albatross
Description: Migrator
Author: John Bragg
Latest version: 2.0.7

# Albatross

The constant migrator.

All SQL!

Have a migrations table. when new migrations are found, simply insert them into the database, with the contents of the migration up/down in text fields. Have a trigger run when new rows are inserted to migrate appropriately. Allow foa lock of migration version via some other table/field, with an update trigger to migrate as needed.

Keep a log of all actions, period, even when rolling up/down, and log the output and any errors.

Push to pubsub queues for output, status, etc. for interface(s). Expose via web sockets for API.

### IDEA

albatross_versions table, same signature, same everything but migrates first with 'Upgrading...' message/log event.
npm package: @remotezygote/database
Description: Database connector for PG
Author: John Bragg
Latest version: 1.2.19

# Database

```js
import { query, withDatabaseClient, listen } from '@remotezygote/database'

const getUserData = async email => {
  const { rows } = await query('SELECT * FROM users WHERE email = $1', [email])
  return rows && row[0]
}

const multipleQueriesWithClient = async updates => {
  const { email, data } = updates
  return await withDatabaseClient(async client => {
    const { rows } = await client.query(
      'SELECT * FROM users WHERE email = $1',
      [email]
    )
    await client.query('INSERT INTO user_log (email, item) VALUES ($1, $2)', [
      email,
      'updated'
    ])
  })
}

const queryWithTransaction = async updates => {
  const { email, data } = updates
  const { commit } = await withTransaction(
    async client => {
      const { rows } = await client.query(
        'SELECT * FROM users WHERE email = $1',
        [email]
      )
      await client.query('INSERT INTO user_log (email, item) VALUES ($1, $2)', [
        email,
        'updated'
      ])
    },
    { autoCommit: false }
  )
  return await commit()
}

const queryWithAutoCommit = async updates => {
  const { email, data } = updates
  return await withTransaction(async client => {
    const { rows } = await client.query(
      'SELECT * FROM users WHERE email = $1',
      [email]
    )
    await client.query('INSERT INTO user_log (email, item) VALUES ($1, $2)', [
      email,
      'updated'
    ])
  })
}

const queryWithRollback = async updates => {
  const { email, data } = updates
  const { rollback } = await withTransaction(
    async client => {
      const { rows } = await client.query(
        'SELECT * FROM users WHERE email = $1',
        [email]
      )
      await client.query('INSERT INTO user_log (email, item) VALUES ($1, $2)', [
        email,
        'updated'
      ])
    },
    { autoCommit: false }
  )
  return await rollback()
}

const queryWithAutoRollback = async updates => {
  const { email, data } = updates
  return await withTransaction(
    async client => {
      const { rows } = await client.query(
        'SELECT * FROM users WHERE email = $1',
        [email]
      )
      await client.query('INSERT INTO user_log (email, item) VALUES ($1, $2)', [
        email,
        'updated'
      ])
    },
    { autoRollback: true }
  )
}

const processJob = async job => {
  const queue = queues[job.queue]

  if (queue) {
    await queue.add(job.name, job.data)
  }
}

export const listenForJobs = async () => {
  await listen('jobs', processJob)
}
```

## Configuration

The only configuration needed is the connection information to Postgres, via environment variable.

### Environment variables

`DATABASE_URL` - This library uses only the connection URL method for connection configuration. [More info](https://node-postgres.com/features/connecting#connection-uri)
npm package: @remotezygote/koa-api-app
Description: Koa Base App for APIs
Author: John Bragg
Latest version: 1.0.42

# Koa API App

Use this as the base for your API app. It's very simple:

```javascript
import app, {
  exposed,
  body,
  paginate,
  filter,
  get,
  post,
  put,
  del,
  start,
} from "@remotezygote/koa-api-app"
import { ParameterizedContext } from "koa"

const getEnvironment = async (ctx: ParameterizedContext) => {}

const getCurrentUser = async (ctx: ParameterizedContext) => {
  const { user } = ctx.state

  ctx.body = user
  ctx.status = 200
}

exposed.get("/env", getEnvironment) // listen at /env with no authentication needed
get("/me", getCurrentUser) // listen at /me with authenication needed
put("/me", body(), updateUser) // update current user with authentication needed (also read the body)
put("/users", paginate(), getUsers) // get users with pagination (ctx.state.paginate)
put("/users", filter(), getUsers) // get users with filters (ctx.state.filters)
put("/me", body(), paginate(), filter(), getCertainUsers) // read the body, paginate, and parse filters

start()
```

## Websockets

```javascript
import app, {
  start,
} from "@remotezygote/koa-api-app"
import { ParameterizedContext } from "koa"

const getWithWebsocket = async (ctx: ParameterizedContext) => {
  if (ctx.ws) {
    const ws = await ctx.ws()
    ws.send('this is a websocket')
  }

  ctx.status = 200
  ctx.body = 'this is not a websocket'
}

get("/resource", getWithWebsocket) // listen at /me with authenication needed

start()
```
npm package: @remova/ai-cost-tracker
Description: A simple script to count tokens and track your API costs before you send prompts to AI.
Author: Remova
Latest version: 1.0.0

# AI Cost Tracker

A simple script that prevents surprise AI bills. It counts the words (tokens) in your prompts and calculates exactly how much money it will cost you in real-time.

## Why use this?
When you are building with OpenAI, Anthropic, or other LLMs, costs can spiral out of control if you leave a script running. This tool gives you instant visibility into your API spending.

## How to use
1. Install from npm (global CLI):
   ```bash
   npm install -g ai-cost-tracker
   ```
2. Run the tracker:
   ```bash
   ai-cost-tracker
   ```
3. Or run without installing:
   ```bash
   npx ai-cost-tracker
   ```
4. Python version is still available:
   ```bash
   python3 ai_cost_tracker.py
   ```
5. Type any prompt text and press Enter to see:
   - Estimated tokens
   - Estimated prompt cost
   - Running session total
6. Optional commands inside the tool:
   - `/models` to list available models
   - `/model <name>` to switch model
   - `/total` to show current session total
   - `/quit` to exit

---

**Need Enterprise AI Control, Integration, or Growth Support?**

- **Enterprise AI Security:** This tracker is for basic estimating. For hard budget limits, user-level quotas, and full enterprise AI safety, visit [www.remova.org](https://www.remova.org).
- **AI Integration:** Need help integrating AI into your systems? Check out [www.goexpandia.com](https://www.goexpandia.com) for managed AI services and AI strategies.
npm package: @remova/personal-information-remover
Description: Lightweight text masking tool for emails, phone numbers, and credit cards. Built by Remova.
Author: Remova
Latest version: 1.0.0

# Personal Information Remover

A lightweight script that stops you from accidentally sending private customer data to AI models. 

It scans raw text and automatically masks:
- Email addresses
- Phone numbers
- Credit card numbers
- 30+ additional sensitive patterns (SSN, IBAN, API keys, tokens, credentials, IDs, and more)

## Why use this?
If you are building with OpenAI, Anthropic, or other LLMs, you need to ensure sensitive data doesn't leave your servers. This tool acts as a simple safety filter between your users and external AI APIs.

## How to use
Install:

```bash
npm install @remova/personal-information-remover
```

Use in code:

```js
const { maskSensitiveInfo } = require("@remova/personal-information-remover");

const input = "Email: john@email.com, Phone: +1 415-555-2671, Card: 4111 1111 1111 1111";
const output = maskSensitiveInfo(input);
console.log(output);
// Email: [EMAIL REMOVED], Phone: [PHONE REMOVED], Card: [CARD REMOVED]
```

Disable extended regex database:

```js
maskSensitiveInfo("SSN 123-45-6789", { extended: false });
```

Use via CLI:

```bash
npx @remova/personal-information-remover --text "Contact john@email.com at +1 415-555-2671"
```

or

```bash
echo "Card 4242 4242 4242 4242" | npx @remova/personal-information-remover
```

Disable extended regex database in CLI:

```bash
npx @remova/personal-information-remover --basic --text "SSN 123-45-6789"
```

## Publish to npm
1. Update version in `package.json`.
2. Login: `npm login`
3. Publish: `npm publish --access public`

---

**Need Enterprise AI Security?**
This is a basic masking tool. For advanced role-based access control, audit logging, and full enterprise AI compliance, visit [www.remova.org](https://www.remova.org).

Built with support from [GoExpandia](https://www.goexpandia.com) for growth and product scale.