bdy 1.7.60-dev → 1.8.3-dev

package/src/agent/osx.js

@@ -1,150 +0,0 @@
-const AgentSystem = require('./system');
-const { exec } = require('child_process');
-const path = require('path');
-const logger = require('../logger');
-const { LOG_AGENT_SYSTEM_DIR,
-  LOG_AGENT_DOWNLOADING_ARCHIVE,
-  LOG_AGENT_EXTRACTING_ARCHIVE,
-  LOG_AGENT_SYSTEM_SERVICE_CONFIG,
-  LOG_AGENT_ENABLING_SYSTEM,
-  LOG_AGENT_ENABLED,
-  LOG_AGENT_STOPPING_SYSTEM,
-  LOG_AGENT_STARTING_SYSTEM
-} = require('../texts');
-
-class AgentOsx extends AgentSystem {
-
-  hasAdminRights() {
-    return new Promise((resolve) => {
-      resolve(process.getuid() === 0);
-    });
-  }
-
-  isSupported() {
-    // cant check for process.arch because of rosetta (process.arch returns x64 for m1)
-    return Promise.resolve(true);
-  }
-
-  isEnabled() {
-    return new Promise((resolve) => {
-      this.launchCtl('print system/bdy | grep domain').then((str) => {
-        resolve(!!str && !!str.match(/domain\s=\ssystem/i));
-      }).catch(() => {
-        resolve(false);
-      });
-    });
-  }
-
-  getBinaryArchive() {
-    return 'darwin-arm64.tar.gz';
-  }
-
-  getSystemConfigDir() {
-    return '/Library/Application Support/bdy';
-  }
-
-  getSystemConfigPath() {
-    return path.join(this.getSystemConfigDir(), 'agent.json');
-  }
-
-  getServicePath() {
-    return '/Library/LaunchDaemons/bdy.plist';
-  }
-
-  getServiceConfig(id, host, token, port, start, user, debug) {
-    const cli = this.getSystemBinaryPath();
-    let cfg = `<?xml version='1.0' encoding='UTF-8'?>
-<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version='1.0'>
-  <dict>
-    <key>Label</key>
-    <string>bdy</string>
-    <key>ProgramArguments</key>
-    <array>
-      <string>${cli}</string>
-      <string>agent</string>
-      <string>run</string>
-      <string>--id</string>
-      <string>${id}</string>
-      <string>--host</string>
-      <string>${host}</string>
-      <string>--token</string>
-      <string>${token}</string>
-      <string>--port</string>
-      <string>${port}</string>
-      <string>--start</string>
-      <string>${!!start}</string>
-    </array>
-    <key>EnvironmentVariables</key>
-    <dict>
-        <key>DEBUG</key>
-        <string>${debug ? 1 : 0}</string>
-    </dict>
-    <key>KeepAlive</key>
-    <true/>
-    <key>RunAtLoad</key>
-    <true/>`;
-    if (user) {
-      cfg += `
-    <key>UserName</key>
-    <string>${user}</string>`;
-    }
-    cfg += `
-  </dict>
-</plist>`;
-    return cfg;
-  }
-
-  async enable(id, host, token, port, start, user, pass, debug) {
-    try {
-      logger.info(LOG_AGENT_SYSTEM_DIR);
-      await this.ensureSystemConfigDir();
-      logger.info(LOG_AGENT_DOWNLOADING_ARCHIVE);
-      await this.downloadBinaryArchive();
-      logger.info(LOG_AGENT_EXTRACTING_ARCHIVE);
-      await this.extractBinaryArchive();
-      logger.info(LOG_AGENT_SYSTEM_SERVICE_CONFIG);
-      await this.saveFile(this.getServicePath(), this.getServiceConfig(id, host, token, port, start, user, debug));
-      logger.info(LOG_AGENT_ENABLING_SYSTEM);
-      await this.launchCtl(`bootstrap system ${this.getServicePath()}`);
-      logger.info(LOG_AGENT_ENABLED);
-    } catch (err) {
-      logger.info(err);
-      throw err;
-    }
-  }
-
-  async update() {
-    try {
-      logger.info(LOG_AGENT_STOPPING_SYSTEM);
-      await this.launchCtl('bootout system/bdy');
-      logger.info(LOG_AGENT_SYSTEM_DIR);
-      await this.ensureSystemConfigDir();
-      logger.info(LOG_AGENT_DOWNLOADING_ARCHIVE);
-      await this.downloadBinaryArchive();
-      logger.info(LOG_AGENT_EXTRACTING_ARCHIVE);
-      await this.extractBinaryArchive();
-      logger.info(LOG_AGENT_STARTING_SYSTEM);
-      await this.launchCtl(`bootstrap system ${this.getServicePath()}`);
-      logger.info(LOG_AGENT_ENABLED);
-    } catch (err) {
-      logger.error(err);
-      throw err;
-    }
-  }
-
-  disable() {
-    return this.launchCtl('bootout system/bdy');
-  }
-
-  launchCtl(cmd) {
-    return new Promise((resolve, reject) => {
-      exec(`launchctl ${cmd}`, (err, stdout, stderr) => {
-        if (!err) resolve(stdout, stderr);
-        else reject(err, stderr);
-      });
-    });
-  }
-}
-
-module.exports = AgentOsx;

