botmancers 0.5.0 → 0.6.1

package/app/node_modules/@slack/logger/dist/index.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleLogger = exports.LogLevel = void 0;
+/**
+ * Severity levels for log entries
+ */
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["ERROR"] = "error";
+    LogLevel["WARN"] = "warn";
+    LogLevel["INFO"] = "info";
+    LogLevel["DEBUG"] = "debug";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+/**
+ * Default logger which logs to stdout and stderr
+ */
+class ConsoleLogger {
+    constructor() {
+        this.level = LogLevel.INFO;
+        this.name = '';
+    }
+    getLevel() {
+        return this.level;
+    }
+    /**
+     * Sets the instance's log level so that only messages which are equal or more severe are output to the console.
+     */
+    setLevel(level) {
+        this.level = level;
+    }
+    /**
+     * Set the instance's name, which will appear on each log line before the message.
+     */
+    setName(name) {
+        this.name = name;
+    }
+    /**
+     * Log a debug message
+     */
+    // biome-ignore lint/suspicious/noExplicitAny: can log anything
+    debug(...msg) {
+        if (ConsoleLogger.isMoreOrEqualSevere(LogLevel.DEBUG, this.level)) {
+            console.debug(ConsoleLogger.labels.get(LogLevel.DEBUG), this.name, ...msg);
+        }
+    }
+    /**
+     * Log an info message
+     */
+    // biome-ignore lint/suspicious/noExplicitAny: can log anything
+    info(...msg) {
+        if (ConsoleLogger.isMoreOrEqualSevere(LogLevel.INFO, this.level)) {
+            console.info(ConsoleLogger.labels.get(LogLevel.INFO), this.name, ...msg);
+        }
+    }
+    /**
+     * Log a warning message
+     */
+    // biome-ignore lint/suspicious/noExplicitAny: can log anything
+    warn(...msg) {
+        if (ConsoleLogger.isMoreOrEqualSevere(LogLevel.WARN, this.level)) {
+            console.warn(ConsoleLogger.labels.get(LogLevel.WARN), this.name, ...msg);
+        }
+    }
+    /**
+     * Log an error message
+     */
+    // biome-ignore lint/suspicious/noExplicitAny: can log anything
+    error(...msg) {
+        if (ConsoleLogger.isMoreOrEqualSevere(LogLevel.ERROR, this.level)) {
+            console.error(ConsoleLogger.labels.get(LogLevel.ERROR), this.name, ...msg);
+        }
+    }
+    /**
+     * Helper to compare two log levels and determine if a is equal or more severe than b
+     */
+    static isMoreOrEqualSevere(a, b) {
+        return ConsoleLogger.severity[a] >= ConsoleLogger.severity[b];
+    }
+}
+exports.ConsoleLogger = ConsoleLogger;
+/** Map of labels for each log level */
+ConsoleLogger.labels = (() => {
+    const entries = Object.entries(LogLevel);
+    const map = entries.map(([key, value]) => [value, `[${key}] `]);
+    return new Map(map);
+})();
+/** Map of severity as comparable numbers for each log level */
+ConsoleLogger.severity = {
+    [LogLevel.ERROR]: 400,
+    [LogLevel.WARN]: 300,
+    [LogLevel.INFO]: 200,
+    [LogLevel.DEBUG]: 100,
+};
+//# sourceMappingURL=index.js.map

package/app/node_modules/@slack/logger/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@slack/logger",
+  "version": "4.0.1",
+  "description": "Logging utility used by Node Slack SDK",
+  "author": "Slack Technologies, LLC",
+  "license": "MIT",
+  "keywords": [
+    "slack",
+    "logging"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/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/",
+  "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",
+    "test:node18": "npm run build && node --test --test-reporter=spec --import tsx --test src/index.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/index.test.ts"
+  },
+  "dependencies": {
+    "@types/node": ">=18"
+  }
+}

package/app/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/app/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