agent-skill-manager 1.22.0 → 2.0.0

package/node_modules/ssh2/examples/sftp-server-download-only.js

@@ -1,134 +0,0 @@
-'use strict';
-
-const { timingSafeEqual } = require('crypto');
-const { constants, readFileSync } = require('fs');
-
-const { Server, sftp: { OPEN_MODE, STATUS_CODE } } = require('ssh2');
-
-const allowedUser = Buffer.from('foo');
-const allowedPassword = Buffer.from('bar');
-
-function checkValue(input, allowed) {
-  const autoReject = (input.length !== allowed.length);
-  if (autoReject) {
-    // Prevent leaking length information by always making a comparison with the
-    // same input when lengths don't match what we expect ...
-    allowed = input;
-  }
-  const isMatch = timingSafeEqual(input, allowed);
-  return (!autoReject && isMatch);
-}
-
-new Server({
-  hostKeys: [readFileSync('host.key')]
-}, (client) => {
-  console.log('Client connected!');
-
-  client.on('authentication', (ctx) => {
-    let allowed = true;
-    if (!checkValue(Buffer.from(ctx.username), allowedUser))
-      allowed = false;
-
-    switch (ctx.method) {
-      case 'password':
-        if (!checkValue(Buffer.from(ctx.password), allowedPassword))
-          return ctx.reject();
-        break;
-      default:
-        return ctx.reject();
-    }
-
-    if (allowed)
-      ctx.accept();
-    else
-      ctx.reject();
-  }).on('ready', () => {
-    console.log('Client authenticated!');
-
-    client.on('session', (accept, reject) => {
-      const session = accept();
-      session.on('sftp', (accept, reject) => {
-        console.log('Client SFTP session');
-
-        const openFiles = new Map();
-        let handleCount = 0;
-        const sftp = accept();
-        sftp.on('OPEN', (reqid, filename, flags, attrs) => {
-          // Only allow opening /tmp/foo.txt for writing
-          if (filename !== '/tmp/foo.txt' || !(flags & OPEN_MODE.READ))
-            return sftp.status(reqid, STATUS_CODE.FAILURE);
-
-          // Create a fake handle to return to the client, this could easily
-          // be a real file descriptor number for example if actually opening
-          // the file on the disk
-          const handle = Buffer.alloc(4);
-          openFiles.set(handleCount, { read: false });
-          handle.writeUInt32BE(handleCount++, 0, true);
-
-          console.log('Opening file for read');
-          sftp.handle(reqid, handle);
-        }).on('READ', (reqid, handle, offset, length) => {
-          let fnum;
-          if (handle.length !== 4
-              || !openFiles.has(fnum = handle.readUInt32BE(0, true))) {
-            return sftp.status(reqid, STATUS_CODE.FAILURE);
-          }
-
-          // Fake the read
-          const state = openFiles.get(fnum);
-          if (state.read) {
-            sftp.status(reqid, STATUS_CODE.EOF);
-          } else {
-            state.read = true;
-
-            console.log(
-              'Read from file at offset %d, length %d', offset, length
-            );
-            sftp.data(reqid, 'bar');
-          }
-        }).on('CLOSE', (reqid, handle) => {
-          let fnum;
-          if (handle.length !== 4
-              || !openFiles.has(fnum = handle.readUInt32BE(0))) {
-            return sftp.status(reqid, STATUS_CODE.FAILURE);
-          }
-
-          openFiles.delete(fnum);
-
-          console.log('Closing file');
-          sftp.status(reqid, STATUS_CODE.OK);
-        }).on('REALPATH', function(reqid, path) {
-          const name = [{
-            filename: '/tmp/foo.txt',
-            longname: '-rwxrwxrwx 1 foo foo 3 Dec 8 2009 foo.txt',
-            attrs: {}
-          }];
-          sftp.name(reqid, name);
-        }).on('STAT', onSTAT)
-          .on('LSTAT', onSTAT);
-
-        function onSTAT(reqid, path) {
-          if (path !== '/tmp/foo.txt')
-            return sftp.status(reqid, STATUS_CODE.FAILURE);
-
-          let mode = constants.S_IFREG; // Regular file
-          mode |= constants.S_IRWXU; // Read, write, execute for user
-          mode |= constants.S_IRWXG; // Read, write, execute for group
-          mode |= constants.S_IRWXO; // Read, write, execute for other
-          sftp.attrs(reqid, {
-            mode: mode,
-            uid: 0,
-            gid: 0,
-            size: 3,
-            atime: Date.now(),
-            mtime: Date.now(),
-          });
-        }
-      });
-    });
-  }).on('close', () => {
-    console.log('Client disconnected');
-  });
-}).listen(0, '127.0.0.1', function() {
-  console.log(`Listening on port ${this.address().port}`);
-});

