open-index/open-npm huggingface dataset:
npm package: @robinpath/cookie
Description: HTTP cookie parsing, serialization, signing/verification, Set-Cookie handling, and cookie jar management
Latest version: 0.1.1

# @robinpath/cookie

> HTTP cookie parsing, serialization, signing/verification, Set-Cookie handling, and cookie jar management

![Category](https://img.shields.io/badge/category-Web-blue) ![Functions](https://img.shields.io/badge/functions-12-green) ![Auth](https://img.shields.io/badge/auth-none-lightgrey) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `cookie` module lets you:

- Parse Cookie header string
- Serialize Set-Cookie header
- Sign cookie value with HMAC
- Verify and unsign cookie
- Get single cookie from header

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/cookie
```

## Quick Start

No credentials needed — start using it right away:

```robinpath
cookie.serialize "session" "abc123" {"httpOnly": true, "maxAge": 3600}
```

## Available Functions

| Function | Description |
|----------|-------------|
| `cookie.parse` | Parse Cookie header string |
| `cookie.serialize` | Serialize Set-Cookie header |
| `cookie.sign` | Sign cookie value with HMAC |
| `cookie.unsign` | Verify and unsign cookie |
| `cookie.get` | Get single cookie from header |
| `cookie.remove` | Generate removal Set-Cookie |
| `cookie.parseSetCookie` | Parse Set-Cookie header |
| `cookie.isExpired` | Check if cookie is expired |
| `cookie.jar` | Create cookie jar |
| `cookie.toHeader` | Build Cookie header from pairs |
| `cookie.encode` | URL-encode cookie value |
| `cookie.decode` | URL-decode cookie value |

## Examples

### Serialize Set-Cookie header

```robinpath
cookie.serialize "session" "abc123" {"httpOnly": true, "maxAge": 3600}
```

### Sign cookie value with HMAC

```robinpath
cookie.sign "userId=123" "my-secret"
```

### Verify and unsign cookie

```robinpath
cookie.unsign $signed "my-secret"
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/cookie";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  cookie.serialize "session" "abc123" {"httpOnly": true, "maxAge": 3600}
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/json`](../json) — JSON module for complementary functionality

## License

MIT
npm package: @robinpath/cron
Description: Cron expression parsing, validation, scheduling, and human-readable descriptions
Latest version: 0.1.1

# @robinpath/cron

> Cron expression parsing, validation, scheduling, and human-readable descriptions

![Category](https://img.shields.io/badge/category-Infrastructure-blue) ![Functions](https://img.shields.io/badge/functions-8-green) ![Auth](https://img.shields.io/badge/auth-none-lightgrey) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `cron` module lets you:

- Validate a cron expression
- Parse cron expression into expanded fields
- Get next occurrence after a date
- Get next N occurrences
- Get previous occurrence before a date

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/cron
```

## Quick Start

No credentials needed — start using it right away:

```robinpath
cron.parse "0 9 * * 1-5"
```

## Available Functions

| Function | Description |
|----------|-------------|
| `cron.isValid` | Validate a cron expression |
| `cron.parse` | Parse cron expression into expanded fields |
| `cron.next` | Get next occurrence after a date |
| `cron.nextN` | Get next N occurrences |
| `cron.prev` | Get previous occurrence before a date |
| `cron.matches` | Check if a date matches a cron expression |
| `cron.describe` | Human-readable description of a cron expression |
| `cron.between` | Get all occurrences between two dates |

## Examples

### Parse cron expression into expanded fields

```robinpath
cron.parse "0 9 * * 1-5"
```

### Get next occurrence after a date

```robinpath
cron.next "*/5 * * * *"
```

### Get next N occurrences

```robinpath
cron.nextN "0 * * * *" 10
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/cron";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  cron.parse "0 9 * * 1-5"
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/json`](../json) — JSON module for complementary functionality

## License

MIT
npm package: @robinpath/crypto
Description: Hashing, HMAC, and encoding/decoding utilities (MD5, SHA, Base64, Hex, URL)
Latest version: 0.1.1

# @robinpath/crypto

> Hashing, HMAC, and encoding/decoding utilities (MD5, SHA, Base64, Hex, URL)

