@thinremote/thinr-cli 1.0.2 → 1.1.0-alpha.1

package/CHANGELOG.md

@@ -1,5 +1,94 @@
 # Changelog
 
+## [1.1.0] - 2026-04-16
+
+Major release: MCP server for AI clients, subcommand-first CLI, JSON
+output, multi-profile configuration, product-level fan-outs, and a
+consistent error taxonomy across both interfaces.
+
+### Added
+
+- **MCP server** (`thinr mcp`) exposing ~26 typed tools over stdio for AI
+  clients (Claude Code, Claude Desktop, and any other MCP host). Covers
+  discovery, shell `exec`, filesystem (`read`/`write`/`ls`/`mkdir`/`delete`/
+  `move`), typed `resource` calls, properties, scripts (device- and
+  product-level), products, monitoring and agent updates, plus a profiles
+  lookup. MCP errors carry the same `{ code }` taxonomy as the CLI JSON
+  mode (exposed on `_meta`) so clients can pattern-match without parsing
+  human strings.
+- **Subcommand-first CLI UX**: `thinr device <action> <deviceId>` /
+  `thinr product <action> <productId>` replaces the previous top-level
+  flag shape. Matches `kubectl` / `git` idioms.
+- `thinr device list [pattern]` with case-insensitive regex filtering on
+  the server side (replaces the old `thinr devices`).
+- `thinr device exec <deviceId> <command...>` with streaming stdout/stderr,
+  SIGINT cancellation, `--json` envelope, and `--legacy` one-shot fallback
+  for older agents.
+- `thinr device update check|apply` for managing agent upgrades.
+- `thinr device resource` with per-resource input/output schema
+  introspection, and `thinr product resource` / `thinr product property`
+  for fleet fan-outs.
+- **Multi-profile configuration store** (`~/.config/thinr-cli/config.json`):
+  one profile per server, selected via `--profile`, the `THINR_PROFILE`
+  env var, or a per-call MCP parameter. Legacy single-file configs are
+  detected and migrated in-memory on read.
+- `thinr profile list|current|use|delete` for managing configured
+  environments.
+- `--json` / `-j` output envelope on every data-producing command with a
+  stable `{ code }` taxonomy: `not_configured`, `not_found`,
+  `unauthorized`, `server_error`, `network_error`, `input_error`,
+  `timeout`, `cancelled`, `error`.
+- `-u, --user` admin impersonation flag plumbed through every
+  device-scoped operation (CLI + MCP).
+- `THINR_INSECURE=1` env var to accept self-signed TLS certificates
+  against non-localhost hosts (localhost / 127.0.0.1 are always
+  accepted).
+- Device property setter via PUT (`setDeviceProperty` in the CLI,
+  `thinr_property_set` in MCP).
+- `thinr_device_info` MCP tool surfaces server-side product, asset group
+  and description alongside the agent's own `system_info`.
+- Refresh-token flow on 401s: the CLI transparently swaps expired access
+  tokens for a fresh one when a `refresh_token` is on record, and fails
+  cleanly (with an actionable `unauthorized` error) when it isn't.
+
+### Changed
+
+- **MCP server internals**: tool schema and handler now paired in a
+  registry, so they cannot drift apart. Tools grouped by area under
+  `lib/mcp/tools-*.js`, with `server.js` reduced to a thin bootstrap.
+- **CLI `device` command** split into one file per subcommand under
+  `commands/device/` (previously a single 17 KB module).
+- `lib/device.js` renamed to `lib/devices.js` (plural: operations on the
+  fleet), paired with the low-level `lib/device-api.js`.
+- Interactive handlers (auth / console / proxy) no longer call
+  `process.exit` from `lib/*`; the CLI entry owns the exit code.
+- Centralised API error classification in `lib/errors.js` — one
+  `{ message, code, status }` contract consumed by both CLI JSON mode
+  and MCP `_meta`.
+- Re-thrown auth errors chain the original `cause` for better
+  debugging.
+- Bad `-i key=value` values surface as a clean Commander
+  `InvalidArgumentError` instead of a stack trace.
+- Node.js engine requirement bumped to **`>=18`**; `.nvmrc` pinned to 20.
+
+### Removed
+
+- `thinr devices` (use `thinr device list` instead).
+- `thinr device mcp <deviceId>` (use `thinr mcp` with per-call `device`
+  parameter).
+- `thinr device env` launcher.
+
+### Tooling
+
+- ESLint 10 (flat config) + Prettier 3 with `eslint-config-prettier`
+  bridge. Scripts: `npm run lint` / `lint:fix` / `format` /
+  `format:check`.
+- TypeScript `checkJs` via per-file `// @ts-check` opt-in; 21 files
+  under `lib/mcp/` and `commands/device/` pass type-check today. Script:
+  `npm run typecheck`.
+- Unit tests with `node --test` (zero deps): MCP registry invariants +
+  error helpers. Script: `npm test`.
+
 ## [1.0.2] - 2025-07-21
 
 ### Fixed
