bdy 1.12.8-dev → 1.12.8-dev-pipeline-run

package/distTs/src/agent/socket/client.js

@@ -1,178 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const https_1 = require("https");
-const events_1 = __importDefault(require("events"));
-const logger_1 = __importDefault(require("../../logger"));
-const texts_1 = require("../../texts");
-const utils_1 = require("../../utils");
-const socket_io_client_1 = require("socket.io-client");
-const tunnel_1 = require("../../types/tunnel");
-const MAX_REQUESTS_SYNC_WINDOW = 30000;
-const MAX_REQUESTS_SYNC_IN_WINDOW = 100;
-class AgentSocketClient extends events_1.default {
-    socket;
-    id;
-    token;
-    hostname;
-    platform;
-    version;
-    connected;
-    lastUpdate;
-    tunnelRequests;
-    fetch(activate = true, action = null, disabled = null, resetFirstHeard = false, tunnels) {
-        if (!this.socket)
-            return;
-        this.socket.emit('fetchTunnelAgent', {
-            id: this.id,
-            token: this.token,
-            hostname: this.hostname,
-            platform: this.platform,
-            version: this.version,
-            activate,
-            action,
-            disabled,
-            resetFirstHeard,
-            tunnels,
-        });
-    }
-    update(activate, tunnels, force = false) {
-        if (!this.socket)
-            return;
-        const now = Date.now();
-        // nie robimy update jak byl mniej niz 5s temu
-        if (!force && this.lastUpdate && now - this.lastUpdate < 5000)
-            return;
-        this.lastUpdate = now;
-        this.socket.emit('updateTunnelAgent', {
-            id: this.id,
-            token: this.token,
-            hostname: this.hostname,
-            platform: this.platform,
-            version: this.version,
-            activate,
-            tunnels,
-        });
-    }
-    emitRequest(tunnelId, logRequest) {
-        if (!this.socket)
-            return;
-        this.socket.emit('tunnelRequest', {
-            id: this.id,
-            token: this.token,
-            tunnelId,
-            request: logRequest.toSocket(),
-        });
-    }
-    request(tunnelId, logRequest) {
-        if (this.tunnelRequests > MAX_REQUESTS_SYNC_IN_WINDOW)
-            return;
-        this.tunnelRequests += 1;
-        logRequest.once(tunnel_1.TUNNEL_EVENT_HTTP.NEW_RESPONSE_END, () => {
-            this.emitRequest(tunnelId, logRequest);
-        });
-        this.emitRequest(tunnelId, logRequest);
-    }
-    onSyncAgent(data, action) {
-        this.emit(tunnel_1.TUNNEL_SOCKET_EVENT.AGENT, data, action);
-    }
-    onSyncTunnel(data, action) {
-        this.emit(tunnel_1.TUNNEL_SOCKET_EVENT.TUNNEL, data, action);
-    }
-    onSync(data) {
-        try {
-            const json = JSON.parse(data);
-            if (json.payloadType === 'TunnelAgentFront')
-                this.onSyncAgent(json.payload, json.action);
-            else if (json.payloadType === 'TunnelFront')
-                this.onSyncTunnel(json.payload, json.action);
-        }
-        catch {
-            // do nothing
-        }
-    }
-    connect(atOnce) {
-        logger_1.default.debug('socket connect');
-        if (atOnce && this.socket && !this.socket.connected) {
-            this.socket.connect();
-        }
-        else {
-            setTimeout(() => {
-                if (this.socket && !this.socket.connected)
-                    this.socket.connect();
-            }, 3000);
-        }
-    }
-    destroy() {
-        if (this.socket) {
-            this.socket.removeAllListeners();
-            this.socket.disconnect();
-            this.socket = null;
-        }
-    }
-    constructor(host, id, token) {
-        super();
-        this.id = id;
-        this.token = token;
-        this.connected = false;
-        this.hostname = (0, utils_1.getHostname)();
-        this.platform = (0, utils_1.getPlatform)();
-        this.version = (0, utils_1.getVersion)();
-        this.lastUpdate = null;
-        this.tunnelRequests = 0;
-        setInterval(() => {
-            this.tunnelRequests = 0;
-        }, MAX_REQUESTS_SYNC_WINDOW);
-        this.socket = (0, socket_io_client_1.io)(host, {
-            forceNew: true,
-            autoConnect: false,
-            autoUnref: true,
-            forceBase64: true,
-            transports: ['websocket'],
-            reconnection: false,
-            rejectUnauthorized: false,
-            // @ts-ignore
-            agent: new https_1.Agent({
-                rejectUnauthorized: false,
-            }),
-            maxHttpBufferSize: 3e6,
-            extraHeaders: {
-                cookie: 'a=b',
-            },
-        });
-        this.socket.on('connect', () => {
-            if (!this.socket)
-                return;
-            this.connected = true;
-            logger_1.default.info(texts_1.LOG_SOCKET_CONNECTED);
-            this.emit(tunnel_1.TUNNEL_SOCKET_EVENT.CONNECTED);
-            this.socket.emit('joinTunnelAgent', {
-                id: this.id,
-                token: this.token,
-            });
-        });
-        this.socket.on('disconnect', () => {
-            this.connected = false;
-            logger_1.default.info(texts_1.LOG_SOCKET_DISCONNECTED);
-            this.emit(tunnel_1.TUNNEL_SOCKET_EVENT.DISCONNECTED);
-            this.connect();
-        });
-        this.socket.on('connect_error', () => {
-            logger_1.default.debug('socket error');
-            this.connect();
-        });
-        this.socket.on('fetchTunnelAgentSuccess', (data) => {
-            logger_1.default.debug('Socket fetch success');
-            this.emit(tunnel_1.TUNNEL_SOCKET_EVENT.FETCH_SUCCESS, data);
-        });
-        this.socket.on('fetchTunnelAgentFailed', (code) => {
-            logger_1.default.debug('Socket fetch failed');
-            this.emit(tunnel_1.TUNNEL_SOCKET_EVENT.FETCH_FAILED, (0, utils_1.apiErrorCodeToClass)(code, host));
-        });
-        this.socket.on('sync', (data) => this.onSync(data));
-        this.connect(true);
-    }
-}
-exports.default = AgentSocketClient;

