@inkeep/agents-work-apps 0.50.1 → 0.50.4

package/dist/node_modules/.pnpm/@slack_socket-mode@2.0.5/node_modules/@slack/socket-mode/dist/src/SocketModeClient.js

@@ -0,0 +1,367 @@
+import { __commonJSMin, __require } from "../../../../../../../../_virtual/rolldown_runtime.js";
+import { require_errors } from "./errors.js";
+import { require_logger } from "./logger.js";
+import { require_eventemitter3 } from "../../../../../../eventemitter3@5.0.1/node_modules/eventemitter3/index.js";
+import { require_package } from "../package.js";
+import { require_SlackWebSocket } from "./SlackWebSocket.js";
+import { require_UnrecoverableSocketModeStartError } from "./UnrecoverableSocketModeStartError.js";
+
+//#region ../../node_modules/.pnpm/@slack+socket-mode@2.0.5/node_modules/@slack/socket-mode/dist/src/SocketModeClient.js
+var require_SocketModeClient = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+		if (k2 === void 0) 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 === void 0) k2 = k;
+		o[k2] = m[k];
+	}));
+	var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+		Object.defineProperty(o, "default", {
+			enumerable: true,
+			value: v
+		});
+	}) : function(o, v) {
+		o["default"] = v;
+	});
+	var __importStar = exports && exports.__importStar || (function() {
+		var ownKeys = function(o) {
+			ownKeys = Object.getOwnPropertyNames || function(o$1) {
+				var ar = [];
+				for (var k in o$1) if (Object.prototype.hasOwnProperty.call(o$1, 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;
+		};
+	})();
+	var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+		function adopt(value) {
+			return value instanceof P ? value : new P(function(resolve) {
+				resolve(value);
+			});
+		}
+		return new (P || (P = Promise))(function(resolve, reject) {
+			function fulfilled(value) {
+				try {
+					step(generator.next(value));
+				} catch (e) {
+					reject(e);
+				}
+			}
+			function rejected(value) {
+				try {
+					step(generator["throw"](value));
+				} catch (e) {
+					reject(e);
+				}
+			}
+			function step(result) {
+				result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+			}
+			step((generator = generator.apply(thisArg, _arguments || [])).next());
+		});
+	};
+	var __importDefault = exports && exports.__importDefault || function(mod) {
+		return mod && mod.__esModule ? mod : { "default": mod };
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.SocketModeClient = void 0;
+	const web_api_1 = __require("@slack/web-api");
+	const eventemitter3_1 = require_eventemitter3();
+	const package_json_1 = __importDefault(require_package());
+	const errors_1 = require_errors();
+	const logger_1 = __importStar(require_logger());
+	const SlackWebSocket_1 = require_SlackWebSocket();
+	const UnrecoverableSocketModeStartError_1 = require_UnrecoverableSocketModeStartError();
+	var State;
+	(function(State) {
+		State["Connecting"] = "connecting";
+		State["Connected"] = "connected";
+		State["Reconnecting"] = "reconnecting";
+		State["Disconnecting"] = "disconnecting";
+		State["Disconnected"] = "disconnected";
+		State["Authenticated"] = "authenticated";
+	})(State || (State = {}));
+	/**
+	* A Socket Mode Client allows programs to communicate with the
+	* [Slack Platform's Events API](https://https://docs.slack.dev/apis/events-api) over WebSocket connections.
+	* This object uses the EventEmitter pattern to dispatch incoming events
+	* and has a built in send method to acknowledge incoming events over the WebSocket connection.
+	*/
+	var SocketModeClient = class SocketModeClient extends eventemitter3_1.EventEmitter {
+		constructor({ logger = void 0, logLevel = void 0, autoReconnectEnabled = true, pingPongLoggingEnabled = false, clientPingTimeout = 5e3, serverPingTimeout = 3e4, appToken = "", clientOptions = {} } = { appToken: "" }) {
+			super();
+			/**
+			* Internal count for managing the reconnection state
+			*/
+			this.numOfConsecutiveReconnectionFailures = 0;
+			this.customLoggerProvided = false;
+			/**
+			* Sentinel tracking if user invoked `disconnect()`; for enforcing shutting down of client
+			* even if `autoReconnectEnabled` is `true`.
+			*/
+			this.shuttingDown = false;
+			if (!appToken) throw new Error("Must provide an App-Level Token when initializing a Socket Mode Client");
+			this.pingPongLoggingEnabled = pingPongLoggingEnabled;
+			this.clientPingTimeoutMS = clientPingTimeout;
+			this.serverPingTimeoutMS = serverPingTimeout;
+			if (typeof logger !== "undefined") {
+				this.customLoggerProvided = true;
+				this.logger = logger;
+				if (typeof logLevel !== "undefined") this.logger.debug("The logLevel given to Socket Mode was ignored as you also gave logger");
+			} else this.logger = logger_1.default.getLogger(SocketModeClient.loggerName, logLevel !== null && logLevel !== void 0 ? logLevel : logger_1.LogLevel.INFO, logger);
+			this.webClientOptions = clientOptions;
+			if (this.webClientOptions.retryConfig === void 0) this.webClientOptions.retryConfig = {
+				retries: 100,
+				factor: 1.3
+			};
+			this.webClient = new web_api_1.WebClient("", Object.assign({
+				logger,
+				logLevel: this.logger.getLevel(),
+				headers: { Authorization: `Bearer ${appToken}` }
+			}, clientOptions));
+			this.autoReconnectEnabled = autoReconnectEnabled;
+			this.on("error", (err) => {
+				this.logger.error(`WebSocket error! ${err}`);
+			});
+			this.on("close", () => {
+				if (!this.shuttingDown && this.autoReconnectEnabled) this.delayReconnectAttempt(this.start);
+				else this.emit(State.Disconnected);
+			});
+			this.on("ws_message", this.onWebSocketMessage.bind(this));
+			this.logger.debug("The Socket Mode client has successfully initialized");
+		}
+		/**
+		* Start a Socket Mode session app.
+		* This method must be called before any messages can be sent or received,
+		* or to disconnect the client via the `disconnect` method.
+		*/
+		start() {
+			return __awaiter(this, void 0, void 0, function* () {
+				this.shuttingDown = false;
+				this.logger.debug("Starting Socket Mode session ...");
+				this.websocket = new SlackWebSocket_1.SlackWebSocket({
+					url: yield this.retrieveWSSURL(),
+					client: this,
+					logLevel: this.logger.getLevel(),
+					logger: this.customLoggerProvided ? this.logger : void 0,
+					httpAgent: this.webClientOptions.agent,
+					clientPingTimeoutMS: this.clientPingTimeoutMS,
+					serverPingTimeoutMS: this.serverPingTimeoutMS,
+					pingPongLoggingEnabled: this.pingPongLoggingEnabled
+				});
+				return new Promise((resolve, reject) => {
+					var _a;
+					let connectedCallback = (_res) => {};
+					let disconnectedCallback = (_err) => {};
+					connectedCallback = (result) => {
+						this.removeListener(State.Disconnected, disconnectedCallback);
+						resolve(result);
+					};
+					disconnectedCallback = (err) => {
+						this.removeListener(State.Connected, connectedCallback);
+						reject(err);
+					};
+					this.once(State.Connected, connectedCallback);
+					this.once(State.Disconnected, disconnectedCallback);
+					this.emit(State.Connecting);
+					(_a = this.websocket) === null || _a === void 0 || _a.connect();
+				});
+			});
+		}
+		/**
+		* End a Socket Mode session. After this method is called no messages will be sent or received
+		* unless you call start() again later.
+		*/
+		disconnect() {
+			this.shuttingDown = true;
+			this.logger.debug("Manually disconnecting this Socket Mode client");
+			this.emit(State.Disconnecting);
+			return new Promise((resolve, _reject) => {
+				var _a;
+				if (!this.websocket) {
+					this.emit(State.Disconnected);
+					resolve();
+				} else {
+					this.once(State.Disconnected, resolve);
+					(_a = this.websocket) === null || _a === void 0 || _a.disconnect();
+				}
+			});
+		}
+		/**
+		* Initiates a reconnect, taking into account configurable delays and number of reconnect attempts and failures.
+		* Accepts a callback to invoke after any calculated delays.
+		*/
+		delayReconnectAttempt(cb) {
+			this.numOfConsecutiveReconnectionFailures += 1;
+			const msBeforeRetry = this.clientPingTimeoutMS * this.numOfConsecutiveReconnectionFailures;
+			this.logger.debug(`Before trying to reconnect, this client will wait for ${msBeforeRetry} milliseconds`);
+			return new Promise((res, _rej) => {
+				setTimeout(() => {
+					if (this.shuttingDown) this.logger.debug("Client shutting down, will not attempt reconnect.");
+					else {
+						this.logger.debug("Continuing with reconnect...");
+						this.emit(State.Reconnecting);
+						cb.apply(this).then(res);
+					}
+				}, msBeforeRetry);
+			});
+		}
+		/**
+		* Retrieves a new WebSocket URL to connect to.
+		*/
+		retrieveWSSURL() {
+			return __awaiter(this, void 0, void 0, function* () {
+				try {
+					this.logger.debug("Going to retrieve a new WSS URL ...");
+					const resp = yield this.webClient.apps.connections.open({});
+					if (!resp.url) {
+						const msg = `apps.connections.open did not return a URL! (response: ${resp})`;
+						this.logger.error(msg);
+						throw new Error(msg);
+					}
+					this.numOfConsecutiveReconnectionFailures = 0;
+					this.emit(State.Authenticated, resp);
+					return resp.url;
+				} catch (error) {
+					this.logger.error(`Failed to retrieve a new WSS URL (error: ${error})`);
+					const err = error;
+					let isRecoverable = true;
+					if (err.code === web_api_1.ErrorCode.PlatformError && Object.values(UnrecoverableSocketModeStartError_1.UnrecoverableSocketModeStartError).includes(err.data.error)) isRecoverable = false;
+					else if (err.code === web_api_1.ErrorCode.RequestError) isRecoverable = false;
+					else if (err.code === web_api_1.ErrorCode.HTTPError) isRecoverable = false;
+					if (this.autoReconnectEnabled && isRecoverable) return yield this.delayReconnectAttempt(this.retrieveWSSURL);
+					throw error;
+				}
+			});
+		}
+		/**
+		* `onmessage` handler for the client's WebSocket.
+		* This will parse the payload and dispatch the application-relevant events for each incoming message.
+		* Mediates:
+		* - raising the State.Connected event (when Slack sends a type:hello message)
+		* - disconnecting the underlying socket (when Slack sends a type:disconnect message)
+		*/
+		onWebSocketMessage(data, isBinary) {
+			return __awaiter(this, void 0, void 0, function* () {
+				var _a;
+				if (isBinary) {
+					this.logger.debug("Unexpected binary message received, ignoring.");
+					return;
+				}
+				const payload = data.toString();
+				this.logger.debug(`Received a message on the WebSocket: ${payload}`);
+				let event;
+				try {
+					event = JSON.parse(payload);
+				} catch (parseError) {
+					this.logger.debug(`Unable to parse an incoming WebSocket message (will ignore): ${parseError}, ${payload}`);
+					return;
+				}
+				if (event.type === "hello") {
+					this.emit(State.Connected);
+					return;
+				}
+				if (event.type === "disconnect") {
+					this.logger.debug(`Received "${event.type}" (${event.reason}) message - disconnecting.${this.autoReconnectEnabled ? " Will reconnect." : ""}`);
+					(_a = this.websocket) === null || _a === void 0 || _a.disconnect();
+					return;
+				}
+				const ack = (response) => __awaiter(this, void 0, void 0, function* () {
+					if (this.logger.getLevel() === logger_1.LogLevel.DEBUG) this.logger.debug(`Calling ack() - type: ${event.type}, envelope_id: ${event.envelope_id}, data: ${JSON.stringify(response)}`);
+					yield this.send(event.envelope_id, response);
+				});
+				if (event.type === "events_api") this.emit(event.payload.event.type, {
+					ack,
+					envelope_id: event.envelope_id,
+					body: event.payload,
+					event: event.payload.event,
+					retry_num: event.retry_attempt,
+					retry_reason: event.retry_reason,
+					accepts_response_payload: event.accepts_response_payload
+				});
+				else this.emit(event.type, {
+					ack,
+					envelope_id: event.envelope_id,
+					body: event.payload,
+					accepts_response_payload: event.accepts_response_payload
+				});
+				this.emit("slack_event", {
+					ack,
+					envelope_id: event.envelope_id,
+					type: event.type,
+					body: event.payload,
+					retry_num: event.retry_attempt,
+					retry_reason: event.retry_reason,
+					accepts_response_payload: event.accepts_response_payload
+				});
+			});
+		}
+		/**
+		* Method for sending an outgoing message of an arbitrary type over the WebSocket connection.
+		* Primarily used to send acknowledgements back to slack for incoming events
+		* @param id the envelope id
+		* @param body the message body or string text
+		*/
+		send(id, body = {}) {
+			const _body = typeof body === "string" ? { text: body } : body;
+			const message = {
+				envelope_id: id,
+				payload: Object.assign({}, _body)
+			};
+			return new Promise((resolve, reject) => {
+				var _a;
+				const wsState = (_a = this.websocket) === null || _a === void 0 ? void 0 : _a.readyState;
+				this.logger.debug(`send() method was called (WebSocket state: ${wsState ? SlackWebSocket_1.WS_READY_STATES[wsState] : "uninitialized"})`);
+				if (this.websocket === void 0) {
+					this.logger.error("Failed to send a message as the client is not connected");
+					reject((0, errors_1.sendWhileDisconnectedError)());
+				} else if (!this.websocket.isActive()) {
+					this.logger.error("Failed to send a message as the client has no active connection");
+					reject((0, errors_1.sendWhileNotReadyError)());
+				} else {
+					this.emit("outgoing_message", message);
+					const flatMessage = JSON.stringify(message);
+					this.logger.debug(`Sending a WebSocket message: ${flatMessage}`);
+					this.websocket.send(flatMessage, (error) => {
+						if (error) {
+							this.logger.error(`Failed to send a WebSocket message (error: ${error})`);
+							return reject((0, errors_1.websocketErrorWithOriginal)(error));
+						}
+						return resolve();
+					});
+				}
+			});
+		}
+	};
+	exports.SocketModeClient = SocketModeClient;
+	/**
+	* The name used to prefix all logging generated from this class
+	*/
+	SocketModeClient.loggerName = "SocketModeClient";
+	(0, web_api_1.addAppMetadata)({
+		name: package_json_1.default.name,
+		version: package_json_1.default.version
+	});
+	exports.default = SocketModeClient;
+}));
+
+//#endregion
+export default require_SocketModeClient();
+
+export { require_SocketModeClient };