![Category](https://img.shields.io/badge/category-Utility-blue) ![Functions](https://img.shields.io/badge/functions-11-green) ![Auth](https://img.shields.io/badge/auth-none-lightgrey) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `crypto` module lets you:

- Compute the MD5 hash of a string
- Compute the SHA-1 hash of a string
- Compute the SHA-256 hash of a string
- Compute the SHA-512 hash of a string
- Compute an HMAC digest using the specified algorithm and secret key

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/crypto
```

## Quick Start

No credentials needed — start using it right away:

```robinpath
crypto.sha1 "hello"
```

## Available Functions

| Function | Description |
|----------|-------------|
| `crypto.md5` | Compute the MD5 hash of a string |
| `crypto.sha1` | Compute the SHA-1 hash of a string |
| `crypto.sha256` | Compute the SHA-256 hash of a string |
| `crypto.sha512` | Compute the SHA-512 hash of a string |
| `crypto.hmac` | Compute an HMAC digest using the specified algorithm and secret key |
| `crypto.base64Encode` | Encode a string to Base64 |
| `crypto.base64Decode` | Decode a Base64 string back to plain text |
| `crypto.hexEncode` | Encode a string to its hexadecimal representation |
| `crypto.hexDecode` | Decode a hexadecimal string back to plain text |
| `crypto.urlEncode` | Percent-encode a string for use in a URL |
| `crypto.urlDecode` | Decode a percent-encoded URL string back to plain text |

## Examples

### Compute the SHA-1 hash of a string

```robinpath
crypto.sha1 "hello"
```

### Compute the SHA-256 hash of a string

```robinpath
crypto.sha256 "hello"
```

### Compute the SHA-512 hash of a string

```robinpath
crypto.sha512 "hello"
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/crypto";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  crypto.sha1 "hello"
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/json`](../json) — JSON module for complementary functionality

## License

MIT
npm package: @robinpath/csv
Description: Parse and stringify CSV data
Latest version: 0.1.2

# @robinpath/csv

> Parse and stringify CSV data

![Category](https://img.shields.io/badge/category-Utility-blue) ![Functions](https://img.shields.io/badge/functions-5-green) ![Auth](https://img.shields.io/badge/auth-none-lightgrey) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `csv` module lets you:

- Parse a CSV string into an array of objects (first row = headers)
- Convert an array of objects into a CSV string
- Extract header names from a CSV string
- Extract all values from a specific column
- Parse a CSV string into an array of arrays (raw, no header mapping)

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/csv
```

## Quick Start

No credentials needed — start using it right away:

```robinpath
csv.stringify $data
```

## Available Functions

| Function | Description |
|----------|-------------|
| `csv.parse` | Parse a CSV string into an array of objects (first row = headers) |
| `csv.stringify` | Convert an array of objects into a CSV string |
| `csv.headers` | Extract header names from a CSV string |
| `csv.column` | Extract all values from a specific column |
| `csv.rows` | Parse a CSV string into an array of arrays (raw, no header mapping) |

## Examples

### Convert an array of objects into a CSV string

```robinpath
csv.stringify $data
```

### Extract header names from a CSV string

```robinpath
csv.headers "name,age\nAlice,30"
```

### Extract all values from a specific column

```robinpath
csv.column "name,age\nAlice,30" "name"
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/csv";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  csv.stringify $data
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/json`](../json) — JSON module for complementary functionality

## License

MIT
npm package: @robinpath/currency
Description: Currency module for RobinPath.
Latest version: 0.1.1

# @robinpath/currency

> Currency module for RobinPath.