package/distTs/src/agent/socket/tunnel.js

@@ -1,237 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const texts_1 = require("../../texts");
-const events_1 = __importDefault(require("events"));
-const utils_1 = require("../../utils");
-const tunnel_1 = require("../../types/tunnel");
-class AgentSocketTunnel extends events_1.default {
-    id;
-    closed;
-    ready;
-    socket;
-    httpLog;
-    regionLatency;
-    targetLatency;
-    identify;
-    sshForwardPort;
-    domain;
-    sshId;
-    subdomain;
-    terminate;
-    target;
-    type;
-    region;
-    status;
-    log;
-    serve;
-    totalConnections;
-    connections;
-    dns;
-    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: tunnel_1.TUNNEL_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 > utils_1.TUNNEL_HTTP_LOG_MAX_REQUESTS)
-            this.httpLog.requests.pop();
-    }
-    onMessage(msg) {
-        try {
-            const json = JSON.parse(msg.toString('utf8'));
-            if (json.message === tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL) {
-                this.onTunnelData(json);
-                this.ready = true;
-                return;
-            }
-            if (json.message === tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_HTTP_REQUESTS) {
-                this.onTunnelRequests(json);
-                return;
-            }
-            if (json.message === tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_OPEN) {
-                this.emit(tunnel_1.TUNNEL_EVENT.OPEN, json);
-                return;
-            }
-            if (json.message === tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_CLOSED) {
-                this.emit(tunnel_1.TUNNEL_EVENT.CLOSED, json);
-                return;
-            }
-            if (json.message === tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_TCP_OPEN) {
-                this.emit(tunnel_1.TUNNEL_EVENT.TCP_OPEN, json);
-                return;
-            }
-            if (json.message === tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_TCP_CLOSED) {
-                this.emit(tunnel_1.TUNNEL_EVENT.TCP_CLOSED, json);
-                return;
-            }
-            if (json.message === tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_TLS_OPEN) {
-                this.emit(tunnel_1.TUNNEL_EVENT.TLS_OPEN, json);
-                return;
-            }
-            if (json.message === tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_TLS_CLOSED) {
-                this.emit(tunnel_1.TUNNEL_EVENT.TLS_CLOSED, json);
-                return;
-            }
-            if (json.message === tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_HTTP_IDENTIFIED) {
-                this.emit(tunnel_1.TUNNEL_EVENT.HTTP_IDENTIFIED, json, json.identify);
-                return;
-            }
-            if (json.message === tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_HTTP_REQUEST) {
-                this.upsertHttpLog(json.logRequest);
-                this.emit(tunnel_1.TUNNEL_EVENT.HTTP_REQUEST, json, json.logRequest);
-                return;
-            }
-            if (json.message === tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_HTTP_RESPONSE) {
-                this.upsertHttpLog(json.logRequest);
-                this.emit(tunnel_1.TUNNEL_EVENT.HTTP_RESPONSE, json, json.logRequest);
-                return;
-            }
-            if (json.message === tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_STOPPED) {
-                this.emit(tunnel_1.TUNNEL_EVENT.STOPPED, json);
-                this.close();
-            }
-        }
-        catch {
-            this.close();
-        }
-    }
-    onClose() {
-        this.emit(tunnel_1.TUNNEL_EVENT.STOPPED);
-        if (this.socket) {
-            try {
-                this.socket.removeAllListeners();
-                this.socket.close();
-            }
-            catch {
-                // do nothing
-            }
-        }
-        this.closed = true;
-        this.socket = null;
-    }
-    retryHttpLogRequest(logRequest) {
-        if (this.socket) {
-            this.socket.send(JSON.stringify({
-                message: tunnel_1.TUNNEL_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((0, texts_1.ERR_TUNNEL_NOT_FOUND)(this.id)));
-                }
-            }, 100);
-            const ts2 = setTimeout(() => {
-                clearInterval(ts1);
-                clearTimeout(ts2);
-                reject(new Error((0, texts_1.ERR_TUNNEL_NOT_FOUND)(this.id)));
-            }, 3000);
-        });
-    }
-}
-exports.default = AgentSocketTunnel;