package/dist/node_modules/.pnpm/@slack_socket-mode@2.0.5/node_modules/@slack/socket-mode/dist/src/UnrecoverableSocketModeStartError.js

@@ -0,0 +1,20 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../node_modules/.pnpm/@slack+socket-mode@2.0.5/node_modules/@slack/socket-mode/dist/src/UnrecoverableSocketModeStartError.js
+var require_UnrecoverableSocketModeStartError = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.UnrecoverableSocketModeStartError = void 0;
+	var UnrecoverableSocketModeStartError;
+	(function(UnrecoverableSocketModeStartError) {
+		UnrecoverableSocketModeStartError["NotAuthed"] = "not_authed";
+		UnrecoverableSocketModeStartError["InvalidAuth"] = "invalid_auth";
+		UnrecoverableSocketModeStartError["AccountInactive"] = "account_inactive";
+		UnrecoverableSocketModeStartError["UserRemovedFromTeam"] = "user_removed_from_team";
+		UnrecoverableSocketModeStartError["TeamDisabled"] = "team_disabled";
+	})(UnrecoverableSocketModeStartError || (exports.UnrecoverableSocketModeStartError = UnrecoverableSocketModeStartError = {}));
+}));
+
+//#endregion
+export default require_UnrecoverableSocketModeStartError();
+
+export { require_UnrecoverableSocketModeStartError };