![Category](https://img.shields.io/badge/category-Utility-blue) ![Functions](https://img.shields.io/badge/functions-10-green) ![Auth](https://img.shields.io/badge/auth-none-lightgrey) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `currency` module lets you:

- getLatestRates
- convert
- convertBatch
- getHistoricalRates
- listCurrencies

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/currency
```

## Quick Start

No credentials needed — start using it right away:

```robinpath
currency.convert
```

## Available Functions

| Function | Description |
|----------|-------------|
| `currency.getLatestRates` | getLatestRates |
| `currency.convert` | convert |
| `currency.convertBatch` | convertBatch |
| `currency.getHistoricalRates` | getHistoricalRates |
| `currency.listCurrencies` | listCurrencies |
| `currency.getRate` | getRate |
| `currency.getSupportedCodes` | getSupportedCodes |
| `currency.getTimeSeriesRates` | getTimeSeriesRates |
| `currency.formatCurrency` | formatCurrency |
| `currency.getPopularRates` | getPopularRates |

## Examples

### convert

```robinpath
currency.convert
```

### convertBatch

```robinpath
currency.convertBatch
```

### getHistoricalRates

```robinpath
currency.getHistoricalRates
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/currency";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  currency.convert
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/json`](../json) — JSON module for complementary functionality

## License

MIT
npm package: @robinpath/date
Description: Parse, format, manipulate, and compare dates and times
Latest version: 0.1.1

# @robinpath/date

> Parse, format, manipulate, and compare dates and times

![Category](https://img.shields.io/badge/category-Utility-blue) ![Functions](https://img.shields.io/badge/functions-15-green) ![Auth](https://img.shields.io/badge/auth-none-lightgrey) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `date` module lets you:

- Parse a date string and return its ISO representation
- Format a date using a pattern string
- Add a duration to a date
- Subtract a duration from a date
- Calculate the difference between two dates in a given unit

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/date
```

## Quick Start

No credentials needed — start using it right away:

```robinpath
date.format $date "YYYY-MM-DD"
```

## Available Functions

| Function | Description |
|----------|-------------|
| `date.parse` | Parse a date string and return its ISO representation |
| `date.format` | Format a date using a pattern string |
| `date.add` | Add a duration to a date |
| `date.subtract` | Subtract a duration from a date |
| `date.diff` | Calculate the difference between two dates in a given unit |
| `date.startOf` | Get the start of a time period for a date |
| `date.endOf` | Get the end of a time period for a date |
| `date.isAfter` | Check if the first date is after the second date |
| `date.isBefore` | Check if the first date is before the second date |
| `date.isBetween` | Check if a date falls between two other dates (exclusive) |
| `date.toISO` | Convert a date to an ISO 8601 string |
| `date.toUnix` | Convert a date to a Unix timestamp (seconds since epoch) |
| `date.fromUnix` | Convert a Unix timestamp (seconds) to an ISO date string |
| `date.dayOfWeek` | Get the day of the week for a date (0 = Sunday, 6 = Saturday) |
| `date.daysInMonth` | Get the number of days in the month of a given date |

## Examples

### Format a date using a pattern string

```robinpath
date.format $date "YYYY-MM-DD"
```

### Add a duration to a date

```robinpath
date.add $date 5 "days"
```

### Subtract a duration from a date

```robinpath
date.subtract $date 3 "months"
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/date";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  date.format $date "YYYY-MM-DD"
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/json`](../json) — JSON module for complementary functionality

## License

MIT
npm package: @robinpath/debug
Description: Debugging utilities: inspect, timing, counters, logging, memory profiling, value comparison, ASCII tables
Latest version: 0.1.1

# @robinpath/debug

> Debugging utilities: inspect, timing, counters, logging, memory profiling, value comparison, ASCII tables

