@venos-inc/venos 0.1.13 → 0.1.14

package/etc/mcp-server/node_modules/bare-stream/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/etc/mcp-server/node_modules/bare-stream/README.md

@@ -0,0 +1,354 @@
+# bare-stream
+
+Streaming data for JavaScript. The classic Node.js-style stream classes are backed by `streamx` (<https://github.com/mafintosh/streamx>) while a `node:stream/web`-compatible implementation of the WHATWG Streams Standard is also provided.
+
+```
+npm i bare-stream
+```
+
+## Usage
+
+```js
+const { Readable } = require('bare-stream')
+
+const stream = new Readable({
+  read(size) {
+    // Push data, then push `null` to signal the end
+    this.push('hello')
+    this.push('world')
+    this.push(null)
+  }
+})
+
+stream.on('data', (data) => console.log(data))
+```
+
+## API
+
+The classic stream classes and helpers are exported from `bare-stream` and follow the Node.js `stream` API. See <https://nodejs.org/api/stream.html> and <https://github.com/mafintosh/streamx> for the complete behavior; the additions and differences specific to this module are documented below.
+
+#### `const stream = new Readable([options])`
+
+A readable stream. Options include:
+
+```js
+options = {
+  eagerOpen: false,
+  highWaterMark: 16384,
+  encoding: null,
+  signal: null,
+  open(cb) {},
+  read(size) {},
+  predestroy() {},
+  destroy(err, cb) {}
+}
+```
+
+If `encoding` is set, emitted data is decoded to strings using that encoding. If `signal` is an `AbortSignal`, the stream is destroyed when the signal aborts.
+
+#### `stream.closed`
+
+`true` when the stream is no longer readable.
+
+#### `stream.errored`
+
+The error the stream was destroyed with, or `null`.
+
+#### `stream.push(data[, encoding])`
+
+Push `data` into the stream's internal buffer. If `data` is a string, it is encoded to a `Buffer` using `encoding`, defaulting to `'utf8'`. Push `null` to signal the end of the stream.
+
+#### `stream.unshift(data[, encoding])`
+
+Like `stream.push()` but prepends `data` to the internal buffer so it is read before any already buffered data.
+
+#### `Readable.from(data[, options])`
+
+Create a readable stream from `data`, which may be a value, an array of values, or an async iterable.
+
+#### `Readable.isBackpressured(stream)`
+
+#### `Readable.isPaused(stream)`
+
+#### `Readable.fromWeb(readableStream[, options])`
+
+Convert a web `ReadableStream` into a `Readable`. Options include:
+
+```js
+options = {
+  encoding: null,
+  signal: null
+}
+```
+
+#### `Readable.toWeb(readable[, options])`
+
+Convert a `Readable` into a web `ReadableStream`. Options include:
+
+```js
+options = {
+  strategy: null
+}
+```
+
+`strategy` is a custom queuing strategy passed through to the `ReadableStream` constructor.
+
+#### `const stream = new Writable([options])`
+
+A writable stream. Options include:
+
+```js
+options = {
+  eagerOpen: false,
+  signal: null,
+  open(cb) {},
+  write(data, encoding, cb) {},
+  writev(batch, cb) {},
+  final(cb) {},
+  predestroy() {},
+  destroy(err, cb) {}
+}
+```
+
+#### `stream.closed`
+
+`true` when the stream is no longer writable.
+
+#### `stream.errored`
+
+The error the stream was destroyed with, or `null`.
+
+#### `stream.write(data[, encoding][, cb])`
+
+Write `data` to the stream. If `data` is a string, it is encoded using `encoding`, defaulting to `'utf8'`. Returns `false` if the stream is backpressured. The optional `cb` is called once the write has drained.
+
+#### `stream.end([data][, encoding][, cb])`
+
+Signal that no more data will be written. If `data` is provided it is written first. The optional `cb` is called once the stream has finished.
+
+#### `Writable.isBackpressured(stream)`
+
+#### `Writable.drained(stream)`
+
+Returns a promise that resolves once the stream has drained.
+
+#### `Writable.fromWeb(writableStream[, options])`
+
+Convert a web `WritableStream` into a `Writable`. Options include:
+
+```js
+options = {
+  signal: null
+}
+```
+
+#### `Writable.toWeb(writable)`
+
+Convert a `Writable` into a web `WritableStream`.
+
+#### `const stream = new Duplex([options])`
+
+A stream that is both readable and writable. Accepts the combined options of `Readable` and `Writable`.
+
+#### `Duplex.fromWeb({ readable, writable }[, options])`
+
+Convert a pair of web `ReadableStream` and `WritableStream` into a `Duplex`.
+
+#### `Duplex.toWeb(duplex)`
+
+Convert a `Duplex` into a `{ readable, writable }` pair of web streams.
+
+#### `const stream = new Transform([options])`
+
+A duplex stream where output is computed from input. Options include the `Duplex` options plus:
+
+```js
+options = {
+  transform(data, encoding, cb) {},
+  flush(cb) {}
+}
+```
+
+If no `transform` is provided, the stream acts as a pass-through.
+
+#### `const stream = new PassThrough([options])`
+
+A `Transform` that forwards input to output unchanged.
+
+#### `const [a, b] = duplexPair([options])`
+
+Create a pair of linked `Duplex` streams. Data written to `a` is readable from `b` and vice versa. `options` are passed to each side.
+
+#### `stream.pipeline(streams[, cb])`
+
+#### `stream.pipeline(...streams[, cb])`
+
+Pipe a series of streams together, propagating errors and cleaning up on completion. `streams` is a `Readable` source, zero or more `Duplex` transforms, and a `Writable` destination. Returns the destination stream. `cb` is called when the pipeline finishes or errors.
+
+#### `const detach = stream.finished(stream[, options], cb)`
+
+Invoke `cb` once `stream` is no longer readable or writable, or has errored. Returns a function that detaches the listeners. Options include:
+
+```js
+options = {
+  cleanup: false
+}
+```
+
+When `cleanup` is `true`, the listeners are detached automatically once `cb` runs.
+
+#### `stream.addAbortSignal(signal, stream)`
+
+Destroy `stream` when `signal` aborts, using `signal.reason` as the destruction error. Returns `stream`.
+
+#### `stream.isStream(stream)`
+
+#### `stream.isEnding(stream)`
+
+#### `stream.isEnded(stream)`
+
+#### `stream.isFinishing(stream)`
+
+#### `stream.isFinished(stream)`
+
+#### `stream.isDisturbed(stream)`
+
+#### `stream.isErrored(stream)`
+
+#### `stream.isReadable(stream)`
+
+#### `stream.isWritable(stream)`
+
+State predicates for streams. Each returns a boolean.
+
+#### `const err = stream.getStreamError(stream[, options])`
+
+Return the error a stream was destroyed with, or `null`. Options include:
+
+```js
+options = {
+  all: false
+}
+```
+
+### Promises
+
+A promise-based variant of `pipeline` is available from `bare-stream/promises`.
+
+#### `const stream = await pipeline(streams)`
+
+#### `const stream = await pipeline(...streams)`
+
+Like `stream.pipeline()` but returns a promise that resolves with the destination stream once the pipeline finishes, or rejects on error.
+
+### Web
+
+A `node:stream/web`-compatible implementation of the WHATWG Streams Standard is available from `bare-stream/web`. See <https://streams.spec.whatwg.org> for the complete behavior.
+
+#### `const stream = new ReadableStream([underlyingSource][, queuingStrategy])`
+
+A web readable stream. `underlyingSource` may provide `start`, `pull`, and `cancel` methods, or be an existing `streamx` stream to wrap. `queuingStrategy` defaults to a `CountQueuingStrategy`.
+
+#### `stream.locked`
+
+#### `stream.getReader()`
+
+Acquire a `ReadableStreamDefaultReader`. Throws if the stream is already locked.
+
+#### `stream.cancel([reason])`
+
+#### `stream.tee()`
+
+Split the stream into two independent `ReadableStream` branches.
+
+#### `stream.pipeTo(destination)`
+
+Pipe the stream to a `WritableStream`, returning a promise that resolves once piping completes.
+
+#### `ReadableStream.from(iterable)`
+
+Create a `ReadableStream` from an iterable or async iterable.
+
+#### `const reader = new ReadableStreamDefaultReader(stream)`
+
+A reader over a `ReadableStream`, exposing `closed`, `read()`, `releaseLock()`, and `cancel([reason])`.
+
+#### `const controller = new ReadableStreamDefaultController(stream)`
+
+The controller passed to `start` and `pull`, exposing `desiredSize`, `enqueue(data)`, `close()`, and `error([err])`.
+
+#### `const stream = new WritableStream([underlyingSink][, queuingStrategy])`
+
+A web writable stream. `underlyingSink` may provide `start`, `write`, `close`, and `abort` methods, or be an existing `streamx` stream to wrap.
+
+#### `stream.locked`
+
+#### `stream.getWriter()`
+
+Acquire a `WritableStreamDefaultWriter`. Throws if the stream is already locked.
+
+#### `stream.abort([reason])`
+
+#### `stream.close()`
+
+#### `const writer = new WritableStreamDefaultWriter(stream)`
+
+A writer over a `WritableStream`, exposing `desiredSize`, `closed`, `ready`, `write(chunk)`, `releaseLock()`, `close()`, and `abort([reason])`.
+
+#### `const controller = new WritableStreamDefaultController(stream)`
+
+The controller passed to `start` and `write`, exposing `error([err])`.
+
+#### `const stream = new TransformStream([transformer][, writableStrategy][, readableStrategy])`
+
+A web transform stream. `transformer` may provide `start`, `transform`, and `flush` methods. Exposes `readable` and `writable` properties.
+
+#### `const controller = new TransformStreamDefaultController(stream)`
+
+The controller passed to `start`, `transform`, and `flush`, exposing `desiredSize`, `enqueue(data)`, `error([err])`, and `terminate()`.
+
+#### `const strategy = new CountQueuingStrategy([options])`
+
+A queuing strategy that counts each chunk as size `1`. Options include:
+
+```js
+options = {
+  highWaterMark: 1
+}
+```
+
+#### `const strategy = new ByteLengthQueuingStrategy([options])`
+
+A queuing strategy that measures each chunk by its `byteLength`. Options include:
+
+```js
+options = {
+  highWaterMark: 16384
+}
+```
+
+#### `isReadableStream(value)`
+
+#### `isReadableStreamErrored(stream)`
+
+#### `isReadableStreamDisturbed(stream)`
+
+#### `isWritableStream(value)`
+
+#### `isTransformStream(value)`
+
+Predicates for web streams. Each returns a boolean.
+
+### Global
+
+Requiring `bare-stream/global` installs the web stream classes as globals, matching the browser and Node.js environments:
+
+```js
+require('bare-stream/global')
+
+const stream = new ReadableStream()
+```
+
+## License
+
+Apache-2.0

package/etc/mcp-server/node_modules/bare-stream/global.d.ts

@@ -0,0 +1,31 @@
+import * as web from './web'
+
+declare global {
+  type ReadableStream = web.ReadableStream
+  type ReadableStreamDefaultController = web.ReadableStreamDefaultController
+  type ReadableStreamDefaultReader = web.ReadableStreamDefaultReader
+
+  type CountQueuingStrategy = web.CountQueuingStrategy
+  type ByteLengthQueuingStrategy = web.ByteLengthQueuingStrategy
+
+  type WritableStream = web.WritableStream
+  type WritableStreamDefaultController = web.WritableStreamDefaultController
+  type WritableStreamDefaultWriter = web.WritableStreamDefaultWriter
+
+  type TransformStream = web.TransformStream
+  type TransformStreamDefaultController = web.TransformStreamDefaultController
+
+  const ReadableStream: typeof web.ReadableStream
+  const ReadableStreamDefaultController: typeof web.ReadableStreamDefaultController
+  const ReadableStreamDefaultReader: typeof web.ReadableStreamDefaultReader
+
+  const CountQueuingStrategy: typeof web.CountQueuingStrategy
+  const ByteLengthQueuingStrategy: typeof web.ByteLengthQueuingStrategy
+
+  const WritableStream: typeof web.WritableStream
+  const WritableStreamDefaultController: typeof web.WritableStreamDefaultController
+  const WritableStreamDefaultWriter: typeof web.WritableStreamDefaultWriter
+
+  const TransformStream: typeof web.TransformStream
+  const TransformStreamDefaultController: typeof web.TransformStreamDefaultController
+}

package/etc/mcp-server/node_modules/bare-stream/global.js

@@ -0,0 +1,15 @@
+const stream = require('./web')
+
+global.ReadableStream = stream.ReadableStream
+global.ReadableStreamDefaultController = stream.ReadableStreamDefaultController
+global.ReadableStreamDefaultReader = stream.ReadableStreamDefaultReader
+
+global.CountQueuingStrategy = stream.CountQueuingStrategy
+global.ByteLengthQueuingStrategy = stream.ByteLengthQueuingStrategy
+
+global.WritableStream = stream.WritableStream
+global.WritableStreamDefaultController = stream.WritableStreamDefaultController
+global.WritableStreamDefaultWriter = stream.WritableStreamDefaultWriter
+
+global.TransformStream = stream.TransformStream
+global.TransformStreamDefaultController = stream.TransformStreamDefaultController