package/dist/node_modules/.pnpm/@slack_socket-mode@2.0.5/node_modules/@slack/socket-mode/dist/src/errors.js

@@ -0,0 +1,71 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../node_modules/.pnpm/@slack+socket-mode@2.0.5/node_modules/@slack/socket-mode/dist/src/errors.js
+var require_errors = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.ErrorCode = void 0;
+	exports.websocketErrorWithOriginal = websocketErrorWithOriginal;
+	exports.platformErrorFromEvent = platformErrorFromEvent;
+	exports.noReplyReceivedError = noReplyReceivedError;
+	exports.sendWhileDisconnectedError = sendWhileDisconnectedError;
+	exports.sendWhileNotReadyError = sendWhileNotReadyError;
+	/**
+	* A dictionary of codes for errors produced by this package
+	*/
+	var ErrorCode;
+	(function(ErrorCode) {
+		ErrorCode["SendWhileDisconnectedError"] = "slack_socket_mode_send_while_disconnected_error";
+		ErrorCode["SendWhileNotReadyError"] = "slack_socket_mode_send_while_not_ready_error";
+		ErrorCode["SendMessagePlatformError"] = "slack_socket_mode_send_message_platform_error";
+		ErrorCode["WebsocketError"] = "slack_socket_mode_websocket_error";
+		ErrorCode["NoReplyReceivedError"] = "slack_socket_mode_no_reply_received_error";
+		ErrorCode["InitializationError"] = "slack_socket_mode_initialization_error";
+	})(ErrorCode || (exports.ErrorCode = ErrorCode = {}));
+	/**
+	* Factory for producing a {@link CodedError} from a generic error
+	*/
+	function errorWithCode(error, code) {
+		const codedError = error;
+		codedError.code = code;
+		return codedError;
+	}
+	/**
+	* A factory to create SMWebsocketError objects.
+	*/
+	function websocketErrorWithOriginal(original) {
+		const error = errorWithCode(new Error(original.message), ErrorCode.WebsocketError);
+		error.original = original;
+		return error;
+	}
+	/**
+	* A factory to create SMPlatformError objects.
+	*/
+	function platformErrorFromEvent(event) {
+		const error = errorWithCode(/* @__PURE__ */ new Error(`An API error occurred: ${event.error.msg}`), ErrorCode.SendMessagePlatformError);
+		error.data = event;
+		return error;
+	}
+	/**
+	* A factory to create SMNoReplyReceivedError objects.
+	*/
+	function noReplyReceivedError() {
+		return errorWithCode(/* @__PURE__ */ new Error("Message sent but no server acknowledgement was received. This may be caused by the client changing connection state rather than any issue with the specific message. Check before resending."), ErrorCode.NoReplyReceivedError);
+	}
+	/**
+	* A factory to create SMSendWhileDisconnectedError objects.
+	*/
+	function sendWhileDisconnectedError() {
+		return errorWithCode(/* @__PURE__ */ new Error("Failed to send a WebSocket message as the client is not connected"), ErrorCode.NoReplyReceivedError);
+	}
+	/**
+	* A factory to create SMSendWhileNotReadyError objects.
+	*/
+	function sendWhileNotReadyError() {
+		return errorWithCode(/* @__PURE__ */ new Error("Failed to send a WebSocket message as the client is not ready"), ErrorCode.NoReplyReceivedError);
+	}
+}));
+
+//#endregion
+export default require_errors();
+
+export { require_errors };