package/node_modules/ssh2/install.js

@@ -1,27 +0,0 @@
-'use strict';
-
-const { spawnSync } = require('child_process');
-
-const forceFailOnNonZero = (process.env.CI_CHECK_FAIL === 'ssh2');
-
-// Attempt to build the bundled optional binding
-const args = [
-  `--target=${process.version}`,
-  `--real_openssl_major=${/^\d+/.exec(process.versions.openssl)[0]}`,
-  'rebuild',
-];
-const result = spawnSync('node-gyp', args, {
-  cwd: 'lib/protocol/crypto',
-  encoding: 'utf8',
-  shell: true,
-  stdio: 'inherit',
-  windowsHide: true,
-});
-if (result.error || result.status !== 0) {
-  console.log('Failed to build optional crypto binding');
-  if (forceFailOnNonZero)
-    process.exit(1);
-} else {
-  console.log('Succeeded in building optional crypto binding');
-}
-process.exit(0);

package/node_modules/ssh2/lib/Channel.js

@@ -1,295 +0,0 @@
-'use strict';
-
-const {
-  Duplex: DuplexStream,
-  Readable: ReadableStream,
-  Writable: WritableStream,
-} = require('stream');
-
-const {
-  CHANNEL_EXTENDED_DATATYPE: { STDERR },
-} = require('./protocol/constants.js');
-const { bufferSlice } = require('./protocol/utils.js');
-
-const PACKET_SIZE = 32 * 1024;
-const MAX_WINDOW = 2 * 1024 * 1024;
-const WINDOW_THRESHOLD = MAX_WINDOW / 2;
-
-class ClientStderr extends ReadableStream {
-  constructor(channel, streamOpts) {
-    super(streamOpts);
-
-    this._channel = channel;
-  }
-  _read(n) {
-    if (this._channel._waitChanDrain) {
-      this._channel._waitChanDrain = false;
-      if (this._channel.incoming.window <= WINDOW_THRESHOLD)
-        windowAdjust(this._channel);
-    }
-  }
-}
-
-class ServerStderr extends WritableStream {
-  constructor(channel) {
-    super({ highWaterMark: MAX_WINDOW });
-
-    this._channel = channel;
-  }
-
-  _write(data, encoding, cb) {
-    const channel = this._channel;
-    const protocol = channel._client._protocol;
-    const outgoing = channel.outgoing;
-    const packetSize = outgoing.packetSize;
-    const id = outgoing.id;
-    let window = outgoing.window;
-    const len = data.length;
-    let p = 0;
-
-    if (outgoing.state !== 'open')
-      return;
-
-    while (len - p > 0 && window > 0) {
-      let sliceLen = len - p;
-      if (sliceLen > window)
-        sliceLen = window;
-      if (sliceLen > packetSize)
-        sliceLen = packetSize;
-
-      if (p === 0 && sliceLen === len)
-        protocol.channelExtData(id, data, STDERR);
-      else
-        protocol.channelExtData(id, bufferSlice(data, p, p + sliceLen), STDERR);
-
-      p += sliceLen;
-      window -= sliceLen;
-    }
-
-    outgoing.window = window;
-
-    if (len - p > 0) {
-      if (window === 0)
-        channel._waitWindow = true;
-      if (p > 0)
-        channel._chunkErr = bufferSlice(data, p, len);
-      else
-        channel._chunkErr = data;
-      channel._chunkcbErr = cb;
-      return;
-    }
-
-    cb();
-  }
-}
-
-class Channel extends DuplexStream {
-  constructor(client, info, opts) {
-    const streamOpts = {
-      highWaterMark: MAX_WINDOW,
-      allowHalfOpen: (!opts || (opts && opts.allowHalfOpen !== false)),
-      emitClose: false,
-    };
-    super(streamOpts);
-    this.allowHalfOpen = streamOpts.allowHalfOpen;
-
-    const server = !!(opts && opts.server);
-
-    this.server = server;
-    this.type = info.type;
-    this.subtype = undefined;
-
-    /*
-      incoming and outgoing contain these properties:
-      {
-        id: undefined,
-        window: undefined,
-        packetSize: undefined,
-        state: 'closed'
-      }
-    */
-    this.incoming = info.incoming;
-    this.outgoing = info.outgoing;
-    this._callbacks = [];
-
-    this._client = client;
-    this._hasX11 = false;
-    this._exit = {
-      code: undefined,
-      signal: undefined,
-      dump: undefined,
-      desc: undefined,
-    };
-
-    this.stdin = this.stdout = this;
-
-    if (server)
-      this.stderr = new ServerStderr(this);
-    else
-      this.stderr = new ClientStderr(this, streamOpts);
-
-    // Outgoing data
-    this._waitWindow = false; // SSH-level backpressure
-
-    // Incoming data
-    this._waitChanDrain = false; // Channel Readable side backpressure
-
-    this._chunk = undefined;
-    this._chunkcb = undefined;
-    this._chunkErr = undefined;
-    this._chunkcbErr = undefined;
-
-    this.on('finish', onFinish)
-        .on('prefinish', onFinish); // For node v0.11+
-
-    this.on('end', onEnd).on('close', onEnd);
-  }
-
-  _read(n) {
-    if (this._waitChanDrain) {
-      this._waitChanDrain = false;
-      if (this.incoming.window <= WINDOW_THRESHOLD)
-        windowAdjust(this);
-    }
-  }
-
-  _write(data, encoding, cb) {
-    const protocol = this._client._protocol;
-    const outgoing = this.outgoing;
-    const packetSize = outgoing.packetSize;
-    const id = outgoing.id;
-    let window = outgoing.window;
-    const len = data.length;
-    let p = 0;
-
-    if (outgoing.state !== 'open')
-      return;
-
-    while (len - p > 0 && window > 0) {
-      let sliceLen = len - p;
-      if (sliceLen > window)
-        sliceLen = window;
-      if (sliceLen > packetSize)
-        sliceLen = packetSize;
-
-      if (p === 0 && sliceLen === len)
-        protocol.channelData(id, data);
-      else
-        protocol.channelData(id, bufferSlice(data, p, p + sliceLen));
-
-      p += sliceLen;
-      window -= sliceLen;
-    }
-
-    outgoing.window = window;
-
-    if (len - p > 0) {
-      if (window === 0)
-        this._waitWindow = true;
-      if (p > 0)
-        this._chunk = bufferSlice(data, p, len);
-      else
-        this._chunk = data;
-      this._chunkcb = cb;
-      return;
-    }
-
-    cb();
-  }
-
-  eof() {
-    if (this.outgoing.state === 'open') {
-      this.outgoing.state = 'eof';
-      this._client._protocol.channelEOF(this.outgoing.id);
-    }
-  }
-
-  close() {
-    if (this.outgoing.state === 'open' || this.outgoing.state === 'eof') {
-      this.outgoing.state = 'closing';
-      this._client._protocol.channelClose(this.outgoing.id);
-    }
-  }
-
-  destroy() {
-    this.end();
-    this.close();
-    return this;
-  }
-
-  // Session type-specific methods =============================================
-  setWindow(rows, cols, height, width) {
-    if (this.server)
-      throw new Error('Client-only method called in server mode');
-
-    if (this.type === 'session'
-        && (this.subtype === 'shell' || this.subtype === 'exec')
-        && this.writable
-        && this.outgoing.state === 'open') {
-      this._client._protocol.windowChange(this.outgoing.id,
-                                          rows,
-                                          cols,
-                                          height,
-                                          width);
-    }
-  }
-
-  signal(signalName) {
-    if (this.server)
-      throw new Error('Client-only method called in server mode');
-
-    if (this.type === 'session'
-        && this.writable
-        && this.outgoing.state === 'open') {
-      this._client._protocol.signal(this.outgoing.id, signalName);
-    }
-  }
-
-  exit(statusOrSignal, coreDumped, msg) {
-    if (!this.server)
-      throw new Error('Server-only method called in client mode');
-
-    if (this.type === 'session'
-        && this.writable
-        && this.outgoing.state === 'open') {
-      if (typeof statusOrSignal === 'number') {
-        this._client._protocol.exitStatus(this.outgoing.id, statusOrSignal);
-      } else {
-        this._client._protocol.exitSignal(this.outgoing.id,
-                                          statusOrSignal,
-                                          coreDumped,
-                                          msg);
-      }
-    }
-  }
-
-}
-
-function onFinish() {
-  this.eof();
-  if (this.server || !this.allowHalfOpen)
-    this.close();
-  this.writable = false;
-}
-
-function onEnd() {
-  this.readable = false;
-}
-
-function windowAdjust(self) {
-  if (self.outgoing.state === 'closed')
-    return;
-  const amt = MAX_WINDOW - self.incoming.window;
-  if (amt <= 0)
-    return;
-  self.incoming.window += amt;
-  self._client._protocol.channelWindowAdjust(self.outgoing.id, amt);
-}
-
-module.exports = {
-  Channel,
-  MAX_WINDOW,
-  PACKET_SIZE,
-  windowAdjust,
-  WINDOW_THRESHOLD,
-};