package/distTs/src/agent/socket.js

@@ -1,242 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tunnel_1 = require("../types/tunnel");
-class AgentSocket {
-    tunnel;
-    socket;
-    ready;
-    ts;
-    boundEventStopped;
-    boundEventOpen;
-    boundEventClosed;
-    boundEventTcpOpen;
-    boundEventTcpClosed;
-    boundEventTlsOpen;
-    boundEventTlsClosed;
-    boundEventHttpIdentified;
-    boundEventHttpRequest;
-    boundEventHttpResponse;
-    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_1.TUNNEL_EVENT.STOPPED, this.boundEventStopped);
-        this.tunnel.on(tunnel_1.TUNNEL_EVENT.OPEN, this.boundEventOpen);
-        this.tunnel.on(tunnel_1.TUNNEL_EVENT.CLOSED, this.boundEventClosed);
-        this.tunnel.on(tunnel_1.TUNNEL_EVENT.TCP_OPEN, this.boundEventTcpOpen);
-        this.tunnel.on(tunnel_1.TUNNEL_EVENT.TCP_CLOSED, this.boundEventTcpClosed);
-        this.tunnel.on(tunnel_1.TUNNEL_EVENT.TLS_OPEN, this.boundEventTlsOpen);
-        this.tunnel.on(tunnel_1.TUNNEL_EVENT.TLS_CLOSED, this.boundEventTlsClosed);
-        this.tunnel.on(tunnel_1.TUNNEL_EVENT.HTTP_IDENTIFIED, this.boundEventHttpIdentified);
-        this.tunnel.on(tunnel_1.TUNNEL_EVENT.HTTP_REQUEST, this.boundEventHttpRequest);
-        this.tunnel.on(tunnel_1.TUNNEL_EVENT.HTTP_RESPONSE, this.boundEventHttpResponse);
-    }
-    onMessage(message) {
-        try {
-            const json = JSON.parse(message.toString('utf8'));
-            if (json.message === tunnel_1.TUNNEL_SOCKET_MESSAGE.READY) {
-                this.ready = true;
-                this.ts = setInterval(() => {
-                    this.sendTunnel();
-                }, 100);
-                this.sendTunnel();
-                this.sendRequests();
-                return;
-            }
-            if (json.message === tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_HTTP_RETRY &&
-                this.ready) {
-                this.retryHttpRequest(json.logRequest);
-            }
-        }
-        catch {
-            // do nothing
-        }
-    }
-    retryHttpRequest(logRequest) {
-        if (!this.tunnel)
-            return;
-        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(tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_OPEN, t);
-    }
-    tunnelClosed(t) {
-        this.sendEvent(tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_CLOSED, t);
-    }
-    tunnelTcpOpen(t) {
-        this.sendEvent(tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_TCP_OPEN, t);
-    }
-    tunnelTcpClosed(t) {
-        this.sendEvent(tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_TCP_CLOSED, t);
-    }
-    tunnelTlsOpen(t) {
-        this.sendEvent(tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_TLS_OPEN, t);
-    }
-    tunnelTlsClosed(t) {
-        this.sendEvent(tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_TLS_CLOSED, t);
-    }
-    tunnelHttpIdentified(t, type) {
-        this.sendEvent(tunnel_1.TUNNEL_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(tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_HTTP_REQUEST, t, {
-            logRequest: this.logRequestToSocket(logRequest),
-        });
-    }
-    tunnelHttpResponse(t, logRequest) {
-        this.sendEvent(tunnel_1.TUNNEL_SOCKET_MESSAGE.TUNNEL_HTTP_RESPONSE, t, {
-            logRequest: this.logRequestToSocket(logRequest),
-        });
-    }
-    tunnelStopped(t) {
-        this.sendEvent(tunnel_1.TUNNEL_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(tunnel_1.TUNNEL_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(tunnel_1.TUNNEL_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() {
-        if (this.ts) {
-            clearInterval(this.ts);
-        }
-        this.ts = null;
-        if (this.socket) {
-            try {
-                this.socket.removeAllListeners();
-                this.socket.close();
-            }
-            catch {
-                // do nothing
-            }
-        }
-        this.socket = null;
-        if (this.tunnel) {
-            this.tunnel.removeListener(tunnel_1.TUNNEL_EVENT.OPEN, this.boundEventOpen);
-            this.tunnel.removeListener(tunnel_1.TUNNEL_EVENT.CLOSED, this.boundEventClosed);
-            this.tunnel.removeListener(tunnel_1.TUNNEL_EVENT.TCP_OPEN, this.boundEventTcpOpen);
-            this.tunnel.removeListener(tunnel_1.TUNNEL_EVENT.TCP_CLOSED, this.boundEventTcpClosed);
-            this.tunnel.removeListener(tunnel_1.TUNNEL_EVENT.HTTP_IDENTIFIED, this.boundEventHttpIdentified);
-            this.tunnel.removeListener(tunnel_1.TUNNEL_EVENT.HTTP_REQUEST, this.boundEventHttpRequest);
-            this.tunnel.removeListener(tunnel_1.TUNNEL_EVENT.HTTP_RESPONSE, this.boundEventHttpResponse);
-            this.tunnel.removeListener(tunnel_1.TUNNEL_EVENT.TLS_OPEN, this.boundEventTlsOpen);
-            this.tunnel.removeListener(tunnel_1.TUNNEL_EVENT.TLS_CLOSED, this.boundEventTlsClosed);
-            this.tunnel.removeListener(tunnel_1.TUNNEL_EVENT.STOPPED, this.boundEventStopped);
-        }
-        this.tunnel = null;
-    }
-}
-exports.default = AgentSocket;