package/src/agent/socket/tunnel.js

@@ -1,232 +0,0 @@
-const { ERR_TUNNEL_NOT_FOUND } = require('../../texts.js');
-const EventEmitter = require('events');
-const {
-  AGENT_SOCKET_MESSAGE_READY,
-  AGENT_SOCKET_MESSAGE_TUNNEL,
-  AGENT_SOCKET_MESSAGE_TUNNEL_STOPPED,
-  AGENT_SOCKET_MESSAGE_TUNNEL_OPEN,
-  AGENT_SOCKET_MESSAGE_TUNNEL_CLOSED,
-  AGENT_SOCKET_MESSAGE_TUNNEL_TCP_OPEN,
-  AGENT_SOCKET_MESSAGE_TUNNEL_TCP_CLOSED,
-  AGENT_SOCKET_MESSAGE_TUNNEL_TLS_OPEN,
-  AGENT_SOCKET_MESSAGE_TUNNEL_TLS_CLOSED,
-  AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_IDENTIFIED,
-  AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_REQUESTS,
-  AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_REQUEST,
-  AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_RESPONSE,
-  AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_RETRY,
-  TUNNEL_HTTP_LOG_MAX_REQUESTS,
-  TUNNEL_EVENT_OPEN,
-  TUNNEL_EVENT_CLOSED,
-  TUNNEL_EVENT_TCP_OPEN,
-  TUNNEL_EVENT_TCP_CLOSED,
-  TUNNEL_EVENT_TLS_OPEN,
-  TUNNEL_EVENT_TLS_CLOSED,
-  TUNNEL_EVENT_HTTP_IDENTIFIED,
-  TUNNEL_EVENT_HTTP_REQUEST,
-  TUNNEL_EVENT_HTTP_RESPONSE,
-  TUNNEL_EVENT_STOPPED
-} = require('../../utils');
-
-class AgentSocketTunnel extends EventEmitter {
-  constructor(socket, id) {
-    super();
-    this.id = id;
-    this.ready = false;
-    this.closed = false;
-    this.socket = socket;
-    this.socket.on('close', () => this.onClose());
-    this.socket.on('message', (msg) => this.onMessage(msg));
-    this.socket.send(JSON.stringify({
-      message: AGENT_SOCKET_MESSAGE_READY
-    }));
-  }
-
-  close() {
-    if (this.socket) {
-      this.socket.close();
-    }
-  }
-
-  onTunnelRequests(data) {
-    this.httpLog = {
-      requests: data.requests.map((r) => {
-        r.requestBody = {
-          data: Buffer.from(r.requestBody.data, 'base64'),
-          tooLarge: r.requestBody.tooLarge,
-          realLength: r.requestBody.realLength
-        };
-        r.responseBody = {
-          data: Buffer.from(r.responseBody.data, 'base64'),
-          tooLarge: r.responseBody.tooLarge,
-          realLength: r.responseBody.realLength
-        };
-        return r;
-      })
-    };
-  }
-
-  onTunnelData(data) {
-    if (data.regionLatency) this.regionLatency = data.regionLatency;
-    if (data.targetLatency) this.targetLatency = data.targetLatency;
-    if (data.identify) this.identify = data.identify;
-    if (data.dns) this.dns = data.dns;
-    if (data.connections) this.connections = data.connections;
-    this.totalConnections = data.totalConnections;
-    this.serve = data.serve;
-    this.log = data.log;
-    this.status = data.status;
-    this.region = data.region;
-    this.type = data.type;
-    this.target = data.target;
-    this.terminate = data.terminate;
-    this.id = data.id;
-    this.subdomain = data.subdomain;
-    this.sshId = data.sshId;
-    this.domain = data.domain;
-    this.sshForwardPort = data.sshForwardPort;
-  }
-
-  upsertHttpLog(data) {
-    if (!this.httpLog || !this.httpLog.requests || !this.log) return;
-    /**
-     * @type {object}
-     */
-    const r = this.httpLog.requests.find((r) => r.id === data.id);
-    if (!r) {
-      data.requestBody = {
-        data: Buffer.from(data.requestBody.data, 'base64'),
-        tooLarge: data.requestBody.tooLarge,
-        realLength: data.requestBody.realLength
-      };
-      data.responseBody = {
-        data: Buffer.from(data.responseBody.data, 'base64'),
-        tooLarge: data.responseBody.tooLarge,
-        realLength: data.responseBody.realLength
-      };
-      this.httpLog.requests.unshift(data);
-    } else {
-      r.finished = data.finished;
-      r.time = data.time;
-      r.httpVersion = data.httpVersion;
-      r.requestBody = {
-        data: Buffer.from(data.requestBody.data, 'base64'),
-        tooLarge: data.requestBody.tooLarge,
-        realLength: data.requestBody.realLength
-      };
-      r.responseBody = {
-        data: Buffer.from(data.responseBody.data, 'base64'),
-        tooLarge: data.responseBody.tooLarge,
-        realLength: data.responseBody.realLength
-      };
-      r.headers = data.headers;
-      r.status = data.status;
-      r.url = data.url;
-      r.method = data.method;
-    }
-    if (this.httpLog.requests.length > TUNNEL_HTTP_LOG_MAX_REQUESTS) this.httpLog.requests.pop();
-  }
-
-  onMessage(msg) {
-    try {
-      const json = JSON.parse(msg.toString('utf8'));
-      if (json.message === AGENT_SOCKET_MESSAGE_TUNNEL) {
-        this.onTunnelData(json);
-        this.ready = true;
-        return;
-      }
-      if (json.message === AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_REQUESTS) {
-        this.onTunnelRequests(json);
-        return;
-      }
-      if (json.message === AGENT_SOCKET_MESSAGE_TUNNEL_OPEN) {
-        this.emit(TUNNEL_EVENT_OPEN, json);
-        return;
-      }
-      if (json.message === AGENT_SOCKET_MESSAGE_TUNNEL_CLOSED) {
-        this.emit(TUNNEL_EVENT_CLOSED, json);
-        return;
-      }
-      if (json.message === AGENT_SOCKET_MESSAGE_TUNNEL_TCP_OPEN) {
-        this.emit(TUNNEL_EVENT_TCP_OPEN, json);
-        return;
-      }
-      if (json.message === AGENT_SOCKET_MESSAGE_TUNNEL_TCP_CLOSED) {
-        this.emit(TUNNEL_EVENT_TCP_CLOSED, json);
-        return;
-      }
-      if (json.message === AGENT_SOCKET_MESSAGE_TUNNEL_TLS_OPEN) {
-        this.emit(TUNNEL_EVENT_TLS_OPEN, json);
-        return;
-      }
-      if (json.message === AGENT_SOCKET_MESSAGE_TUNNEL_TLS_CLOSED) {
-        this.emit(TUNNEL_EVENT_TLS_CLOSED, json);
-        return;
-      }
-      if (json.message === AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_IDENTIFIED) {
-        this.emit(TUNNEL_EVENT_HTTP_IDENTIFIED, json, json.identify);
-        return;
-      }
-      if (json.message === AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_REQUEST) {
-        this.upsertHttpLog(json.logRequest);
-        this.emit(TUNNEL_EVENT_HTTP_REQUEST, json, json.logRequest);
-        return;
-      }
-      if (json.message === AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_RESPONSE) {
-        this.upsertHttpLog(json.logRequest);
-        this.emit(TUNNEL_EVENT_HTTP_RESPONSE, json, json.logRequest);
-        return;
-      }
-      if (json.message === AGENT_SOCKET_MESSAGE_TUNNEL_STOPPED) {
-        this.emit(TUNNEL_EVENT_STOPPED, json);
-        this.close();
-      }
-    } catch (err) {
-      this.close();
-    }
-  }
-
-  onClose() {
-    this.emit(TUNNEL_EVENT_STOPPED);
-    try {
-      this.socket.removeAllListeners();
-      this.socket.close();
-    } catch (err) {
-      // do nothing
-    }
-    this.closed = true;
-    this.socket = null;
-  }
-
-  retryHttpLogRequest(logRequest) {
-    if (this.socket) {
-      this.socket.send(JSON.stringify({
-        message: AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_RETRY,
-        logRequest
-      }));
-    }
-  }
-
-  waitForReady() {
-    return new Promise((resolve, reject) => {
-      const ts1 = setInterval(() => {
-        if (this.ready) {
-          clearInterval(ts1);
-          clearTimeout(ts2);
-          resolve();
-        } else if (this.closed) {
-          clearInterval(ts1);
-          clearTimeout(ts2);
-          reject(new Error(ERR_TUNNEL_NOT_FOUND(this.id)));
-        }
-      }, 100);
-      const ts2 = setTimeout(() => {
-        clearInterval(ts1);
-        clearTimeout(ts2);
-        reject(new Error(ERR_TUNNEL_NOT_FOUND(this.id)));
-      }, 3000);
-    });
-  }
-}
-
-module.exports = AgentSocketTunnel;