![Category](https://img.shields.io/badge/category-Other-blue) ![Functions](https://img.shields.io/badge/functions-20-green) ![Auth](https://img.shields.io/badge/auth-none-lightgrey) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `debug` module lets you:

- Deep inspect a value
- Get detailed type
- Start a timer
- End timer and get duration
- Pass value through with timing

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/debug
```

## Quick Start

No credentials needed — start using it right away:

```robinpath
debug.typeOf $data
```

## Available Functions

| Function | Description |
|----------|-------------|
| `debug.inspect` | Deep inspect a value |
| `debug.typeOf` | Get detailed type |
| `debug.timeStart` | Start a timer |
| `debug.timeEnd` | End timer and get duration |
| `debug.timeit` | Pass value through with timing |
| `debug.count` | Increment counter |
| `debug.countReset` | Reset counter |
| `debug.countGet` | Get counter value |
| `debug.log` | Add debug log entry |
| `debug.getLogs` | Get debug logs |
| `debug.clearLogs` | Clear debug logs |
| `debug.assert` | Assert condition |
| `debug.trace` | Get stack trace |
| `debug.memory` | Get memory usage |
| `debug.sizeof` | Estimate value memory size |
| `debug.diff` | Compare two values |
| `debug.freeze` | Deep freeze object |
| `debug.clone` | Deep clone value |
| `debug.table` | Format as ASCII table |
| `debug.dump` | Pretty-print value |

## Examples

### Get detailed type

```robinpath
debug.typeOf $data
```

### Start a timer

```robinpath
debug.timeStart "fetch"
```

### End timer and get duration

```robinpath
debug.timeEnd "fetch"
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/debug";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  debug.typeOf $data
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/json`](../json) — JSON module for complementary functionality

## License

MIT
npm package: @robinpath/deepl
Description: DeepL module for RobinPath.
Latest version: 0.1.1

# @robinpath/deepl

> DeepL module for RobinPath.

![Category](https://img.shields.io/badge/category-AI-blue) ![Functions](https://img.shields.io/badge/functions-13-green) ![Auth](https://img.shields.io/badge/auth-API%20Key-orange) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `deepl` module lets you:

- translateText
- translateBatch
- getUsage
- listSourceLanguages
- listTargetLanguages

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/deepl
```

## Quick Start

**1. Set up credentials**

```robinpath
deepl.setCredentials "your-credentials"
```

**2. translateText**

```robinpath
deepl.translateText
```

## Available Functions

| Function | Description |
|----------|-------------|
| `deepl.setCredentials` | Configure deepl credentials. |
| `deepl.translateText` | translateText |
| `deepl.translateBatch` | translateBatch |
| `deepl.getUsage` | getUsage |
| `deepl.listSourceLanguages` | listSourceLanguages |
| `deepl.listTargetLanguages` | listTargetLanguages |
| `deepl.listGlossaryLanguagePairs` | listGlossaryLanguagePairs |
| `deepl.createGlossary` | createGlossary |
| `deepl.getGlossary` | getGlossary |
| `deepl.listGlossaries` | listGlossaries |
| `deepl.deleteGlossary` | deleteGlossary |
| `deepl.getGlossaryEntries` | getGlossaryEntries |
| `deepl.translateDocument` | translateDocument |

## Examples

### translateText

```robinpath
deepl.translateText
```

### translateBatch

```robinpath
deepl.translateBatch
```

### getUsage

```robinpath
deepl.getUsage
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/deepl";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  deepl.setCredentials "your-credentials"
  deepl.translateText
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/openai`](../openai) — OpenAI module for complementary functionality
- [`@robinpath/anthropic`](../anthropic) — Anthropic module for complementary functionality
- [`@robinpath/ai`](../ai) — AI module for complementary functionality
- [`@robinpath/translate`](../translate) — Translate module for complementary functionality
- [`@robinpath/json`](../json) — JSON module for complementary functionality

## License

MIT
npm package: @robinpath/diff
Description: Text and data diffing: line, word, character, object, and array diffs with unified output
Latest version: 0.1.1

# @robinpath/diff

> Text and data diffing: line, word, character, object, and array diffs with unified output

