@openclaw/slack 2026.7.2-beta.7 → 2026.7.34

package/node_modules/@slack/bolt/node_modules/@slack/oauth/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slack/oauth",
-  "version": "4.0.0",
+  "version": "3.0.5",
   "description": "Official library for interacting with Slack's Oauth endpoints",
   "author": "Slack Technologies, LLC",
   "license": "MIT",
@@ -16,8 +16,8 @@
     "dist/**/*"
   ],
   "engines": {
-    "node": ">=20",
-    "npm": ">=9.6.4"
+    "node": ">=18",
+    "npm": ">=8.6.0"
   },
   "repository": {
     "type": "git",
@@ -35,15 +35,16 @@
     "build:clean": "shx rm -rf ./dist",
     "docs": "npx typedoc --plugin typedoc-plugin-markdown",
     "prepack": "npm run build",
-    "test": "npm run build && bash -c 'node --test-reporter=spec --test-reporter-destination=stdout --test-reporter=junit --test-reporter-destination=test-results.xml --import tsx --test src/**/*.test.ts'",
-    "test:coverage": "npm run build && node --experimental-test-coverage --test-reporter=spec --test-reporter-destination=stdout --test-reporter=lcov --test-reporter-destination=lcov.info --test-reporter=junit --test-reporter-destination=test-results.xml --import tsx --test src/**/*.test.ts",
+    "test": "npm run test:unit",
+    "test:node18": "npm run build && bash -O globstar -c 'node --test --test-reporter=spec --import tsx src/**/*.test.ts'",
+    "test:unit": "npm run build && node --experimental-test-coverage --test-reporter=spec --test-reporter-destination=stdout --test-reporter=lcov --test-reporter-destination=lcov.info --test-reporter=junit --test-reporter-destination=test-results.xml --import tsx --test src/**/*.test.ts",
     "watch": "npx nodemon --watch 'src' --ext 'ts' --exec npm run build"
   },
   "dependencies": {
-    "@slack/logger": "^5.0.0",
-    "@slack/web-api": "^8.0.0",
+    "@slack/logger": "^4.0.1",
+    "@slack/web-api": "^7.15.0",
     "@types/jsonwebtoken": "^9",
-    "@types/node": ">=20",
+    "@types/node": ">=18",
     "jsonwebtoken": "^9"
   },
   "devDependencies": {

package/node_modules/@slack/bolt/node_modules/@slack/socket-mode/README.md

@@ -0,0 +1,221 @@
+# Slack Socket Mode
+
+[![codecov](https://codecov.io/gh/slackapi/node-slack-sdk/graph/badge.svg?token=OcQREPvC7r&flag=socket-mode)](https://codecov.io/gh/slackapi/node-slack-sdk)
+
+This package is designed to support [**Socket Mode**][socket-mode], which allows your app to receive events from Slack over a WebSocket connection.
+
+## Requirements
+
+This package supports Node v18 and higher. It's highly recommended to use [the latest LTS version of
+node](https://github.com/nodejs/Release#release-schedule), and the documentation is written using syntax and features from that version.
+
+## Installation
+
+```shell
+$ npm install @slack/socket-mode
+```
+
+## Usage
+
+### Initialize the client
+
+The package exports a `SocketModeClient` class. Your app will create an instance of the class for each workspace it communicates with. Creating an instance requires an [**app-level token**][app-token] from Slack. Apps connect to the **Socket Mode** API using an [**app-level token**][app-token], which starts with `xapp`.
+
+Note: **Socket Mode** requires the `connections:write` scope. Navigate to your [app configuration](https://api.slack.com/apps) and go to the bottom of the **Basic Information** section to create an App token with the `connections:write` scope.
+
+
+```javascript
+const { SocketModeClient } = require('@slack/socket-mode');
+
+// Read a token from the environment variables
+const appToken = process.env.SLACK_APP_TOKEN;
+
+// Initialize
+const client = new SocketModeClient({appToken});
+```
+
+### Connect to Slack
+
+Connecting is as easy as calling the `.start()` method.
+
+```javascript
+const { SocketModeClient } = require('@slack/socket-mode');
+const appToken = process.env.SLACK_APP_TOKEN;
+
+const socketModeClient = new SocketModeClient({appToken});
+
+(async () => {
+  // Connect to Slack
+  await socketModeClient.start();
+})();
+```
+
+### Listen for an event
+
+If you've used Node's [`EventEmitter`](https://nodejs.org/api/events.html#events_class_eventemitter) pattern
+before, then you're already familiar with how this works, since the client is an `EventEmitter`.
+
+The `event` argument passed to the listener is an object. Its contents correspond to the [type of
+event](https://docs.slack.dev/reference/events) it's registered for.
+
+```javascript
+const { SocketModeClient } = require('@slack/socket-mode');
+const appToken = process.env.SLACK_APP_TOKEN;
+
+const socketModeClient = new SocketModeClient({appToken});
+
+// Attach listeners to events by type. See: https://docs.slack.dev/reference/events/message
+socketModeClient.on('message', (event) => {
+  console.log(event);
+});
+
+(async () => {
+  await socketModeClient.start();
+})();
+```
+
+### Send a message
+
+To respond to events and send messages back into Slack, we recommend using the `@slack/web-api` package with a [bot token](https://docs.slack.dev/authentication/tokens#bot).
+
+```javascript
+const { SocketModeClient } = require('@slack/socket-mode');
+const { WebClient } = require('@slack/web-api');
+
+const socketModeClient = new SocketModeClient(process.env.SLACK_APP_TOKEN);
+const webClient = new WebClient(process.env.BOT_TOKEN);
+
+// Attach listeners to events by type. See: https://docs.slack.dev/reference/events/message
+socketModeClient.on('member_joined_channel', async ({event, body, ack}) => {
+    try {
+      // send acknowledgement back to slack over the socketMode websocket connection
+      // this is so slack knows you have received the event and are processing it
+      await ack();
+      await webClient.chat.postMessage({
+          blocks: [
+          {
+            type: 'section',
+            text: {
+              type: 'mrkdwn',
+              text: `Welcome to the channel, <@${event.user}>. We're here to help. Let us know if you have an issue.`,
+            },
+            accessory: {
+              type: 'button',
+              text: {
+                type: 'plain_text',
+                text: 'Get Help',
+              },
+              value: 'get_help',
+            },
+          },
+        ],
+        channel: event.channel,
+      });
+    } catch (error) {
+      console.log('An error occurred', error);
+    }
+  });
+  
+(async () => {
+  await socketModeClient.start();
+})();
+```
+
+### Lifecycle events
+
+The client's connection to Slack has a lifecycle. This means the client can be seen as a state machine which transitions through a few states as it connects, disconnects and possibly reconnects with Slack. The client emits an event for each state it transitions to throughout its lifecycle. If your app simply needs to know whether the client is connected or not, the `.connected` boolean property can be checked.
+
+In the table below, the client's states are listed, which are also the names of the events you can use to observe the transition to that state. The table also includes descriptions for the states and arguments that a listener would receive.
+
+| Event Name      | Arguments | Description |
+|-----------------|-----------------|-------------|
+| `connecting`    |  | The client is in the process of connecting to the platform. |
+| `connected`     |  | The client is connected to the platform and incoming events will start being emitted. |
+| `disconnecting` |  | The client is no longer connected to the platform and cleaning up its resources. It will soon transition to `disconnected`. |
+| `reconnecting`  |  | The client is no longer connected to the platform and cleaning up its resources. It will soon transition to `connecting`. |
+| `disconnected`  | `(error)` | The client is not connected to the platform. This is a steady state - no attempt to connect is occurring. The `error` argument will be `undefined` when the client initiated the disconnect (normal). |
+
+The client also emits events that are part of its lifecycle, but aren't states. Instead, they represent specific moments that might be helpful to your app. The following table lists these events, their description, and includes the arguments that a listener would receive.
+
+| Event Name      | Arguments | Description |
+|-----------------|-----------|-------------|
+| `error`         | `(error)` | An error has occurred. |
+| `slack_event`   | `(eventType, event)` | An incoming Slack event has been received. |
+
+---
+
+### Logging
+
+The `SocketModeClient` will log information to the console by default. You can use the `logLevel` to decide how much or what kind of information should be output. There are a few possible log levels, which you can find in the `LogLevel` export. By default, the value is set to `LogLevel.INFO`. While you're in development, it's sometimes helpful to set this to the most verbose: `LogLevel.DEBUG`.
+
+```javascript
+// Import LogLevel from the package
+const { SocketModeClient, LogLevel } = require('@slack/socket-mode');
+const appToken = process.env.SLACK_APP_TOKEN;
+
+// Log level is one of the options you can set in the constructor
+const socketModeClient = new SocketModeClient({
+  appToken,
+  logLevel: LogLevel.DEBUG,
+});
+
+(async () => {
+  await socketModeClient.start();
+})();
+```
+
+All the log levels, in order of most to least information are: `DEBUG`, `INFO`, `WARN`, and `ERROR`.
+
+<details>
+<summary markdown="span">
+<strong><i>Sending log output somewhere besides the console</i></strong>
+</summary>
+
+You can also choose to have logs sent to a custom logger using the `logger` option. A custom logger needs to implement specific methods (known as the `Logger` interface, see the [`@slack/logger` package](https://www.npmjs.com/package/@slack/logger) for details). A minimal interface should implement the following methods:
+
+| Method       | Parameters        | Return type |
+|--------------|-------------------|-------------|
+| `getLevel()` | n/a               | `LogLevel`  |
+| `setLevel()` | `level: LogLevel` | `void`      |
+| `setName()`  | `name: string`    | `void`      |
+| `debug()`    | `...msgs: any[]`  | `void`      |
+| `info()`     | `...msgs: any[]`  | `void`      |
+| `warn()`     | `...msgs: any[]`  | `void`      |
+| `error()`    | `...msgs: any[]`  | `void`      |
+
+A very simple custom logger might ignore the name and level, and write all messages to a file.
+
+```javascript
+const { createWriteStream } = require('fs');
+const logWritable = createWriteStream('/var/my_log_file'); // Not shown: close this stream
+
+const socketModeClient = new SocketModeClient({
+  appToken,
+  // Creating a logger as a literal object. It's more likely that you'd create a class.
+  logger: {
+    debug(...msgs): { logWritable.write('debug: ' + JSON.stringify(msgs)); },
+    info(...msgs): { logWritable.write('info: ' + JSON.stringify(msgs)); },
+    warn(...msgs): { logWritable.write('warn: ' + JSON.stringify(msgs)); },
+    error(...msgs): { logWritable.write('error: ' + JSON.stringify(msgs)); },
+    getLevel(): { return 'info'; },
+    setLevel(): { },
+    setName(): { },
+  },
+});
+
+(async () => {
+  await socketModeClient.start();
+})();
+```
+</details>
+
+---
+
+## Getting Help
+
+If you get stuck, we're here to help. The following are the best ways to get assistance working through your issue:
+
+  * [Issue Tracker](http://github.com/slackapi/node-slack-sdk/issues) for questions, feature requests, bug reports and general discussion related to these packages. Try searching before you create a new issue.
+
+[socket-mode]: https://docs.slack.dev/apis/events-api/using-socket-mode
+[app-token]: https://docs.slack.dev/authentication/tokens#app-level

package/node_modules/@slack/bolt/node_modules/@slack/socket-mode/dist/package.json

@@ -0,0 +1,67 @@
+{
+    "name": "@slack/socket-mode",
+    "version": "2.0.7",
+    "description": "Official library for using the Slack Platform's Socket Mode API",
+    "author": "Slack Technologies, LLC",
+    "license": "MIT",
+    "keywords": [
+        "slack",
+        "socket",
+        "websocket",
+        "firewall",
+        "bot",
+        "client",
+        "http",
+        "websocket",
+        "api",
+        "proxy",
+        "state",
+        "connection"
+    ],
+    "main": "dist/src/index.js",
+    "types": "./dist/src/index.d.ts",
+    "files": [
+        "dist/**/*"
+    ],
+    "engines": {
+        "node": ">= 18",
+        "npm": ">= 8.6.0"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/slackapi/node-slack-sdk.git"
+    },
+    "homepage": "https://docs.slack.dev/tools/node-slack-sdk/socket-mode/",
+    "publishConfig": {
+        "access": "public"
+    },
+    "bugs": {
+        "url": "https://github.com/slackapi/node-slack-sdk/issues"
+    },
+    "scripts": {
+        "build": "npm run build:clean && tsc",
+        "build:clean": "shx rm -rf ./dist",
+        "docs": "npx typedoc --plugin typedoc-plugin-markdown",
+        "prepack": "npm run build",
+        "test": "npm run test:unit && npm run test:integration",
+        "test:node18": "npm run build && bash -c 'node --test --test-reporter=spec --import tsx src/*.test.ts' && npm run test:integration",
+        "test:integration": "npm run build && node --import tsx --test test/integration.test.js",
+        "test:unit": "npm run build && node --experimental-test-coverage --test-reporter=spec --test-reporter-destination=stdout --test-reporter=lcov --test-reporter-destination=lcov.info --test-reporter=junit --test-reporter-destination=test-results.xml --import tsx --test src/*.test.ts",
+        "watch": "npx nodemon --watch 'src' --ext 'ts' --exec npm test"
+    },
+    "dependencies": {
+        "@slack/logger": "^4.0.1",
+        "@slack/web-api": "^7.15.0",
+        "@types/node": ">=18",
+        "@types/ws": "^8",
+        "eventemitter3": "^5",
+        "ws": "^8"
+    },
+    "devDependencies": {
+        "@types/proxyquire": "^1.3.31",
+        "@types/sinon": "^21",
+        "nodemon": "^3.1.0",
+        "proxyquire": "^2.1.3",
+        "sinon": "^21"
+    }
+}

package/node_modules/@slack/bolt/node_modules/@slack/socket-mode/dist/src/SlackWebSocket.d.ts

@@ -0,0 +1,96 @@
+import type { Agent } from 'node:http';
+import type { EventEmitter } from 'eventemitter3';
+import { type Logger, LogLevel } from './logger';
+export declare const WS_READY_STATES: string[];
+export interface SlackWebSocketOptions {
+    /** @description The Slack WebSocket URL to connect to. */
+    url: string;
+    /** @description An instance of EventEmitter where socket-related events can be emitted to. */
+    client: EventEmitter;
+    /** @description A LogLevel at which this class should log to. */
+    logLevel?: LogLevel;
+    /** @description A Logger instance used to log activity to. */
+    logger?: Logger;
+    /** @description Delay between this client sending a `ping` message, in milliseconds. */
+    pingInterval?: number;
+    /** @description The HTTP Agent to use when establishing a WebSocket connection. */
+    httpAgent?: Agent;
+    /** @description Whether this WebSocket should DEBUG log ping and pong events. `false` by default. */
+    pingPongLoggingEnabled?: boolean;
+    /**
+     * @description How many milliseconds to wait between ping events from the server before deeming the connection
+     * stale. Defaults to 30,000.
+     */
+    serverPingTimeoutMS: number;
+    /**
+     * @description How many milliseconds to wait between ping events from the server before deeming the connection
+     * stale. Defaults to 5,000.
+     */
+    clientPingTimeoutMS: number;
+}
+/**
+ * Encapsulates the Slack-specific details around establishing a WebSocket connection with the Slack backend.
+ * Manages the ping/pong heartbeat of the connection.
+ */
+export declare class SlackWebSocket {
+    private static loggerName;
+    private options;
+    private logger;
+    private websocket;
+    /**
+     * The last timetamp that this WebSocket received pong from the server
+     */
+    private lastPongReceivedTimestamp;
+    /**
+     * Sentinel checking if Slack sent us a close frame or not, in order to be able
+     * to terminate underlying socket gracefully.
+     */
+    private closeFrameReceived;
+    /**
+     * Reference to the timeout timer we use to listen to pings from the server
+     */
+    private serverPingTimeout;
+    /**
+     * Reference to the timeout timer we use to listen to pongs from the server
+     */
+    private clientPingTimeout;
+    constructor({ url, client, httpAgent, logger, logLevel, pingInterval, pingPongLoggingEnabled, serverPingTimeoutMS, clientPingTimeoutMS, }: SlackWebSocketOptions);
+    /**
+     * Establishes a connection with the Slack backend
+     */
+    connect(): void;
+    /**
+     * Disconnects the WebSocket connection with Slack, if connected.
+     */
+    disconnect(): void;
+    /**
+     * Clean up any underlying intervals, timeouts and the WebSocket.
+     */
+    private terminate;
+    /**
+     * Returns true if the underlying WebSocket connection is active, meaning the underlying
+     * {@link https://github.com/websockets/ws/blob/master/doc/ws.md#ready-state-constants WebSocket ready state is "OPEN"}.
+     */
+    isActive(): boolean;
+    /**
+     * Retrieve the underlying WebSocket readyState. Returns `undefined` if the WebSocket has not been instantiated,
+     * otherwise will return a number between 0 and 3 inclusive representing the ready states.
+     * The ready state constants are documented in the {@link https://github.com/websockets/ws/blob/master/doc/ws.md#ready-state-constants `ws` API docs }
+     */
+    get readyState(): number | undefined;
+    /**
+     * Sends data via the underlying WebSocket. Accepts an errorback argument.
+     */
+    send(data: string, cb: (err: Error | undefined) => void): void;
+    /**
+     * Confirms WebSocket connection is still active; fires whenever a ping event is received
+     * If we don't receive another ping from the peer before the timeout, we initiate closing the connection.
+     */
+    private monitorPingFromSlack;
+    /**
+     * Monitors WebSocket connection health; sends a ping to peer, and expects a pong within a certain timeframe.
+     * If that expectation is not met, we disconnect the websocket.
+     */
+    private monitorPingToSlack;
+}
+//# sourceMappingURL=SlackWebSocket.d.ts.map

package/node_modules/@slack/bolt/node_modules/@slack/socket-mode/dist/src/SlackWebSocket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SlackWebSocket.d.ts","sourceRoot":"","sources":["../../src/SlackWebSocket.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC;AAEvC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAIlD,OAAY,EAAE,KAAK,MAAM,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAGtD,eAAO,MAAM,eAAe,UAA8C,CAAC;AAE3E,MAAM,WAAW,qBAAqB;IACpC,0DAA0D;IAC1D,GAAG,EAAE,MAAM,CAAC;IACZ,8FAA8F;IAC9F,MAAM,EAAE,YAAY,CAAC;IACrB,iEAAiE;IACjE,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,8DAA8D;IAC9D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,wFAAwF;IACxF,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,mFAAmF;IACnF,SAAS,CAAC,EAAE,KAAK,CAAC;IAClB,qGAAqG;IACrG,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC;;;OAGG;IACH,mBAAmB,EAAE,MAAM,CAAC;IAC5B;;;OAGG;IACH,mBAAmB,EAAE,MAAM,CAAC;CAC7B;AAED;;;GAGG;AACH,qBAAa,cAAc;IAEzB,OAAO,CAAC,MAAM,CAAC,UAAU,CAAoB;IAE7C,OAAO,CAAC,OAAO,CAAwB;IAEvC,OAAO,CAAC,MAAM,CAAS;IAEvB,OAAO,CAAC,SAAS,CAAmB;IAEpC;;OAEG;IACH,OAAO,CAAC,yBAAyB,CAAqB;IAEtD;;;OAGG;IACH,OAAO,CAAC,kBAAkB,CAAU;IAEpC;;OAEG;IACH,OAAO,CAAC,iBAAiB,CAA6B;IAEtD;;OAEG;IACH,OAAO,CAAC,iBAAiB,CAA6B;gBAEnC,EACjB,GAAG,EACH,MAAM,EACN,SAAS,EACT,MAAM,EACN,QAAwB,EACxB,YAAmB,EACnB,sBAA8B,EAC9B,mBAA2B,EAC3B,mBAA0B,GAC3B,EAAE,qBAAqB;IAoBxB;;OAEG;IACI,OAAO,IAAI,IAAI;IA6CtB;;OAEG;IACI,UAAU,IAAI,IAAI;IAwBzB;;OAEG;IACH,OAAO,CAAC,SAAS;IAWjB;;;OAGG;IACI,QAAQ,IAAI,OAAO;IAU1B;;;;OAIG;IACH,IAAW,UAAU,IAAI,MAAM,GAAG,SAAS,CAE1C;IAED;;OAEG;IACI,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,KAAK,GAAG,SAAS,KAAK,IAAI,GAAG,IAAI;IAIrE;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAU5B;;;OAGG;IACH,OAAO,CAAC,kBAAkB;CAwC3B"}

package/node_modules/@slack/bolt/node_modules/@slack/socket-mode/dist/src/SlackWebSocket.js

@@ -0,0 +1,242 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlackWebSocket = exports.WS_READY_STATES = void 0;
+const ws_1 = require("ws");
+const errors_1 = require("./errors");
+const logger_1 = __importStar(require("./logger"));
+// Maps ws `readyState` to human readable labels https://github.com/websockets/ws/blob/HEAD/doc/ws.md#ready-state-constants
+exports.WS_READY_STATES = ['CONNECTING', 'OPEN', 'CLOSING', 'CLOSED'];
+/**
+ * Encapsulates the Slack-specific details around establishing a WebSocket connection with the Slack backend.
+ * Manages the ping/pong heartbeat of the connection.
+ */
+class SlackWebSocket {
+    constructor({ url, client, httpAgent, logger, logLevel = logger_1.LogLevel.INFO, pingInterval = 5000, pingPongLoggingEnabled = false, serverPingTimeoutMS = 30000, clientPingTimeoutMS = 5000, }) {
+        this.options = {
+            url,
+            client,
+            httpAgent,
+            logLevel,
+            pingInterval,
+            pingPongLoggingEnabled,
+            serverPingTimeoutMS,
+            clientPingTimeoutMS,
+        };
+        if (logger) {
+            this.logger = logger;
+        }
+        else {
+            this.logger = logger_1.default.getLogger(SlackWebSocket.loggerName, logLevel);
+        }
+        this.websocket = null;
+        this.closeFrameReceived = false;
+    }
+    /**
+     * Establishes a connection with the Slack backend
+     */
+    connect() {
+        this.logger.debug('Initiating new WebSocket connection.');
+        const options = {
+            perMessageDeflate: false,
+            agent: this.options.httpAgent,
+        };
+        this.websocket = new ws_1.WebSocket(this.options.url, options);
+        this.websocket.addEventListener('open', (_event) => {
+            this.logger.debug('WebSocket open event received (connection established)!');
+            this.monitorPingToSlack();
+        });
+        this.websocket.addEventListener('error', (event) => {
+            this.logger.error(`WebSocket error occurred: ${event.message}`);
+            this.disconnect();
+            this.options.client.emit('error', (0, errors_1.websocketErrorWithOriginal)(event.error));
+        });
+        this.websocket.on('message', (msg, isBinary) => {
+            this.options.client.emit('ws_message', msg, isBinary);
+        });
+        this.websocket.on('close', (code, data) => {
+            this.logger.debug(`WebSocket close frame received (code: ${code}, reason: ${data.toString()})`);
+            this.closeFrameReceived = true;
+            this.disconnect();
+        });
+        // Confirm WebSocket connection is still active
+        this.websocket.on('ping', (data) => {
+            // Note that ws' `autoPong` option is true by default, so no need to respond to ping.
+            // see https://github.com/websockets/ws/blob/2aa0405a5e96754b296fef6bd6ebdfb2f11967fc/doc/ws.md#new-websocketaddress-protocols-options
+            if (this.options.pingPongLoggingEnabled) {
+                this.logger.debug(`WebSocket received ping from Slack server (data: ${data.toString()})`);
+            }
+            this.monitorPingFromSlack();
+        });
+        this.websocket.on('pong', (data) => {
+            if (this.options.pingPongLoggingEnabled) {
+                this.logger.debug(`WebSocket received pong from Slack server (data: ${data.toString()})`);
+            }
+            this.lastPongReceivedTimestamp = Date.now();
+        });
+    }
+    /**
+     * Disconnects the WebSocket connection with Slack, if connected.
+     */
+    disconnect() {
+        if (this.websocket) {
+            // Disconnecting a WebSocket involves a close frame handshake so we check if we've already received a close frame.
+            // If so, we can terminate the underlying socket connection and let the client know.
+            if (this.closeFrameReceived) {
+                this.logger.debug('Terminating WebSocket (close frame received).');
+                this.terminate();
+            }
+            else if (this.websocket.readyState === ws_1.WebSocket.CLOSING) {
+                // A close frame was already sent but the peer hasn't responded. Force-terminate rather than
+                // waiting for the ws library's closeTimeout (~30s) while the ping monitor logs repeated warnings.
+                this.logger.debug('Terminating WebSocket (close frame sent but no response, force-terminating).');
+                this.terminate();
+            }
+            else {
+                // If we haven't received a close frame yet, then we send one to the peer, expecting to receive a close frame
+                // in response.
+                this.logger.debug('Sending close frame (status=1000).');
+                this.websocket.close(1000); // 1000 = Normal Closure
+            }
+        }
+        else {
+            this.logger.debug('WebSocket already disconnected, flushing remainder.');
+            this.terminate();
+        }
+    }
+    /**
+     * Clean up any underlying intervals, timeouts and the WebSocket.
+     */
+    terminate() {
+        var _a, _b;
+        (_a = this.websocket) === null || _a === void 0 ? void 0 : _a.removeAllListeners();
+        (_b = this.websocket) === null || _b === void 0 ? void 0 : _b.terminate();
+        this.websocket = null;
+        clearTimeout(this.serverPingTimeout);
+        clearInterval(this.clientPingTimeout);
+        // Emit event back to client letting it know connection has closed (in case it needs to reconnect if
+        // reconnecting is enabled)
+        this.options.client.emit('close');
+    }
+    /**
+     * Returns true if the underlying WebSocket connection is active, meaning the underlying
+     * {@link https://github.com/websockets/ws/blob/master/doc/ws.md#ready-state-constants WebSocket ready state is "OPEN"}.
+     */
+    isActive() {
+        // python equiv: SocketModeClient.is_connected
+        if (!this.websocket) {
+            this.logger.debug('isActive(): websocket not instantiated!');
+            return false;
+        }
+        this.logger.debug(`isActive(): websocket ready state is ${exports.WS_READY_STATES[this.websocket.readyState]}`);
+        return this.websocket.readyState === 1; // readyState=1 is "OPEN"
+    }
+    /**
+     * Retrieve the underlying WebSocket readyState. Returns `undefined` if the WebSocket has not been instantiated,
+     * otherwise will return a number between 0 and 3 inclusive representing the ready states.
+     * The ready state constants are documented in the {@link https://github.com/websockets/ws/blob/master/doc/ws.md#ready-state-constants `ws` API docs }
+     */
+    get readyState() {
+        var _a;
+        return (_a = this.websocket) === null || _a === void 0 ? void 0 : _a.readyState;
+    }
+    /**
+     * Sends data via the underlying WebSocket. Accepts an errorback argument.
+     */
+    send(data, cb) {
+        var _a;
+        (_a = this.websocket) === null || _a === void 0 ? void 0 : _a.send(data, cb);
+    }
+    /**
+     * Confirms WebSocket connection is still active; fires whenever a ping event is received
+     * If we don't receive another ping from the peer before the timeout, we initiate closing the connection.
+     */
+    monitorPingFromSlack() {
+        clearTimeout(this.serverPingTimeout);
+        this.serverPingTimeout = setTimeout(() => {
+            this.logger.warn(`A ping wasn't received from the server before the timeout of ${this.options.serverPingTimeoutMS}ms!`);
+            this.disconnect();
+        }, this.options.serverPingTimeoutMS);
+    }
+    /**
+     * Monitors WebSocket connection health; sends a ping to peer, and expects a pong within a certain timeframe.
+     * If that expectation is not met, we disconnect the websocket.
+     */
+    monitorPingToSlack() {
+        this.lastPongReceivedTimestamp = undefined;
+        let pingAttemptCount = 0;
+        clearInterval(this.clientPingTimeout);
+        this.clientPingTimeout = setInterval(() => {
+            var _a;
+            const now = Date.now();
+            try {
+                const pingMessage = `Ping from client (${now})`;
+                (_a = this.websocket) === null || _a === void 0 ? void 0 : _a.ping(pingMessage);
+                if (this.lastPongReceivedTimestamp === undefined) {
+                    pingAttemptCount += 1;
+                }
+                else {
+                    // if lastPongReceivedTimestamp is defined, then the server has responded to pings at some point in the past
+                    pingAttemptCount = 0;
+                }
+                if (this.options.pingPongLoggingEnabled) {
+                    this.logger.debug(`Sent ping to Slack: ${pingMessage}`);
+                }
+            }
+            catch (e) {
+                this.logger.error(`Failed to send ping to Slack (error: ${e})`);
+                this.disconnect();
+                return;
+            }
+            // default invalid state is: sent > 3 pings to the server and it never responded with a pong
+            let isInvalid = pingAttemptCount > 3;
+            if (this.lastPongReceivedTimestamp !== undefined) {
+                // secondary invalid state is: if we did receive a pong from the server,
+                // has the elapsed time since the last pong exceeded the client ping timeout
+                const millis = now - this.lastPongReceivedTimestamp;
+                isInvalid = millis > this.options.clientPingTimeoutMS;
+            }
+            if (isInvalid) {
+                this.logger.warn(`A pong wasn't received from the server before the timeout of ${this.options.clientPingTimeoutMS}ms!`);
+                this.disconnect();
+            }
+        }, this.options.clientPingTimeoutMS / 3);
+        this.logger.debug('Started monitoring pings to and pongs from Slack.');
+    }
+}
+exports.SlackWebSocket = SlackWebSocket;
+// python equiv: Connection
+SlackWebSocket.loggerName = 'SlackWebSocket';
+//# sourceMappingURL=SlackWebSocket.js.map