package/dist/node_modules/.pnpm/@slack_socket-mode@2.0.5/node_modules/@slack/socket-mode/dist/src/index.js

@@ -0,0 +1,44 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/rolldown_runtime.js";
+import { require_errors } from "./errors.js";
+import { require_logger } from "./logger.js";
+import { require_UnrecoverableSocketModeStartError } from "./UnrecoverableSocketModeStartError.js";
+import { require_SocketModeClient } from "./SocketModeClient.js";
+
+//#region ../../node_modules/.pnpm/@slack+socket-mode@2.0.5/node_modules/@slack/socket-mode/dist/src/index.js
+var require_src = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.UnrecoverableSocketModeStartError = exports.SocketModeClient = exports.LogLevel = exports.ErrorCode = void 0;
+	var errors_1 = require_errors();
+	Object.defineProperty(exports, "ErrorCode", {
+		enumerable: true,
+		get: function() {
+			return errors_1.ErrorCode;
+		}
+	});
+	var logger_1 = require_logger();
+	Object.defineProperty(exports, "LogLevel", {
+		enumerable: true,
+		get: function() {
+			return logger_1.LogLevel;
+		}
+	});
+	var SocketModeClient_1 = require_SocketModeClient();
+	Object.defineProperty(exports, "SocketModeClient", {
+		enumerable: true,
+		get: function() {
+			return SocketModeClient_1.SocketModeClient;
+		}
+	});
+	var UnrecoverableSocketModeStartError_1 = require_UnrecoverableSocketModeStartError();
+	Object.defineProperty(exports, "UnrecoverableSocketModeStartError", {
+		enumerable: true,
+		get: function() {
+			return UnrecoverableSocketModeStartError_1.UnrecoverableSocketModeStartError;
+		}
+	});
+}));
+
+//#endregion
+export default require_src();
+
+export {  };