![Category](https://img.shields.io/badge/category-Utility-blue) ![Functions](https://img.shields.io/badge/functions-9-green) ![Auth](https://img.shields.io/badge/auth-none-lightgrey) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `diff` module lets you:

- Diff two strings line by line
- Diff two strings character by character
- Diff two strings word by word
- Diff two objects
- Diff two arrays

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/diff
```

## Quick Start

No credentials needed — start using it right away:

```robinpath
diff.chars "cat" "car"
```

## Available Functions

| Function | Description |
|----------|-------------|
| `diff.lines` | Diff two strings line by line |
| `diff.chars` | Diff two strings character by character |
| `diff.words` | Diff two strings word by word |
| `diff.objects` | Diff two objects |
| `diff.arrays` | Diff two arrays |
| `diff.patch` | Apply a line diff to produce the new string |
| `diff.unified` | Generate unified diff format (like git diff) |
| `diff.isEqual` | Deep equality check |
| `diff.stats` | Get diff statistics from a diff result |

## Examples

### Diff two strings character by character

```robinpath
diff.chars "cat" "car"
```

### Diff two strings word by word

```robinpath
diff.words $old $new
```

### Diff two objects

```robinpath
diff.objects $obj1 $obj2
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/diff";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  diff.chars "cat" "car"
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/json`](../json) — JSON module for complementary functionality

## License

MIT
npm package: @robinpath/dns
Description: DNS lookups: resolve, reverse, MX, TXT, NS, SRV, SOA, CNAME records
Latest version: 0.1.1

# @robinpath/dns

> DNS lookups: resolve, reverse, MX, TXT, NS, SRV, SOA, CNAME records

![Category](https://img.shields.io/badge/category-Utility-blue) ![Functions](https://img.shields.io/badge/functions-12-green) ![Auth](https://img.shields.io/badge/auth-none-lightgrey) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `dns` module lets you:

- Resolve hostname to records by type
- Resolve hostname to IPv4 addresses
- Resolve hostname to IPv6 addresses
- Reverse DNS lookup
- OS-level DNS lookup

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/dns
```

## Quick Start

No credentials needed — start using it right away:

```robinpath
dns.resolve4 "example.com"
```

## Available Functions

| Function | Description |
|----------|-------------|
| `dns.resolve` | Resolve hostname to records by type |
| `dns.resolve4` | Resolve hostname to IPv4 addresses |
| `dns.resolve6` | Resolve hostname to IPv6 addresses |
| `dns.reverse` | Reverse DNS lookup |
| `dns.lookup` | OS-level DNS lookup |
| `dns.mx` | Get MX records sorted by priority |
| `dns.txt` | Get TXT records |
| `dns.ns` | Get nameserver records |
| `dns.srv` | Get SRV records |
| `dns.soa` | Get SOA record |
| `dns.cname` | Get CNAME records |
| `dns.isResolvable` | Check if hostname resolves |

## Examples

### Resolve hostname to IPv4 addresses

```robinpath
dns.resolve4 "example.com"
```

### Resolve hostname to IPv6 addresses

```robinpath
dns.resolve6 "example.com"
```

### Reverse DNS lookup

```robinpath
dns.reverse "8.8.8.8"
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/dns";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  dns.resolve4 "example.com"
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/json`](../json) — JSON module for complementary functionality

## License

MIT
npm package: @robinpath/docker
Description: Docker container and image management using the system docker binary
Latest version: 0.1.1

# @robinpath/docker

> Docker container and image management using the system docker binary

![Category](https://img.shields.io/badge/category-DevOps-blue) ![Functions](https://img.shields.io/badge/functions-16-green) ![Auth](https://img.shields.io/badge/auth-none-lightgrey) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `docker` module lets you:

- List Docker containers
- List Docker images
- Run a new container from an image
- Stop a running container
- Start a stopped container

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/docker
```

## Quick Start

No credentials needed — start using it right away:

```robinpath
docker.images
```

## Available Functions

| Function | Description |
|----------|-------------|
| `docker.ps` | List Docker containers |
| `docker.images` | List Docker images |
| `docker.run` | Run a new container from an image |
| `docker.stop` | Stop a running container |
| `docker.start` | Start a stopped container |
| `docker.rm` | Remove a container |
| `docker.rmi` | Remove a Docker image |
| `docker.logs` | Fetch logs from a container |
| `docker.exec` | Execute a command inside a running container |
| `docker.build` | Build a Docker image from a Dockerfile |
| `docker.pull` | Pull a Docker image from a registry |
| `docker.push` | Push a Docker image to a registry |
| `docker.inspect` | Return low-level information on a container or image |
| `docker.stats` | Display container resource usage statistics |
| `docker.network` | Manage Docker networks |
| `docker.volume` | Manage Docker volumes |

## Examples

### List Docker images

```robinpath
docker.images
```

### Run a new container from an image

```robinpath
docker.run
```

### Stop a running container

```robinpath
docker.stop
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/docker";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  docker.images
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/git`](../git) — Git module for complementary functionality
- [`@robinpath/github`](../github) — GitHub module for complementary functionality
- [`@robinpath/gitlab`](../gitlab) — GitLab module for complementary functionality
- [`@robinpath/vercel`](../vercel) — Vercel module for complementary functionality
- [`@robinpath/netlify`](../netlify) — Netlify module for complementary functionality

## License

MIT
npm package: @robinpath/docusign
Description: DocuSign module for RobinPath.
Latest version: 0.1.1

# @robinpath/docusign

> DocuSign module for RobinPath.

![Category](https://img.shields.io/badge/category-Documents-blue) ![Functions](https://img.shields.io/badge/functions-15-green) ![Auth](https://img.shields.io/badge/auth-API%20Key-orange) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `docusign` module lets you:

- listEnvelopes
- getEnvelope
- createEnvelope
- sendEnvelope
- voidEnvelope

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/docusign
```

## Quick Start

**1. Set up credentials**

```robinpath
docusign.setCredentials "your-credentials"
```

**2. listEnvelopes**

```robinpath
docusign.listEnvelopes
```

## Available Functions

| Function | Description |
|----------|-------------|
| `docusign.setCredentials` | Configure docusign credentials. |
| `docusign.listEnvelopes` | listEnvelopes |
| `docusign.getEnvelope` | getEnvelope |
| `docusign.createEnvelope` | createEnvelope |
| `docusign.sendEnvelope` | sendEnvelope |
| `docusign.voidEnvelope` | voidEnvelope |
| `docusign.getEnvelopeDocuments` | getEnvelopeDocuments |
| `docusign.downloadDocument` | downloadDocument |
| `docusign.listRecipients` | listRecipients |
| `docusign.getRecipientStatus` | getRecipientStatus |
| `docusign.listTemplates` | listTemplates |
| `docusign.getTemplate` | getTemplate |
| `docusign.createEnvelopeFromTemplate` | createEnvelopeFromTemplate |
| `docusign.getUserInfo` | getUserInfo |
| `docusign.getAccount` | getAccount |

## Examples

### listEnvelopes

```robinpath
docusign.listEnvelopes
```

### getEnvelope

```robinpath
docusign.getEnvelope
```

### createEnvelope

```robinpath
docusign.createEnvelope
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/docusign";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  docusign.setCredentials "your-credentials"
  docusign.listEnvelopes
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/pdf`](../pdf) — PDF module for complementary functionality
- [`@robinpath/excel`](../excel) — Excel module for complementary functionality
- [`@robinpath/office`](../office) — Office module for complementary functionality
- [`@robinpath/pandadoc`](../pandadoc) — PandaDoc module for complementary functionality
- [`@robinpath/hellosign`](../hellosign) — HelloSign module for complementary functionality