@@ -31,6 +120,7 @@
 - Property listing and retrieval
 - Device resource listing and execution
 
+[1.1.0]: https://github.com/Thin-Remote/thinr-cli/compare/1.0.2...1.1.0
 [1.0.2]: https://github.com/Thin-Remote/thinr-cli/compare/1.0.1...1.0.2
 [1.0.1]: https://github.com/Thin-Remote/thinr-cli/compare/1.0.0...1.0.1
 [1.0.0]: https://github.com/Thin-Remote/thinr-cli/tag/1.0.0

package/README.md

@@ -1,18 +1,45 @@
-# Thinr - ThinRemote CLI
+# Thinr — ThinRemote CLI
 
 <p align="center">
-  <img src='https://s3.us-east-1.amazonaws.com/thinremote.io.files/share-image.svg' alt="Thinger n8n node">
+  <img src='https://s3.us-east-1.amazonaws.com/thinremote.io.files/share-image.svg' alt="Thinger">
 </p>
 
-A modern command-line interface for managing remote devices through the ThinRemote platform.
-
-## Features
-
-- **Remote Terminal**: Connect to a device's terminal and interact with it directly
-- **TCP/Web Proxy**: Create proxies to remote devices, either for TCP connections or web interfaces
-- **Device Status**: Check connection status and statistics for a device
-- **Secure Authentication**: Support for both username/password and token-based authentication
-- **Modern UI**: Clean and intuitive command-line interface
+A command-line tool for managing remote IoT devices on the ThinRemote
+platform, and an MCP server that lets AI assistants drive those
+devices programmatically.
+
+Two operating modes:
+
+- **CLI** — interactive or scripted device management from a shell.
+- **MCP server** — a stdio [Model Context Protocol][mcp] server that
+  exposes the same operations as typed tools for AI clients like
+  Claude Code.
+
+Both modes share the same auth, profiles, and device API layer, so
+you configure the tool once and use it in whichever mode fits the
+task at hand.
+
+[mcp]: https://modelcontextprotocol.io/
+
+## Table of contents
+
+- [Installation](#installation)
+- [Initial setup](#initial-setup)
+- [Global options and environment variables](#global-options-and-environment-variables)
+- [Part 1 — CLI](#part-1--cli)
+    - [JSON output](#json-output)
+    - [`thinr device <action> [<deviceId>]`](#thinr-device-action-deviceid)
+    - [`thinr product <action> <productId>`](#thinr-product-action-productid)
+    - [`thinr profile`](#thinr-profile)
+    - [`thinr logout`](#thinr-logout)
+- [Part 2 — MCP server](#part-2--mcp-server)
+    - [Starting the server](#starting-the-server)
+    - [Tool catalog](#tool-catalog)
+    - [Per-call controls](#per-call-controls)
+    - [Integrating with Claude Code](#integrating-with-claude-code)
+- [Profiles and multi-account use](#profiles-and-multi-account-use)
+- [Development](#development)
+- [License](#license)
 
 ## Installation
 
@@ -22,7 +49,7 @@ A modern command-line interface for managing remote devices through the ThinRemo
 npm install -g @thinremote/thinr-cli
 ```
 
-### From Source
+### From source
 
 ```bash
 git clone https://github.com/Thin-Remote/thinr-cli.git
@@ -31,174 +58,422 @@ npm install
 npm link
 ```
 
-## Usage
+Requires Node.js ≥ 18.
 
-### Initial Setup
+## Initial setup
 
-Run the CLI without any parameters to set up:
+Run the CLI once with no arguments to authenticate:
 
 ```bash
 thinr
 ```
 
-You'll be prompted to authenticate either with username/password or with an existing token.
+You'll be prompted for the ThinRemote server, and can authenticate
+with either username/password (OAuth 2.0 device flow) or a pre-issued
+token. On success a profile is created at
+`~/.config/thinr-cli/config.json`, named after the server hostname,
+and marked as the default.
+
+Every later command reads that profile automatically. Logging into a
+second server creates a second profile side-by-side; see
+[Profiles and multi-account use](#profiles-and-multi-account-use).
+
+## Global options and environment variables
+
+These apply to every subcommand:
+
+| Flag                | Env var            | Meaning                                                                                                                                                            |
+| ------------------- | ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `--profile <name>`  | `THINR_PROFILE`    | Use a non-default profile for this invocation.                                                                                                                     |
+| `-u, --user <name>` | —                  | Admin impersonation: act on behalf of another user (requires admin privileges on the server).                                                                      |
+| —                   | `THINR_INSECURE=1` | Accept self-signed TLS certificates globally. Localhost / 127.0.0.1 are always accepted; this flag extends the relaxation to any host, useful for LAN dev servers. |
+
+---
+
+## Part 1 — CLI
+
+All device- and product-scoped actions follow a **subcommand-first**
+shape: the action comes before the target id, matching patterns like
+`kubectl describe pod <name>` or `git remote add <name> <url>`.
+
+```
+thinr device <action>  <deviceId>  [args…] [options]
+thinr product <action> <productId> [args…] [options]
+```
+
+### JSON output
+
+Every data-producing command accepts `-j, --json` and writes a single
+envelope to stdout so scripts can pipe it to `jq`:
+
+```json
+{ "ok": true, "data": <payload> }
+{ "ok": false, "error": { "message": "...", "code": "<code>" } }
+```
+
+Process exit codes always reflect success (`0`) or failure (non-zero),
+independently of the envelope.
+
+Emitted error `code` values:
+
+| code             | meaning                                           |
+| ---------------- | ------------------------------------------------- |
+| `not_configured` | CLI has no saved profile — run `thinr` to set up. |
+| `not_found`      | Device, property, resource or profile not found.  |
+| `unauthorized`   | Token expired or insufficient permissions.        |
+| `server_error`   | Non-success HTTP response from the server.        |
+| `network_error`  | No response from the server.                      |
+| `input_error`    | Bad or missing CLI argument.                      |
+| `timeout`        | Command timed out on the device (`exec`).         |
+| `cancelled`      | User interrupted with Ctrl+C (`exec`).            |
+| `error`          | Fallback for anything uncategorised.              |
+
+Spinners and progress messages are suppressed in JSON mode so the
+output is valid JSON without wrappers. Interactive commands
+(`console`, `tcp`/`tls`/`http`) accept `--json` silently but
+don't change their behaviour — they don't produce a discrete result.
+`exec` buffers stdout/stderr when `--json` is set and emits a single
+envelope on exit.
+
+### `thinr device <action> [<deviceId>]`
+
+Most actions take a `<deviceId>` as their first positional. The `list`
+action is the exception — it operates on the fleet, with an optional
+`<pattern>` to filter results.
 
-### Available Commands
+#### `list`
 
-#### Device
+List every device visible to the active profile, or filter with a
+case-insensitive regex (matched against device id and name on the
+server side):
 
-##### Console
+```bash
+thinr device list                    # every device
+thinr device list supermicro         # only ids/names containing "supermicro"
+thinr device list "^revpi|jetson"    # regex alternation works too
+thinr device list --json             # JSON envelope with the raw API records
+```
+
+Combine with the global `-u, --user` flag for admin impersonation.
 
-Connect to a device's terminal:
+#### `console`
+
+Open an interactive terminal on the device:
 
 ```bash
-thinr device <deviceId> console
+thinr device console <deviceId>
 ```
 
-##### Proxy
+#### Proxies — `tcp` / `tls` / `http`
 
-Create a TCP or HTTP proxy to a remote device:
+Create a TCP, TLS, or HTTP proxy to a remote endpoint reachable from
+the device:
 
 ```bash
-thinr device <deviceId> tcp <target> [options]
-thinr device <deviceId> tls <target> [options]
-thinr device <deviceId> http <taget> [options]
+thinr device tcp  <deviceId> [target] [options]
+thinr device tls  <deviceId> [target] [options]
+thinr device http <deviceId> [target] [options]
 ```
 
-The target being the remote address and port on the device (defaults: tcp: 22, http: 80, tls: 443, and localhost for the target address).
+`target` is the remote address and port on the device side. Defaults
+when omitted: `tcp` → 22, `tls` → 443, `http` → 80, against
+localhost.
 
 Options:
-- `-w, --web`: Create an HTTP proxy for web interface instead of TCP
-- `--no-open`: Do not open browser automatically (web mode only)
+
+- `-p, --port <port>`: Local port to bind (default: random in 50000–51000)
+- `--no-open`: Do not open the browser automatically (http only)
 
 Examples:
+
 ```bash
-# Create a TCP proxy to SSH
-thinr device RevPi20679 tcp 22
+# TCP proxy to SSH
+thinr device tcp RevPi20679 22
 
-# Create a proxy to a specific port with SSL
-thinr device RevPi20679 http 8080
+# HTTP proxy to a specific port
+thinr device http RevPi20679 8080
 
-# Create a proxy to a specific address
-thinr device RevPi20679 http http://192.168.1.45:8080
+# HTTP proxy to a specific address behind the device
+thinr device http RevPi20679 http://192.168.1.45:8080
 ```
 
-##### Status
+#### `status`
+
+```bash
+thinr device status <deviceId> [-j, --json]
+```
+
+Returns the device's connection stats (uptime, tx/rx, last-seen).
+
+#### `property`
 
-Check the connection status of a device:
+List every property of a device, or read one by id:
 
 ```bash
-thinr device <deviceId> status [options]
+thinr device property <deviceId>                                # list
+thinr device property <deviceId> <propertyId> [options]         # read
 ```
 
 Options:
-- `-j, --json`: Output the status in JSON format
 
-##### Property
+- `-j, --json`: Output as JSON
+- `-f, --field <path>`: Extract a sub-field via dot path (`-f data.value`)
 
-Retrieve the properties of a device:
+#### `resource`
+
+List the resources exposed by the device (with their `in`/`out`
+schemas when advertised), or call one:
 
 ```bash
-thinr device <deviceId> property [options]
+thinr device resource <deviceId>                                # list
+thinr device resource <deviceId> <resourceId> [options]         # call
 ```
 
-Retrieve a property from a device:
+Options:
+
+- `-i, --input <key=value>`: Resource input (repeatable)
+- `-j, --json`: Output as JSON
+- `-f, --field <path>`: Extract a sub-field from the result (dot path)
+
+#### `exec`
+
+Run a shell command on the device and stream stdout/stderr back:
 
 ```bash
-thinr device <deviceId> property <propertyId> [options]
+thinr device exec <deviceId> "<command>" [options]
 ```
 
 Options:
-- `-j, --json`: Output the status in JSON format
-- `-f, --field`: Field to extract from the property or resource (e.g., -f data.value)
 
-##### Resource
+- `-j, --json`: Buffer output and emit a single envelope
+  `{stdout, stderr, exitCode}` on exit
+- `--legacy`: Use the non-streaming one-shot API (older agents)
+
+The process exits with the remote command's exit code.
 
-Get the available resources of a device:
+#### `update`
+
+Check for or apply an agent update on the device:
 
 ```bash
-thinr device <deviceId> resource [options]
+thinr device update check <deviceId> [options]
+thinr device update apply <deviceId> [options]
 ```
 
 Options:
-- `-j, --json`: Output the status in JSON format
 
-Execute a resource on a device:
+- `--channel <name>`: Update channel (default: `latest`)
+- `-j, --json`: Output as JSON
+
+### `thinr product <action> <productId>`
+
+Fan out an operation across every device that belongs to a product.
+
+#### `property`
 
 ```bash
-thinr device <deviceId> resource <resourceId> [options]
+thinr product property <productId> <propertyId> [options]
 ```
 
 Options:
-- `-i, --input`: Input for the resource (e.g., -i param1=value1 -i param2=value2)
-- `-j, --json`: Output the status in JSON format
-- `-f, --field`: Field to extract from the property or resource (e.g., -f data.value)
 
-##### Product
+- `-j, --json`: Output as JSON. Emits one envelope with a `results[]`
+  array, one entry per device, each with its own `ok` flag.
+- `-f, --field <path>`: Extract a sub-field from each property (dot path)
+- `-a, --all`: Include offline devices (default: only active)
+- `-g, --group <group>`: Filter devices by asset group
 
-Iterate over all devices of a specific product in order to retrieve a property or execute a resource:
+#### `resource`
 
 ```bash
-thinr product <productId> property [options]
-thinr product <productId> resource [options]
+thinr product resource <productId> <resource> [options]
 ```
 
 Options:
-- `-j, --json`: Output the status in JSON format
-- `-f, --field`: Field to extract from the property or resource (e.g., -f data.value)
 
-Options for executing a resource:
-- `-i, --input`: Input for the resource (e.g., -i param1=value1 -i param2=value2)
+- `-j, --json`: Output as JSON (`results[]` array, same shape as above)
+- `-f, --field <path>`: Extract a sub-field from each result (dot path)
+- `-g, --group <group>`: Filter devices by asset group
+- `-i, --input <key=value>`: Resource input (repeatable)
 
+Offline devices are skipped for `resource` — the server would reject
+the call anyway.
 
-### Help
+### `thinr profile`
 
-Get help for any command:
+Manage the profile store (see [Profiles and multi-account
+use](#profiles-and-multi-account-use)):
 
 ```bash
-thinr --help
-thinr device --help
-thinr logout --help
+thinr profile list          [--json]
+thinr profile current       [--json]
+thinr profile use    <name> [--json]
+thinr profile delete <name> [--json]
 ```
 
-## Development
+### `thinr logout`
 
-The project structure is organized as follows:
+Remove the active profile's credentials and config:
 
+```bash
+thinr logout
 ```
-thinr/
-├── bin/           # Main executable
-├── lib/           # Core functionality
-├── commands/      # Command implementations
-├── package.json
-└── README.md
+
+Other profiles are left untouched.
+
+---
+
+## Part 2 — MCP server
+
+`thinr` ships an [MCP][mcp] server that exposes the CLI's device
+operations as a set of typed tools. AI clients (Claude Code, Claude
+Desktop, and any other MCP-compatible host) can then list devices,
+run shell commands, read/write files, call resources, and manage
+products through the same API the CLI uses — with stable schemas and
+a consistent error contract.
+
+### Starting the server
+
+```bash
+thinr mcp [-d, --device <deviceId>]
 ```
 
-### Building
+The server speaks [MCP over stdio][mcp-stdio]. `-d/--device` sets a
+default device that tools can omit in each call; `--user` can be
+passed through (via the global flag) to impersonate another account.
+
+[mcp-stdio]: https://modelcontextprotocol.io/specification/server/transport#stdio
+
+### Tool catalog
+
+Roughly 28 tools, grouped by capability. Every tool accepts optional
+`device`, `user`, and `profile` arguments, so a single session can
+target any device/account/environment without restart.
+
+| Area                  | Tools                                                                                                                 |
+| --------------------- | --------------------------------------------------------------------------------------------------------------------- |
+| Discovery             | `thinr_devices` (with optional `query` for regex filtering), `thinr_device_info`, `thinr_profiles`                    |
+| Shell                 | `thinr_exec` (buffered), with streaming stdout/stderr                                                                 |
+| Filesystem            | `thinr_read`, `thinr_write`, `thinr_ls`, `thinr_mkdir`, `thinr_delete`, `thinr_move`                                  |
+| Resources             | `thinr_resource_list` (with `in`/`out` schemas), `thinr_resource_call`                                                |
+| Properties            | `thinr_property_get`, `thinr_property_set`                                                                            |
+| Scripts (device)      | `thinr_script_list`, `thinr_script_write`, `thinr_script_delete`                                                      |
+| Monitoring and update | `thinr_monitoring`, `thinr_update`                                                                                    |
+| Products              | `thinr_products`, `thinr_product_delete`, `thinr_device_set_product`                                                  |
+| Product scripts       | `thinr_product_script_list`, `thinr_product_script_read`, `thinr_product_script_write`, `thinr_product_script_delete` |
+
+Full input/output schemas are published via standard MCP
+`list_tools`; the client will show them when you connect.
+
+### Per-call controls
+
+The server starts with no per-session pin: every tool call must say
+which device it's for, and may optionally override the account or
+profile for that single call.
+
+- **`device`** — required for any device-scoped tool. Use
+  `thinr_devices` (optionally with `query` to filter by regex) to
+  discover ids.
+- **`user`** — optional admin impersonation; falls back to the
+  authenticated user of the active profile.
+- **`profile`** — optional. Switches the active profile for that
+  single tool call so an agent can hop between prod and staging
+  without restarting the server. List the configured profiles with
+  `thinr_profiles`.
+
+### Integrating with Claude Code
+
+Register the server once with the Claude Code CLI:
 
 ```bash
-npm install
-npm link
+claude mcp add thinr -s user -- thinr mcp
 ```
 
-### Testing
+That's it — a single MCP server entry handles every device of the
+active profile. Tool calls pass `device` (and optionally `user` /
+`profile`) per call.
+
+Other MCP hosts follow the same pattern — they just need the command
+`thinr mcp` (optionally with `-d <deviceId>`) over stdio.
+
+---
+
+## Profiles and multi-account use
+
+`~/.config/thinr-cli/config.json` stores any number of profiles:
+
+```json
+{
+    "default": "perf.aws.thinger.io",
+    "profiles": {
+        "perf.aws.thinger.io": { "server": "...", "username": "...", "token": "..." },
+        "staging.local": { "server": "...", "username": "...", "token": "..." }
+    }
+}
+```
+
+The active profile is picked, in order:
+
+1. `--profile <name>` flag on the command line.
+2. `THINR_PROFILE` environment variable.
+3. The `default` field in the config file.
+4. The sole profile, if there's only one.
+
+Logging in to a new server creates a new profile whose name is the
+server hostname (so it never clobbers an existing one). Legacy
+single-profile files from older versions of the CLI are detected on
+read and migrated in-memory without a manual step.
+
+Use `thinr profile use <name>` to change the persisted default, or
+`--profile <name>` / `THINR_PROFILE=<name>` for one-off runs.
+
+## Development
+
+```
+thinr-cli/
+├── bin/           # CLI entry point (thinr)
+├── commands/      # Commander subcommand modules
+├── lib/           # Core: api, auth, config, device-api, errors,
+│                  # output, mcp-server, proxy, console, …
+├── package.json
+└── README.md
+```
+
+Local development:
 
 ```bash
-npm test
+npm install
+npm link            # makes `thinr` available on $PATH
+node bin/thinr.js   # or run directly without linking
 ```
 
+There are no automated tests yet — contributions welcome.
+
 ## License
 
 <a href="http://opensource.org/">
   <img style="float: right;" width="100px" height="137px" src="https://opensource.org/wp-content/uploads/2009/06/OSI_Standard_Logo_0.svg">
 </a>
 
-The plugin is licensed under the [MIT License](http://opensource.org/licenses/MIT):
+Released under the [MIT License](http://opensource.org/licenses/MIT).
 
 Copyright &copy; [Thinger.io](http://thinger.io)
 
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.