@inkeep/agents-work-apps 0.50.0 → 0.50.3

package/dist/_virtual/rolldown_runtime.js

@@ -0,0 +1,32 @@
+import { createRequire } from "node:module";
+
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+export { __commonJSMin, __require, __toESM };

package/dist/env.d.ts

@@ -33,6 +33,7 @@ declare const envSchema: z.ZodObject<{
   SLACK_SIGNING_SECRET: z.ZodOptional<z.ZodString>;
   SLACK_BOT_TOKEN: z.ZodOptional<z.ZodString>;
   SLACK_APP_URL: z.ZodOptional<z.ZodString>;
+  SLACK_APP_TOKEN: z.ZodOptional<z.ZodString>;
   NANGO_SECRET_KEY: z.ZodOptional<z.ZodString>;
   NANGO_SLACK_SECRET_KEY: z.ZodOptional<z.ZodString>;
   NANGO_SLACK_INTEGRATION_ID: z.ZodOptional<z.ZodString>;
@@ -57,6 +58,7 @@ declare const env: {
   SLACK_SIGNING_SECRET?: string | undefined;
   SLACK_BOT_TOKEN?: string | undefined;
   SLACK_APP_URL?: string | undefined;
+  SLACK_APP_TOKEN?: string | undefined;
   NANGO_SECRET_KEY?: string | undefined;
   NANGO_SLACK_SECRET_KEY?: string | undefined;
   NANGO_SLACK_INTEGRATION_ID?: string | undefined;

package/dist/env.js

@@ -35,6 +35,7 @@ const envSchema = z.object({
 	SLACK_SIGNING_SECRET: z.string().optional().describe("Slack App Signing Secret"),
 	SLACK_BOT_TOKEN: z.string().optional().describe("Slack Bot Token (for testing)"),
 	SLACK_APP_URL: z.string().optional().describe("Slack App Install URL"),
+	SLACK_APP_TOKEN: z.string().optional().describe("Slack App-Level Token for Socket Mode (xapp-*)"),
 	NANGO_SECRET_KEY: z.string().optional().describe("Nango Secret Key"),
 	NANGO_SLACK_SECRET_KEY: z.string().optional().describe("Nango Slack-specific Secret Key"),
 	NANGO_SLACK_INTEGRATION_ID: z.string().optional().describe("Nango Slack Integration ID"),

package/dist/github/mcp/auth.d.ts

@@ -1,7 +1,7 @@
-import * as hono0 from "hono";
+import * as hono1 from "hono";
 
 //#region src/github/mcp/auth.d.ts
-declare const githubMcpAuth: () => hono0.MiddlewareHandler<{
+declare const githubMcpAuth: () => hono1.MiddlewareHandler<{
   Variables: {
     toolId: string;
   };

package/dist/github/mcp/index.d.ts

@@ -1,11 +1,11 @@
 import { Hono } from "hono";
-import * as hono_types7 from "hono/types";
+import * as hono_types9 from "hono/types";
 
 //#region src/github/mcp/index.d.ts
 declare const app: Hono<{
   Variables: {
     toolId: string;
   };
-}, hono_types7.BlankSchema, "/">;
+}, hono_types9.BlankSchema, "/">;
 //#endregion
 export { app as default };

package/dist/github/mcp/schemas.d.ts

@@ -76,8 +76,8 @@ declare const ChangedFileSchema: z.ZodObject<{
   path: z.ZodString;
   status: z.ZodEnum<{
     added: "added";
-    removed: "removed";
     modified: "modified";
+    removed: "removed";
     renamed: "renamed";
     copied: "copied";
     changed: "changed";

package/dist/github/routes/tokenExchange.d.ts

@@ -1,7 +1,7 @@
 import { Hono } from "hono";
-import * as hono_types8 from "hono/types";
+import * as hono_types5 from "hono/types";
 
 //#region src/github/routes/tokenExchange.d.ts
-declare const app: Hono<hono_types8.BlankEnv, hono_types8.BlankSchema, "/">;
+declare const app: Hono<hono_types5.BlankEnv, hono_types5.BlankSchema, "/">;
 //#endregion
 export { app as default };

package/dist/github/routes/webhooks.d.ts

@@ -1,5 +1,5 @@
 import { Hono } from "hono";
-import * as hono_types5 from "hono/types";
+import * as hono_types7 from "hono/types";
 
 //#region src/github/routes/webhooks.d.ts
 interface WebhookVerificationResult {
@@ -7,6 +7,6 @@ interface WebhookVerificationResult {
   error?: string;
 }
 declare function verifyWebhookSignature(payload: string, signature: string | undefined, secret: string): WebhookVerificationResult;
-declare const app: Hono<hono_types5.BlankEnv, hono_types5.BlankSchema, "/">;
+declare const app: Hono<hono_types7.BlankEnv, hono_types7.BlankSchema, "/">;
 //#endregion
 export { WebhookVerificationResult, app as default, verifyWebhookSignature };

package/dist/node_modules/.pnpm/@slack_logger@4.0.0/node_modules/@slack/logger/dist/index.js

@@ -0,0 +1,89 @@
+import { __commonJSMin } from "../../../../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../node_modules/.pnpm/@slack+logger@4.0.0/node_modules/@slack/logger/dist/index.js
+var require_dist = /* @__PURE__ */ __commonJSMin(((exports) => {
+	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 || (exports.LogLevel = {}));
+	/**
+	* Default logger which logs to stdout and stderr
+	*/
+	var ConsoleLogger = 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
+		*/
+		debug(...msg) {
+			if (ConsoleLogger.isMoreOrEqualSevere(LogLevel.DEBUG, this.level)) console.debug(ConsoleLogger.labels.get(LogLevel.DEBUG), this.name, ...msg);
+		}
+		/**
+		* Log an info message
+		*/
+		info(...msg) {
+			if (ConsoleLogger.isMoreOrEqualSevere(LogLevel.INFO, this.level)) console.info(ConsoleLogger.labels.get(LogLevel.INFO), this.name, ...msg);
+		}
+		/**
+		* Log a warning message
+		*/
+		warn(...msg) {
+			if (ConsoleLogger.isMoreOrEqualSevere(LogLevel.WARN, this.level)) console.warn(ConsoleLogger.labels.get(LogLevel.WARN), this.name, ...msg);
+		}
+		/**
+		* Log an error message
+		*/
+		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 map = Object.entries(LogLevel).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
+	};
+}));
+
+//#endregion
+export default require_dist();
+
+export { require_dist };

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

@@ -0,0 +1,85 @@
+import { __commonJSMin } from "../../../../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../node_modules/.pnpm/@slack+socket-mode@2.0.5/node_modules/@slack/socket-mode/dist/package.json
+var require_package = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		"name": "@slack/socket-mode",
+		"version": "2.0.5",
+		"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": "slackapi/node-slack-sdk",
+		"homepage": "https://tools.slack.dev/node-slack-sdk/socket-mode",
+		"publishConfig": { "access": "public" },
+		"bugs": { "url": "https://github.com/slackapi/node-slack-sdk/issues" },
+		"scripts": {
+			"prepare": "npm run build",
+			"build": "npm run build:clean && tsc",
+			"build:clean": "shx rm -rf ./dist ./coverage",
+			"docs": "npx typedoc --plugin typedoc-plugin-markdown",
+			"lint": "npx @biomejs/biome check .",
+			"lint:fix": "npx @biomejs/biome check --write .",
+			"test:unit": "mocha --config ./test/.mocharc.json src/**/*.spec.ts",
+			"test:coverage": "c8 --config ./test/.c8rc.json npm run test:unit",
+			"test:integration": "mocha --config ./test/.mocharc.json test/integration.spec.js",
+			"test": "npm run lint && npm run build && npm run test:coverage && npm run test:integration",
+			"watch": "npx nodemon --watch 'src' --ext 'ts' --exec npm test"
+		},
+		"dependencies": {
+			"@slack/logger": "^4",
+			"@slack/web-api": "^7.10.0",
+			"@types/node": ">=18",
+			"@types/ws": "^8",
+			"eventemitter3": "^5",
+			"ws": "^8"
+		},
+		"devDependencies": {
+			"@biomejs/biome": "^2.0.5",
+			"@tsconfig/recommended": "^1.0.7",
+			"@types/chai": "^4",
+			"@types/mocha": "^10",
+			"@types/proxyquire": "^1.3.31",
+			"@types/sinon": "^17",
+			"c8": "^10.1.2",
+			"chai": "^4",
+			"mocha": "^11",
+			"mocha-junit-reporter": "^2.2.1",
+			"mocha-multi-reporters": "^1.5.1",
+			"nodemon": "^3.1.0",
+			"proxyquire": "^2.1.3",
+			"shx": "^0.4.0",
+			"sinon": "^21",
+			"source-map-support": "^0.5.21",
+			"ts-node": "^10",
+			"typedoc": "^0.28.7",
+			"typedoc-plugin-markdown": "^4.7.0",
+			"typescript": "5.9.2"
+		}
+	};
+}));
+
+//#endregion
+export default require_package();
+
+export { require_package };

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

@@ -0,0 +1,223 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/rolldown_runtime.js";
+import { require_errors } from "./errors.js";
+import { require_logger } from "./logger.js";
+import { require_ws } from "../../../../../../ws@8.19.0/node_modules/ws/index.js";
+
+//#region ../../node_modules/.pnpm/@slack+socket-mode@2.0.5/node_modules/@slack/socket-mode/dist/src/SlackWebSocket.js
+var require_SlackWebSocket = /* @__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;
+		};
+	})();
+	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());
+	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.
+	*/
+	var SlackWebSocket = class SlackWebSocket {
+		constructor({ url, client, httpAgent, logger, logLevel = logger_1.LogLevel.INFO, pingInterval = 5e3, pingPongLoggingEnabled = false, serverPingTimeoutMS = 3e4, clientPingTimeoutMS = 5e3 }) {
+			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();
+			});
+			this.websocket.on("ping", (data) => {
+				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) if (this.closeFrameReceived) {
+				this.logger.debug("Terminating WebSocket (close frame received).");
+				this.terminate();
+			} else {
+				this.logger.debug("Sending close frame (status=1000).");
+				this.websocket.close(1e3);
+			}
+			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 || _a.removeAllListeners();
+			(_b = this.websocket) === null || _b === void 0 || _b.terminate();
+			this.websocket = null;
+			clearTimeout(this.serverPingTimeout);
+			clearInterval(this.clientPingTimeout);
+			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() {
+			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;
+		}
+		/**
+		* 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 || _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 = void 0;
+			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 || _a.ping(pingMessage);
+					if (this.lastPongReceivedTimestamp === void 0) pingAttemptCount += 1;
+					else 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;
+				}
+				let isInvalid = pingAttemptCount > 3;
+				if (this.lastPongReceivedTimestamp !== void 0) isInvalid = now - this.lastPongReceivedTimestamp > 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;
+	SlackWebSocket.loggerName = "SlackWebSocket";
+}));
+
+//#endregion
+export default require_SlackWebSocket();
+
+export { require_SlackWebSocket };