## License

MIT
npm package: @robinpath/dotenv
Description: Secure .env file management with key validation, path restrictions, and protected system variables
Latest version: 0.1.1

# @robinpath/dotenv

> Secure .env file management with key validation, path restrictions, and protected system variables

![Category](https://img.shields.io/badge/category-Utility-blue) ![Functions](https://img.shields.io/badge/functions-10-green) ![Auth](https://img.shields.io/badge/auth-none-lightgrey) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `dotenv` module lets you:

- Parse a .env format string into an object
- Convert an object to .env format string
- Read a .env file and load values into process.env (won't override existing or protected vars by default)
- Read a .env file and return as object without modifying process.env
- Get a value from a .env file by key

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/dotenv
```

## Quick Start

No credentials needed — start using it right away:

```robinpath
dotenv.stringify $vars
```

## Available Functions

| Function | Description |
|----------|-------------|
| `dotenv.parse` | Parse a .env format string into an object |
| `dotenv.stringify` | Convert an object to .env format string |
| `dotenv.load` | Read a .env file and load values into process.env (won't override existing or protected vars by default) |
| `dotenv.read` | Read a .env file and return as object without modifying process.env |
| `dotenv.get` | Get a value from a .env file by key |
| `dotenv.set` | Set a key=value in a .env file |
| `dotenv.remove` | Remove a key from a .env file |
| `dotenv.exists` | Check if a .env file exists |
| `dotenv.keys` | Return all keys from a .env file |
| `dotenv.expand` | Expand variable references like ${VAR} in values (process.env fallback disabled by default) |

## Examples

### Convert an object to .env format string

```robinpath
dotenv.stringify $vars
```

### Read a .env file and load values into process.env (won't override existing or protected vars by default)

```robinpath
dotenv.load ".env"
```

### Read a .env file and return as object without modifying process.env

```robinpath
dotenv.read ".env.local"
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/dotenv";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  dotenv.stringify $vars
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/json`](../json) — JSON module for complementary functionality

## License

MIT
npm package: @robinpath/dropbox
Description: Dropbox module for RobinPath.
Latest version: 0.1.1

# @robinpath/dropbox

> Dropbox module for RobinPath.

![Category](https://img.shields.io/badge/category-Cloud-storage-blue) ![Functions](https://img.shields.io/badge/functions-19-green) ![Auth](https://img.shields.io/badge/auth-API%20Key-orange) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `dropbox` module lets you:

- listFolder
- getMetadata
- createFolder
- deleteEntry
- moveEntry

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/dropbox
```

## Quick Start

**1. Set up credentials**

```robinpath
dropbox.setCredentials "your-credentials"
```

**2. listFolder**

```robinpath
dropbox.listFolder
```

## Available Functions

| Function | Description |
|----------|-------------|
| `dropbox.setCredentials` | Configure dropbox credentials. |
| `dropbox.listFolder` | listFolder |
| `dropbox.getMetadata` | getMetadata |
| `dropbox.createFolder` | createFolder |
| `dropbox.deleteEntry` | deleteEntry |
| `dropbox.moveEntry` | moveEntry |
| `dropbox.copyEntry` | copyEntry |
| `dropbox.uploadFile` | uploadFile |
| `dropbox.downloadFile` | downloadFile |
| `dropbox.getTemporaryLink` | getTemporaryLink |
| `dropbox.searchFiles` | searchFiles |
| `dropbox.listRevisions` | listRevisions |
| `dropbox.restoreFile` | restoreFile |
| `dropbox.createSharedLink` | createSharedLink |
| `dropbox.listSharedLinks` | listSharedLinks |
| `dropbox.revokeSharedLink` | revokeSharedLink |
| `dropbox.getSpaceUsage` | getSpaceUsage |
| `dropbox.getCurrentAccount` | getCurrentAccount |
| `dropbox.getPreview` | getPreview |

## Examples

### listFolder

```robinpath
dropbox.listFolder
```

### getMetadata

```robinpath
dropbox.getMetadata
```

### createFolder

```robinpath
dropbox.createFolder
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/dropbox";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  dropbox.setCredentials "your-credentials"
  dropbox.listFolder
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/s3`](../s3) — Amazon S3 module for complementary functionality
- [`@robinpath/box`](../box) — Box module for complementary functionality
- [`@robinpath/onedrive`](../onedrive) — OneDrive module for complementary functionality
- [`@robinpath/google-drive`](../google-drive) — Google Drive module for complementary functionality
- [`@robinpath/json`](../json) — JSON module for complementary functionality

## License

MIT
npm package: @robinpath/encrypt
Description: AES and RSA encryption/decryption with key generation
Latest version: 0.1.1

# @robinpath/encrypt

> AES-256-GCM and RSA encryption/decryption with key generation, password-based key derivation, and hashing

![Category](https://img.shields.io/badge/category-Utility-blue) ![Functions](https://img.shields.io/badge/functions-10-green) ![Auth](https://img.shields.io/badge/auth-none-lightgrey) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `encrypt` module lets you:

- Encrypt text with AES using a password (auto-generates salt/IV)
- Decrypt AES-encrypted data using a password
- Encrypt text with a raw hex key (for advanced use)
- Generate a cryptographically secure random key
- Generate an RSA key pair

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/encrypt
```

## Quick Start

No credentials needed — start using it right away:

```robinpath
encrypt.aesDecrypt $encryptedData "my-password"
```

## Available Functions

| Function | Description |
|----------|-------------|
| `encrypt.aesEncrypt` | Encrypt text with AES using a password (auto-generates salt/IV) |
| `encrypt.aesDecrypt` | Decrypt AES-encrypted data using a password |
| `encrypt.aesEncryptRaw` | Encrypt text with a raw hex key (for advanced use) |
| `encrypt.generateKey` | Generate a cryptographically secure random key |
| `encrypt.rsaGenerateKeys` | Generate an RSA key pair |
| `encrypt.rsaEncrypt` | Encrypt text with an RSA public key |
| `encrypt.rsaDecrypt` | Decrypt RSA-encrypted text with a private key |
| `encrypt.hash` | Hash a string (sha256, sha512, md5, etc.) |
| `encrypt.deriveKey` | Derive an encryption key from a password using scrypt |
| `encrypt.randomIv` | Generate a random initialization vector |

## Examples

### Decrypt AES-encrypted data using a password

```robinpath
encrypt.aesDecrypt $encryptedData "my-password"
```

### Encrypt text with a raw hex key (for advanced use)

```robinpath
encrypt.aesEncryptRaw "data" $hexKey
```

### Generate a cryptographically secure random key

```robinpath
encrypt.generateKey 256
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/encrypt";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  encrypt.aesDecrypt $encryptedData "my-password"
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/json`](../json) — JSON module for complementary functionality

## License

MIT
npm package: @robinpath/env
Description: Secure environment variable management with sensitive value redaction and protected system vars
Latest version: 0.1.1

# @robinpath/env

> Secure environment variable management with sensitive value redaction and protected system vars

![Category](https://img.shields.io/badge/category-Other-blue) ![Functions](https://img.shields.io/badge/functions-7-green) ![Auth](https://img.shields.io/badge/auth-none-lightgrey) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `env` module lets you:

- Get the value of an environment variable
- Check if an environment variable exists
- Get all environment variables (sensitive values are redacted by default)
- Delete an environment variable (protected system vars cannot be deleted)
- Mark an environment variable as sensitive (will be redacted in env.all output)

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/env
```

## Quick Start

No credentials needed — start using it right away:

```robinpath
env.set "API_URL" "https://api.example.com"
```

## Available Functions

| Function | Description |
|----------|-------------|
| `env.get` | Get the value of an environment variable |
| `env.set` | Set an environment variable (protected system vars cannot be overwritten) |
| `env.has` | Check if an environment variable exists |
| `env.all` | Get all environment variables (sensitive values are redacted by default) |
| `env.delete` | Delete an environment variable (protected system vars cannot be deleted) |
| `env.secret` | Mark an environment variable as sensitive (will be redacted in env.all output) |
| `env.load` | Load environment variables from a .env file (won't override existing or protected vars) |

## Examples

### Set an environment variable (protected system vars cannot be overwritten)

```robinpath
env.set "API_URL" "https://api.example.com"
```

### Check if an environment variable exists

```robinpath
env.has "NODE_ENV"
```

### Get all environment variables (sensitive values are redacted by default)

```robinpath
env.all
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/env";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  env.set "API_URL" "https://api.example.com"
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/json`](../json) — JSON module for complementary functionality

## License

MIT
npm package: @robinpath/excel
Description: Read, write, and manipulate Excel spreadsheets (.xlsx)
Latest version: 0.1.4

# @robinpath/excel

> Read, write, and manipulate Excel spreadsheets (.xlsx) with sheets, cells, JSON/CSV conversion

![Category](https://img.shields.io/badge/category-Documents-blue) ![Functions](https://img.shields.io/badge/functions-9-green) ![Auth](https://img.shields.io/badge/auth-none-lightgrey) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `excel` module lets you:

- Read an Excel file into an array of row objects
- Write an array of objects to an Excel file
- List all sheet names in an Excel file
- Add a new sheet with data to an existing Excel file
- Convert an Excel file to JSON (shortcut for read().rows)

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/excel
```

## Quick Start

No credentials needed — start using it right away:

```robinpath
excel.write "./output.xlsx" $data {"sheetName": "Users"}
```

## Available Functions

| Function | Description |
|----------|-------------|
| `excel.read` | Read an Excel file into an array of row objects |
| `excel.write` | Write an array of objects to an Excel file |
| `excel.readSheetNames` | List all sheet names in an Excel file |
| `excel.addSheet` | Add a new sheet with data to an existing Excel file |
| `excel.toJson` | Convert an Excel file to JSON (shortcut for read().rows) |
| `excel.fromJson` | Create an Excel file from JSON data |
| `excel.toCsv` | Convert an Excel file to CSV string |
| `excel.getCell` | Get a specific cell value |
| `excel.setCell` | Set a specific cell value |

## Examples

### Write an array of objects to an Excel file

```robinpath
excel.write "./output.xlsx" $data {"sheetName": "Users"}
```

### List all sheet names in an Excel file

```robinpath
excel.readSheetNames "./data.xlsx"
```

### Add a new sheet with data to an existing Excel file

```robinpath
excel.addSheet "./data.xlsx" "Summary" $summaryData
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/excel";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  excel.write "./output.xlsx" $data {"sheetName": "Users"}
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/pdf`](../pdf) — PDF module for complementary functionality
- [`@robinpath/office`](../office) — Office module for complementary functionality
- [`@robinpath/docusign`](../docusign) — DocuSign module for complementary functionality
- [`@robinpath/pandadoc`](../pandadoc) — PandaDoc module for complementary functionality
- [`@robinpath/hellosign`](../hellosign) — HelloSign module for complementary functionality

## License

MIT