package/dist/node_modules/.pnpm/@slack_socket-mode@2.0.5/node_modules/@slack/socket-mode/dist/src/logger.js

@@ -0,0 +1,32 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/rolldown_runtime.js";
+import { require_dist } from "../../../../../../@slack_logger@4.0.0/node_modules/@slack/logger/dist/index.js";
+
+//#region ../../node_modules/.pnpm/@slack+socket-mode@2.0.5/node_modules/@slack/socket-mode/dist/src/logger.js
+var require_logger = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.LogLevel = void 0;
+	const logger_1 = require_dist();
+	Object.defineProperty(exports, "LogLevel", {
+		enumerable: true,
+		get: function() {
+			return logger_1.LogLevel;
+		}
+	});
+	let instanceCount = 0;
+	exports.default = { getLogger: function getLogger(name, level, existingLogger) {
+		const instanceId = instanceCount;
+		instanceCount += 1;
+		const logger = (() => {
+			if (existingLogger !== void 0) return existingLogger;
+			return new logger_1.ConsoleLogger();
+		})();
+		logger.setName(`socket-mode:${name}:${instanceId}`);
+		if (level !== void 0) logger.setLevel(level);
+		return logger;
+	} };
+}));
+
+//#endregion
+export default require_logger();
+
+export { require_logger };