agent-skill-manager 1.22.0 → 2.1.0

package/node_modules/ssh2/util/pagent.c

@@ -1,88 +0,0 @@
-#include <windows.h>
-#include <stdio.h>
-#include <fcntl.h>
-
-#define AGENT_COPYDATA_ID 0x804e50ba
-#define AGENT_MAX_MSGLEN  8192
-
-#define GET_32BIT_MSB_FIRST(cp) \
-  (((unsigned long)(unsigned char)(cp)[0] << 24) | \
-  ((unsigned long)(unsigned char)(cp)[1] << 16) | \
-  ((unsigned long)(unsigned char)(cp)[2] << 8) | \
-  ((unsigned long)(unsigned char)(cp)[3]))
-
-#define GET_32BIT(cp) GET_32BIT_MSB_FIRST(cp)
-
-#define RET_ERR_BADARGS 10
-#define RET_ERR_UNAVAILABLE 11
-#define RET_ERR_NOMAP 12
-#define RET_ERR_BINSTDIN 13
-#define RET_ERR_BINSTDOUT 14
-#define RET_ERR_BADLEN 15
-
-#define RET_NORESPONSE 1
-#define RET_RESPONSE 0
-
-int main (int argc, const char* argv[]) {
-  HWND hwnd;
-  char *mapname;
-  HANDLE filemap;
-  unsigned char *p, *ret;
-  int id, retlen, inlen, n, rmode, r = RET_NORESPONSE;
-  COPYDATASTRUCT cds;
-  void *in;
-
-  if (argc < 2)
-    return RET_ERR_BADARGS;
-
-  hwnd = FindWindow("Pageant", "Pageant");
-  if (!hwnd)
-    return RET_ERR_UNAVAILABLE;
-
-  rmode = _setmode(_fileno(stdin), _O_BINARY);
-  if (rmode == -1)
-    return RET_ERR_BINSTDIN;
-
-  rmode = _setmode(_fileno(stdout), _O_BINARY);
-  if (rmode == -1)
-    return RET_ERR_BINSTDOUT;
-
-  inlen = atoi(argv[1]);
-  in = malloc(inlen);
-  n = fread(in, 1, inlen, stdin);
-  if (n != inlen) {
-    free(in);
-    return RET_ERR_BADLEN;
-  }
-
-  mapname = malloc(32);
-  n = sprintf(mapname, "PageantRequest%08x", (unsigned)GetCurrentThreadId());
-
-  filemap = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE,
-                              0, AGENT_MAX_MSGLEN, mapname);
-  if (filemap == NULL || filemap == INVALID_HANDLE_VALUE) {
-    free(in);
-    free(mapname);
-    return RET_ERR_NOMAP;
-  }
-
-  p = MapViewOfFile(filemap, FILE_MAP_WRITE, 0, 0, 0);
-  memcpy(p, in, inlen);
-  cds.dwData = AGENT_COPYDATA_ID;
-  cds.cbData = 1 + n;
-  cds.lpData = mapname;
-
-  id = SendMessage(hwnd, WM_COPYDATA, (WPARAM) NULL, (LPARAM) &cds);
-  if (id > 0) {
-    r = RET_RESPONSE;
-    retlen = 4 + GET_32BIT(p);
-    fwrite(p, 1, retlen, stdout);
-  }
-
-  free(in);
-  free(mapname);
-  UnmapViewOfFile(p);
-  CloseHandle(filemap);
-
-  return r;
-}

package/node_modules/streamx/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2019 Mathias Buus
-
-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.

package/node_modules/streamx/README.md