package/src/agent/socket.js

@@ -1,260 +0,0 @@
-const {
-  AGENT_SOCKET_MESSAGE_READY,
-  AGENT_SOCKET_MESSAGE_TUNNEL,
-  AGENT_SOCKET_MESSAGE_TUNNEL_STOPPED,
-  AGENT_SOCKET_MESSAGE_TUNNEL_OPEN,
-  AGENT_SOCKET_MESSAGE_TUNNEL_CLOSED,
-  AGENT_SOCKET_MESSAGE_TUNNEL_TCP_OPEN,
-  AGENT_SOCKET_MESSAGE_TUNNEL_TCP_CLOSED,
-  AGENT_SOCKET_MESSAGE_TUNNEL_TLS_OPEN,
-  AGENT_SOCKET_MESSAGE_TUNNEL_TLS_CLOSED,
-  AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_IDENTIFIED,
-  AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_REQUESTS,
-  AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_REQUEST,
-  AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_RESPONSE,
-  AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_RETRY,
-  TUNNEL_EVENT_OPEN,
-  TUNNEL_EVENT_CLOSED,
-  TUNNEL_EVENT_TCP_OPEN,
-  TUNNEL_EVENT_TCP_CLOSED,
-  TUNNEL_EVENT_TLS_OPEN,
-  TUNNEL_EVENT_TLS_CLOSED,
-  TUNNEL_EVENT_HTTP_IDENTIFIED,
-  TUNNEL_EVENT_HTTP_REQUEST,
-  TUNNEL_EVENT_HTTP_RESPONSE,
-  TUNNEL_EVENT_STOPPED
-} = require('../utils');
-
-class AgentSocket {
-  constructor(socket, tunnel) {
-    this.tunnel = tunnel;
-    this.socket = socket;
-    this.ready = false;
-    this.socket.on('close', () => this.close());
-    this.socket.on('message', (msg) => this.onMessage(msg));
-    this.boundEventStopped = (t) => this.tunnelStopped(t);
-    this.boundEventOpen = (t) => this.tunnelOpen(t);
-    this.boundEventClosed = (t) => this.tunnelClosed(t);
-    this.boundEventTcpOpen = (t) => this.tunnelTcpOpen(t);
-    this.boundEventTcpClosed = (t) => this.tunnelTcpClosed(t);
-    this.boundEventTlsOpen = (t) => this.tunnelTlsOpen(t);
-    this.boundEventTlsClosed = (t) => this.tunnelTlsClosed(t);
-    this.boundEventHttpIdentified = (t, type) => this.tunnelHttpIdentified(t, type);
-    this.boundEventHttpRequest = (t, logRequest) => this.tunnelHttpRequest(t, logRequest);
-    this.boundEventHttpResponse = (t, logRequest) => this.tunnelHttpResponse(t, logRequest);
-    this.tunnel.on(TUNNEL_EVENT_STOPPED, this.boundEventStopped);
-    this.tunnel.on(TUNNEL_EVENT_OPEN, this.boundEventOpen);
-    this.tunnel.on(TUNNEL_EVENT_CLOSED, this.boundEventClosed);
-    this.tunnel.on(TUNNEL_EVENT_TCP_OPEN, this.boundEventTcpOpen);
-    this.tunnel.on(TUNNEL_EVENT_TCP_CLOSED, this.boundEventTcpClosed);
-    this.tunnel.on(TUNNEL_EVENT_TLS_OPEN, this.boundEventTlsOpen);
-    this.tunnel.on(TUNNEL_EVENT_TLS_CLOSED, this.boundEventTlsClosed);
-    this.tunnel.on(TUNNEL_EVENT_HTTP_IDENTIFIED, this.boundEventHttpIdentified);
-    this.tunnel.on(TUNNEL_EVENT_HTTP_REQUEST, this.boundEventHttpRequest);
-    this.tunnel.on(TUNNEL_EVENT_HTTP_RESPONSE, this.boundEventHttpResponse);
-  }
-
-  onMessage(message) {
-    try {
-      const json = JSON.parse(message.toString('utf8'));
-      if (json.message === AGENT_SOCKET_MESSAGE_READY) {
-        this.ready = true;
-        this.ts = setInterval(() => {
-          this.sendTunnel();
-        }, 100);
-        this.sendTunnel();
-        this.sendRequests();
-        return;
-      }
-      if (json.message === AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_RETRY && this.ready) {
-        this.retryHttpRequest(json.logRequest);
-      }
-    } catch (err) {
-      // do nothing
-    }
-  }
-
-  retryHttpRequest(logRequest) {
-    this.tunnel.retryHttpLogRequest(logRequest);
-  }
-
-  send(message, data = {}) {
-    if (this.socket && this.ready) {
-      this.socket.send(JSON.stringify({
-        message,
-        ...data
-      }));
-    }
-  }
-
-  sendEvent(message, t, data = {}) {
-    this.send(message, {
-      type: t.type,
-      serve: t.serve,
-      target: t.target,
-      subdomain: t.subdomain,
-      domain: t.domain,
-      sshId: t.sshId,
-      sshForwardPort: t.sshForwardPort,
-      ...data
-    });
-  }
-
-  tunnelOpen(t) {
-    this.sendEvent(AGENT_SOCKET_MESSAGE_TUNNEL_OPEN, t);
-  }
-
-  tunnelClosed(t) {
-    this.sendEvent(AGENT_SOCKET_MESSAGE_TUNNEL_CLOSED, t);
-  }
-
-  tunnelTcpOpen(t) {
-    this.sendEvent(AGENT_SOCKET_MESSAGE_TUNNEL_TCP_OPEN, t);
-  }
-
-  tunnelTcpClosed(t) {
-    this.sendEvent(AGENT_SOCKET_MESSAGE_TUNNEL_TCP_CLOSED, t);
-  }
-
-  tunnelTlsOpen(t) {
-    this.sendEvent(AGENT_SOCKET_MESSAGE_TUNNEL_TLS_OPEN, t);
-  }
-
-  tunnelTlsClosed(t) {
-    this.sendEvent(AGENT_SOCKET_MESSAGE_TUNNEL_TLS_CLOSED, t);
-  }
-
-  tunnelHttpIdentified(t, type) {
-    this.sendEvent(AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_IDENTIFIED, t, {
-      identify: type
-    });
-  }
-
-  logRequestToSocket(logRequest) {
-    return {
-      id: logRequest.id,
-      finished: logRequest.finished,
-      time: logRequest.time,
-      httpVersion: logRequest.httpVersion,
-      requestBody: {
-        data: logRequest.requestBody.data.toString('base64'),
-        tooLarge: logRequest.requestBody.tooLarge,
-        realLength: logRequest.requestBody.realLength
-      },
-      responseBody: {
-        data: logRequest.responseBody.data.toString('base64'),
-        tooLarge: logRequest.responseBody.tooLarge,
-        realLength: logRequest.responseBody.realLength
-      },
-      headers: logRequest.headers,
-      status: logRequest.status,
-      url: logRequest.url,
-      method: logRequest.method
-    };
-  }
-
-  tunnelHttpRequest(t, logRequest) {
-    this.sendEvent(AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_REQUEST, t, {
-      logRequest: this.logRequestToSocket(logRequest)
-    });
-  }
-
-  tunnelHttpResponse(t, logRequest) {
-    this.sendEvent(AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_RESPONSE, t, {
-      logRequest: this.logRequestToSocket(logRequest)
-    });
-  }
-
-  tunnelStopped(t) {
-    this.sendEvent(AGENT_SOCKET_MESSAGE_TUNNEL_STOPPED, t);
-    this.close();
-  }
-
-  sendRequests() {
-    let requests = [];
-    if (this.tunnel.httpLog) {
-      requests = this.tunnel.httpLog.requests.map((lr) => this.logRequestToSocket(lr));
-    }
-    this.send(AGENT_SOCKET_MESSAGE_TUNNEL_HTTP_REQUESTS, {
-      requests
-    });
-  }
-
-  sendTunnel() {
-    const connections = {};
-    Object.keys(this.tunnel.connections).forEach((id) => {
-      connections[id] = true;
-    });
-    const regionLatency = {
-      latency: -1
-    };
-    if (this.tunnel.regionLatency) {
-      regionLatency.latency = this.tunnel.regionLatency.latency;
-    }
-    const targetLatency = {
-      latency: -1
-    };
-    if (this.tunnel.targetLatency) {
-      targetLatency.latency = this.tunnel.targetLatency.latency;
-    }
-    let identify = null;
-    if (this.tunnel.identify) {
-      identify = {
-        type: this.tunnel.identify.type
-      };
-    }
-    const dns = {
-      checking: false,
-      valid: false
-    };
-    if (this.tunnel.dns) {
-      dns.checking = this.tunnel.dns.checking;
-      dns.valid = this.tunnel.dns.valid;
-    }
-    this.send(AGENT_SOCKET_MESSAGE_TUNNEL, {
-      regionLatency,
-      targetLatency,
-      connections,
-      identify,
-      dns,
-      totalConnections: this.tunnel.totalConnections,
-      serve: this.tunnel.serve,
-      log: this.tunnel.log,
-      status: this.tunnel.status,
-      region: this.tunnel.region,
-      type: this.tunnel.type,
-      target: this.tunnel.target,
-      terminate: this.tunnel.terminate,
-      id: this.tunnel.id,
-      subdomain: this.tunnel.subdomain,
-      domain: this.tunnel.domain,
-      sshId: this.tunnel.sshId,
-      sshForwardPort: this.tunnel.sshForwardPort
-    });
-  }
-
-  close() {
-    clearInterval(this.ts);
-    try {
-      this.socket.removeAllListeners();
-      this.socket.close();
-    } catch (err) {
-      // do nothing
-    }
-    this.ts = null;
-    this.socket = null;
-    this.tunnel.removeListener(TUNNEL_EVENT_OPEN, this.boundEventOpen);
-    this.tunnel.removeListener(TUNNEL_EVENT_CLOSED, this.boundEventClosed);
-    this.tunnel.removeListener(TUNNEL_EVENT_TCP_OPEN, this.boundEventTcpOpen);
-    this.tunnel.removeListener(TUNNEL_EVENT_TCP_CLOSED, this.boundEventTcpClosed);
-    this.tunnel.removeListener(TUNNEL_EVENT_HTTP_IDENTIFIED, this.boundEventHttpIdentified);
-    this.tunnel.removeListener(TUNNEL_EVENT_HTTP_REQUEST, this.boundEventHttpRequest);
-    this.tunnel.removeListener(TUNNEL_EVENT_HTTP_RESPONSE, this.boundEventHttpResponse);
-    this.tunnel.removeListener(TUNNEL_EVENT_TLS_OPEN, this.boundEventTlsOpen);
-    this.tunnel.removeListener(TUNNEL_EVENT_TLS_CLOSED, this.boundEventTlsClosed);
-    this.tunnel.removeListener(TUNNEL_EVENT_STOPPED, this.boundEventStopped);
-    this.tunnel = null;
-  }
-}
-
-module.exports = AgentSocket;