@@ -1,490 +0,0 @@
-# streamx
-
-An iteration of the Node.js core streams with a series of improvements.
-
-```
-npm install streamx
-```
-
-[![Build Status](https://github.com/streamxorg/streamx/workflows/Build%20Status/badge.svg)](https://github.com/streamxorg/streamx/actions?query=workflow%3A%22Build+Status%22)
-
-## Main improvements from Node.js core stream
-
-#### Proper lifecycle support.
-
-Streams have an `_open` function that is called before any read/write operation and a `_destroy`
-function that is always run as the last part of the stream.
-
-This makes it easy to maintain state.
-
-#### Easy error handling
-
-Fully integrates a `.destroy()` function. When called the stream will wait for any
-pending operation to finish and call the stream destroy logic.
-
-Close is _always_ the last event emitted and `destroy` is always run.
-
-#### `pipe()` error handles
-
-`pipe` accepts a callback that is called when the pipeline is fully drained.
-It also error handles the streams provided and destroys both streams if either
-of them fail.
-
-#### All streams are both binary and object mode streams
-
-A `map` function can be provided to map your input data into buffers
-or other formats. To indicate how much buffer space each data item takes
-an `byteLength` function can be provided as well.
-
-This removes the need for two modes of streams.
-
-#### Simplicity
-
-This is a full rewrite, all contained in one file.
-
-Lots of stream methods are simplified based on how I and devs I work with actually use streams in the wild.
-
-#### Backwards compat
-
-streamx aims to be compatible with Node.js streams whenever it is reasonable to do so.
-
-This means that streamx streams behave a lot like Node.js streams from the outside but still provides the
-improvements above.
-
-#### Smaller browser footprint
-
-streamx has a much smaller footprint when compiled for the browser:
-
-```
-$ for x in stream{,x}; do echo $x: $(browserify -r $x | wc -c) bytes; done
-stream: 173844 bytes
-streamx: 46943 bytes
-```
-
-With optimizations turned on, the difference is even more stark:
-
-```
-$ for x in stream{,x}; do echo $x: $(browserify -r $x -p tinyify | wc -c) bytes; done
-stream: 62649 bytes
-streamx: 8460 bytes
-$ for x in stream{,x}; do echo $x: $(browserify -r $x -p tinyify | gzip | wc -c) "bytes (gzipped)"; done
-stream: 18053 bytes (gzipped)
-streamx: 2806 bytes (gzipped)
-```
-
-#### AbortSignal support
-
-To make it easier to integrate streams in a `async/await` flow, all streams support a `signal` option
-that accepts a [`AbortSignal`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal) to as an
-alternative means to `.destroy` streams.
-
-## Usage
-
-```js
-const { Readable } = require('streamx')
-
-const rs = new Readable({
-  read(cb) {
-    this.push('Cool data')
-    cb(null)
-  }
-})
-
-rs.on('data', (data) => console.log('data:', data))
-```
-
-## API
-
-This streamx package contains 4 streams similar to Node.js core.
-
-## Readable Stream
-
-#### `rs = new stream.Readable([options])`
-
-Create a new readable stream.
-
-Options include:
-
-```
-{
-  highWaterMark: 16384, // max buffer size in bytes
-  map: (data) => data, // optional function to map input data
-  byteLength: (data) => size, // optional function that calculates the byte size of input data
-  signal: abortController.signal, // optional AbortSignal that triggers `.destroy` when on `abort`
-  eagerOpen: false // eagerly open the stream
-}
-```
-
-In addition you can pass the `open`, `read`, and `destroy` functions as shorthands in
-the constructor instead of overwrite the methods below.
-
-The default byteLength function returns the byte length of buffers and `1024`
-for any other object. This means the buffer will contain around 16 non buffers
-or buffers worth 16kb when full if the defaults are used.
-
-If you set highWaterMark to `0` then all read ahead buffering on the stream
-is disabled and it will only call `_read` when a user reads rather than ahead of time.
-
-#### `rs._read(cb)`
-
-This function is called when the stream wants you to push new data.
-Overwrite this and add your own read logic.
-You should call the callback when you are fully done with the read.
-
-Can also be set using `options.read` in the constructor.
-
-Note that this function differs from Node.js streams in that it takes
-the "read finished" callback.
-
-#### `drained = rs.push(data)`
-
-Push new data to the stream. Returns true if the buffer is not full
-and you should push more data if you can.
-
-If you call `rs.push(null)` you signal to the stream that no more
-data will be pushed and that you want to end the stream.
-
-#### `data = rs.read()`
-
-Read a piece of data from the stream buffer. If the buffer is currently empty
-`null` will be returned and you should wait for `readable` to be emitted before
-trying again. If the stream has been ended it will also return `null`.
-
-Note that this method differs from Node.js streams in that it does not accept
-an optional amounts of bytes to consume.
-
-#### `rs.unshift(data)`
-
-Add a piece of data to the front of the buffer. Use this if you read too much
-data using the `rs.read()` function.
-
-#### `rs._open(cb)`
-
-This function is called once before the first read is issued. Use this function
-to implement your own open logic.
-
-Can also be set using `options.open` in the constructor.
-
-#### `rs._destroy(cb)`
-
-This function is called just before the stream is fully destroyed. You should
-use this to implement whatever teardown logic you need. The final part of the
-stream life cycle is always to call destroy itself so this function will always
-be called wheather or not the stream ends gracefully or forcefully.
-
-Can also be set using `options.destroy` in the constructor.
-
-Note that the `_destroy` might be called without the open function being called
-in case no read was ever performed on the stream.
-
-#### `rs._predestroy()`
-
-A simple hook that is called as soon as the first `stream.destroy()` call is invoked.
-
-Use this in case you need to cancel pending reads (if possible) instead of waiting for them to finish.
-
-Can also be set using `options.predestroy` in the constructor.
-
-#### `rs.destroy([error])`
-
-Forcefully destroy the stream. Will call `_destroy` as soon as all pending reads have finished.
-Once the stream is fully destroyed `close` will be emitted.
-
-If you pass an error this error will be emitted just before `close` is, signifying a reason
-as to why this stream was destroyed.
-
-#### `rs.pause()`
-
-Pauses the stream. You will only need to call this if you want to pause a resumed stream.
-
-Returns this stream instance.
-
-#### `rs.resume()`
-
-Will start reading data from the stream as fast as possible.
-
-If you do not call this, you need to use the `read()` method to read data or the `pipe()` method to
-pipe the stream somewhere else or the `data` handler.
-
-If none of these option are used the stream will stay paused.
-
-Returns this stream instance.
-
-#### `bool = Readable.isPaused(rs)`
-
-Returns `true` if the stream is paused, else `false`.
-
-#### `writableStream = rs.pipe(writableStream, [callback])`
-
-Efficently pipe the readable stream to a writable stream (can be Node.js core stream or a stream from this package).
-If you provide a callback the callback is called when the pipeline has fully finished with an optional error in case
-it failed.
-
-To cancel the pipeline destroy either of the streams.
-
-#### `rs.on('readable')`
-
-Emitted when data is pushed to the stream if the buffer was previously empty.
-
-#### `rs.on('data', data)`
-
-Emitted when data is being read from the stream. If you attach a data handler you are implicitly resuming the stream.
-
-#### `rs.on('end')`
-
-Emitted when the readable stream has ended and no data is left in it's buffer.
-
-#### `rs.on('close')`
-
-Emitted when the readable stream has fully closed (i.e. it's destroy function has completed)
-
-#### `rs.on('error', err)`
-
-Emitted if any of the stream operations fail with an error. `close` is always emitted right after this.
-
-#### `rs.on('piping', dest)`
-
-Emitted when the readable stream is pipeing to a destination.
-
-#### `rs.destroyed`
-
-Boolean property indicating wheather or not this stream has been destroyed.
-
-#### `bool = Readable.isBackpressured(rs)`
-
-Static method to check if a readable stream is currently under backpressure.
-
-#### `stream = Readable.from(arrayOrBufferOrStringOrAsyncIterator)`
-
-Static method to turn an array or buffer or string or AsyncIterator into a readable stream.
-
-## Writable Stream
-
-#### `ws = new stream.Writable([options])`
-
-Create a new writable stream.
-
-Options include:
-
-```
-{
-  highWaterMark: 16384, // max buffer size in bytes
-  map: (data) => data, // optional function to map input data
-  byteLength: (data) => size, // optional function that calculates the byte size of input data
-  signal: abortController.signal // optional AbortSignal that triggers `.destroy` when on `abort`
-}
-```
-
-In addition you can pass the `open`, `write`, `final`, and `destroy` functions as shorthands in
-the constructor instead of overwrite the methods below.
-
-The default byteLength function returns the byte length of buffers and `1024`
-for any other object. This means the buffer will contain around 16 non buffers
-or buffers worth 16kb when full if the defaults are used.
-
-#### `ws._open(cb)`
-
-This function is called once before the first write is issued. Use this function
-to implement your own open logic.
-
-Can also be set using `options.open` in the constructor.
-
-#### `ws._destroy(cb)`
-
-This function is called just before the stream is fully destroyed. You should
-use this to implement whatever teardown logic you need. The final part of the
-stream life cycle is always to call destroy itself so this function will always
-be called wheather or not the stream ends gracefully or forcefully.
-
-Can also be set using `options.destroy` in the constructor.
-
-Note that the `_destroy` might be called without the open function being called
-in case no write was ever performed on the stream.
-
-#### `ws._predestroy()`
-
-A simple hook that is called as soon as the first `stream.destroy()` call is invoked.
-
-Use this in case you need to cancel pending writes (if possible) instead of waiting for them to finish.
-
-Can also be set using `options.predestroy` in the constructor.
-
-#### `ws.destroy([error])`
-
-Forcefully destroy the stream. Will call `_destroy` as soon as all pending reads have finished.
-Once the stream is fully destroyed `close` will be emitted.
-
-If you pass an error this error will be emitted just before `close` is, signifying a reason
-as to why this stream was destroyed.
-
-#### `drained = ws.write(data)`
-
-Write a piece of data to the stream. Returns `true` if the stream buffer is not full and you
-should keep writing to it if you can. If `false` is returned the stream will emit `drain`
-once it's buffer is fully drained.
-
-#### `ws._write(data, callback)`
-
-This function is called when the stream want to write some data. Use this to implement your own
-write logic. When done call the callback and the stream will call it again if more data exists in the buffer.
-
-Can also be set using `options.write` in the constructor.
-
-#### `ws._writev(batch, callback)`
-
-Similar to `_write` but passes an array of all data in the current write buffer instead of the oldest one.
-Useful if the destination you are writing the data to supports batching.
-
-Can also be set using `options.writev` in the constructor.
-
-#### `ws.end()`
-
-Gracefully end the writable stream. Call this when you no longer want to write to the stream.
-
-Once all writes have been fully drained `finish` will be emitted.
-
-Returns this stream instance.
-
-#### `ws._final(callback)`
-
-This function is called just before `finish` is emitted, i.e. when all writes have flushed but `ws.end()`
-have been called. Use this to implement any logic that should happen after all writes but before finish.
-
-Can also be set using `options.final` in the constructor.
-
-#### `ws.on('finish')`
-
-Emitted when the stream has been ended and all writes have been drained.
-
-#### `ws.on('close')`
-
-Emitted when the readable stream has fully closed (i.e. it's destroy function has completed)
-
-#### `ws.on('error', err)`
-
-Emitted if any of the stream operations fail with an error. `close` is always emitted right after this.
-
-#### `ws.on('pipe', src)`
-
-Emitted when a readable stream is being piped to the writable one.
-
-#### `ws.destroyed`
-
-Boolean property indicating wheather or not this stream has been destroyed.
-
-#### `bool = Writable.isBackpressured(ws)`
-
-Static method to check if a writable stream is currently under backpressure.
-
-#### `bool = await Writable.drained(ws)`
-
-Static helper to wait for a stream to drain the currently queued writes.
-Returns true if they were drained and false otherwise if the stream was destroyed.
-
-## Duplex Stream
-
-#### `s = new stream.Duplex([options])`
-
-A duplex stream is a stream that is both readable and writable.
-
-Since JS does not support multiple inheritance it inherits directly from Readable
-but implements the Writable API as well.
-
-If you want to provide only a map function for the readable side use `mapReadable` instead.
-If you want to provide only a byteLength function for the readable side use `byteLengthReadable` instead.
-
-Same goes for the writable side but using `mapWritable` and `byteLengthWritable` instead.
-
-## Transform Stream
-
-A Transform stream is a duplex stream with an `._transform` template method that allows to
-asynchronously map the input to a different output.
-
-The transform stream overrides the `_write` and `_read` operations of `Readable` and `Writable` but
-still allows the setting of these options in the constructor. Usually it is unnecessary to pass
-in `read` or `write`/`writev` or to override the corresponding `._read`, `._write` or `._writev` operation.
-
-#### `ts = new stream.Transform([options])`
-
-A transform stream is a duplex stream that maps the data written to it and emits that as readable data.
-
-Has the same options as a duplex stream except you can provide a `transform` function also.
-
-#### `ts._transform(data, callback)`
-
-Transform the incoming data. Call `callback(null, mappedData)` or use `ts.push(mappedData)` to
-return data to the readable side of the stream.
-
-Per default the transform function just remits the incoming data making it act as a pass-through stream.
-
-## Pipeline
-
-`pipeline` allows to stream form a readable through a set of duplex streams to a writable entry.
-
-```js
-const { pipeline, Readable, Transform, Writable } = require('streamx')
-const lastStream = pipeline(
-  Readable.from([1, 2, 3]),
-  new Transform({
-    transform (from, cb) {
-      this.push(from.toString())
-      cb()
-    }
-  }),
-  new Writable({
-    write (data, cb) {
-      console.log(data)
-      cb()
-    }
-  })
-  error => {
-    // Callback once write has finished
-  }
-)
-```
-
-#### `lastStream = stream.pipeline(...streams, [done])`
-
-Pipe all streams together and return the last stream piped to.
-When the last stream finishes the pipeline ended succesfully.
-
-If any of the streams error, whether they are Node.js core streams
-or streamx streams, all streams in the pipeline are shutdown.
-
-Optionally you can pass a done callback to know when the pipeline is done.
-
-#### `promise = stream.pipelinePromise(...streams)`
-
-Same as normal pipeline except instead of returning the last stream it returns
-a promise representing the done callback. Note you should error handle this
-promise if you use this version.
-
-## Helpers
-
-#### `bool = isStream(stream)`
-
-#### `bool = isStreamx(stream)`
-
-#### `err = getStreamError(stream, [options])`
-
-Returns `null` if the stream has no errors.
-
-## Utilities
-
-Streamx aims to be minimal and stable. It therefore only contains a minimal set of utilities.
-To help discover of other modules that help you build streamx apps, we link some useful utilities here
-
-- [stream-composer](https://github.com/mafintosh/stream-composer) - Compose streams like Node's `stream.compose` and the `duplexify` and `pumpify` modules.
-- [teex](https://github.com/mafintosh/teex) - Clone a readable stream into multiple new readable instances.
-- [merge-readable](https://github.com/holepunchto/merge-readable) - Merge multiple readers into a new readable with optional mapping of data
-
-## Contributing
-
-If you want to help contribute to streamx a good way to start is to help writing more test
-cases, compatibility tests, documentation, or performance benchmarks.
-
-If in doubt open an issue :)
-
-## License
-
-MIT