@inkeep/agents-work-apps 0.0.0-dev-20260219045007 → 0.0.0-dev-20260219103848

package/dist/slack/routes/events.js

@@ -3,17 +3,13 @@ import { getLogger } from "../../logger.js";
 import runDbClient_default from "../../db/runDbClient.js";
 import { findWorkspaceConnectionByTeamId, getSlackIntegrationId, getSlackNango, updateConnectionMetadata } from "../services/nango.js";
 import { getSlackClient, getSlackUserInfo } from "../services/client.js";
-import { sendResponseUrlMessage } from "../services/events/utils.js";
 import { handleCommand } from "../services/commands/index.js";
 import { SLACK_SPAN_KEYS, SLACK_SPAN_NAMES, tracer } from "../tracer.js";
-import { handleAppMention } from "../services/events/app-mention.js";
-import { handleMessageShortcut, handleOpenAgentSelectorModal, handleOpenFollowUpModal } from "../services/events/block-actions.js";
-import { handleFollowUpSubmission, handleModalSubmission } from "../services/events/modal-submission.js";
-import "../services/events/index.js";
 import { parseSlackCommandBody, parseSlackEventBody, verifySlackRequest } from "../services/security.js";
 import "../services/index.js";
+import { dispatchSlackEvent } from "../dispatcher.js";
 import { OpenAPIHono } from "@hono/zod-openapi";
-import { deleteAllWorkAppSlackChannelAgentConfigsByTeam, deleteAllWorkAppSlackUserMappingsByTeam, deleteWorkAppSlackWorkspaceByNangoConnectionId, flushTraces, getWaitUntil } from "@inkeep/agents-core";
+import { deleteAllWorkAppSlackChannelAgentConfigsByTeam, deleteAllWorkAppSlackUserMappingsByTeam, deleteWorkAppSlackWorkspaceByNangoConnectionId, getWaitUntil } from "@inkeep/agents-core";
 import { SpanStatusCode } from "@opentelemetry/api";
 
 //#region src/slack/routes/events.ts
@@ -122,328 +118,14 @@ app.post("/events", async (c) => {
 				span.end();
 				return c.text(String(eventBody.challenge));
 			}
-			if (eventType === "event_callback") {
-				const teamId = eventBody.team_id;
-				const event = eventBody.event;
-				const innerEventType = event?.type || "unknown";
-				span.setAttribute(SLACK_SPAN_KEYS.INNER_EVENT_TYPE, innerEventType);
-				if (teamId) span.setAttribute(SLACK_SPAN_KEYS.TEAM_ID, teamId);
-				if (event?.channel) span.setAttribute(SLACK_SPAN_KEYS.CHANNEL_ID, event.channel);
-				if (event?.user) span.setAttribute(SLACK_SPAN_KEYS.USER_ID, event.user);
-				span.updateName(`${SLACK_SPAN_NAMES.WEBHOOK} event_callback.${innerEventType}`);
-				if (event?.bot_id || event?.subtype === "bot_message") {
-					outcome = "ignored_bot_message";
-					span.setAttribute(SLACK_SPAN_KEYS.IS_BOT_MESSAGE, true);
-					span.setAttribute(SLACK_SPAN_KEYS.OUTCOME, outcome);
-					logger.info({
-						botId: event.bot_id,
-						subtype: event?.subtype,
-						teamId,
-						innerEventType
-					}, "Ignoring bot message");
-					span.end();
-					return c.json({ ok: true });
-				}
-				if (event?.type === "app_mention" && event.channel && event.user && teamId) {
-					outcome = "handled";
-					span.setAttribute(SLACK_SPAN_KEYS.OUTCOME, outcome);
-					const question = (event.text || "").replace(/<@[A-Z0-9]+>/g, "").trim();
-					span.setAttribute(SLACK_SPAN_KEYS.HAS_QUERY, question.length > 0);
-					if (event.thread_ts) span.setAttribute(SLACK_SPAN_KEYS.THREAD_TS, event.thread_ts);
-					if (event.ts) span.setAttribute(SLACK_SPAN_KEYS.MESSAGE_TS, event.ts);
-					logger.info({
-						userId: event.user,
-						channel: event.channel,
-						teamId,
-						hasQuery: question.length > 0
-					}, "Handling event: app_mention");
-					const dispatchedAt = Date.now();
-					const mentionWork = handleAppMention({
-						slackUserId: event.user,
-						channel: event.channel,
-						text: question,
-						threadTs: event.thread_ts || event.ts || "",
-						messageTs: event.ts || "",
-						teamId,
-						dispatchedAt
-					}).catch((err) => {
-						const errorMessage = err instanceof Error ? err.message : String(err);
-						const errorStack = err instanceof Error ? err.stack : void 0;
-						logger.error({
-							errorMessage,
-							errorStack
-						}, "Failed to handle app mention (outer catch)");
-					}).finally(() => flushTraces());
-					if (waitUntil) {
-						waitUntil(mentionWork);
-						logger.info({
-							teamId,
-							channel: event.channel,
-							dispatchedAt
-						}, "app_mention work registered with waitUntil");
-					} else logger.warn({
-						teamId,
-						channel: event.channel,
-						dispatchedAt
-					}, "waitUntil unavailable — app_mention background work is untracked fire-and-forget");
-				} else {
-					outcome = "ignored_unknown_event";
-					span.setAttribute(SLACK_SPAN_KEYS.OUTCOME, outcome);
-					logger.info({
-						innerEventType,
-						teamId
-					}, `Ignoring unhandled event_callback: ${innerEventType}`);
-				}
-			}
-			if (eventType === "block_actions" || eventType === "interactive_message") {
-				const actions = eventBody.actions;
-				const teamId = eventBody.team?.id;
-				const responseUrl = eventBody.response_url;
-				const triggerId = eventBody.trigger_id;
-				const actionIds = actions?.map((a) => a.action_id) || [];
-				if (teamId) span.setAttribute(SLACK_SPAN_KEYS.TEAM_ID, teamId);
-				span.setAttribute(SLACK_SPAN_KEYS.ACTION_IDS, actionIds.join(","));
-				span.updateName(`${SLACK_SPAN_NAMES.WEBHOOK} ${eventType} [${actionIds.join(",")}]`);
-				if (actions && teamId) {
-					let anyHandled = false;
-					for (const action of actions) {
-						if (action.action_id === "open_agent_selector_modal" && action.value && triggerId) {
-							anyHandled = true;
-							logger.info({
-								teamId,
-								actionId: action.action_id
-							}, "Handling block_action: open_agent_selector_modal");
-							const selectorWork = handleOpenAgentSelectorModal({
-								triggerId,
-								actionValue: action.value,
-								teamId,
-								responseUrl: responseUrl || ""
-							}).catch(async (err) => {
-								const errorMessage = err instanceof Error ? err.message : String(err);
-								logger.error({
-									errorMessage,
-									actionId: action.action_id
-								}, "Failed to open agent selector modal");
-								if (responseUrl) await sendResponseUrlMessage(responseUrl, {
-									text: "Sorry, something went wrong while opening the agent selector. Please try again.",
-									response_type: "ephemeral"
-								}).catch((e) => logger.warn({ error: e }, "Failed to send error notification via response URL"));
-							}).finally(() => flushTraces());
-							if (waitUntil) waitUntil(selectorWork);
-						}
-						if (action.action_id === "modal_project_select") {
-							anyHandled = true;
-							const selectedProjectId = action.selected_option?.value;
-							const view = eventBody.view;
-							logger.info({
-								teamId,
-								actionId: action.action_id,
-								selectedProjectId
-							}, "Handling block_action: modal_project_select");
-							if (selectedProjectId && view?.id) {
-								const projectSelectWork = (async () => {
-									try {
-										const metadata = JSON.parse(view.private_metadata || "{}");
-										const tenantId = metadata.tenantId;
-										if (!tenantId) {
-											logger.warn({ teamId }, "No tenantId in modal metadata — skipping project update");
-											return;
-										}
-										const workspace = await findWorkspaceConnectionByTeamId(teamId);
-										if (!workspace?.botToken) return;
-										const slackClient = getSlackClient(workspace.botToken);
-										const { fetchProjectsForTenant, fetchAgentsForProject } = await import("../services/events/utils.js");
-										const { buildAgentSelectorModal, buildMessageShortcutModal } = await import("../services/modals.js");
-										const projectList = await fetchProjectsForTenant(tenantId);
-										const agentList = await fetchAgentsForProject(tenantId, selectedProjectId);
-										const agentOptions = agentList.map((a) => ({
-											id: a.id,
-											name: a.name,
-											projectId: a.projectId,
-											projectName: a.projectName || a.projectId
-										}));
-										const modal = metadata.messageContext ? buildMessageShortcutModal({
-											projects: projectList,
-											agents: agentOptions,
-											metadata,
-											selectedProjectId,
-											messageContext: metadata.messageContext
-										}) : buildAgentSelectorModal({
-											projects: projectList,
-											agents: agentOptions,
-											metadata,
-											selectedProjectId
-										});
-										await slackClient.views.update({
-											view_id: view.id,
-											view: modal
-										});
-										logger.debug({
-											selectedProjectId,
-											agentCount: agentList.length
-										}, "Updated modal with agents for selected project");
-									} catch (err) {
-										logger.error({
-											err,
-											selectedProjectId
-										}, "Failed to update modal on project change");
-									} finally {
-										await flushTraces();
-									}
-								})();
-								if (waitUntil) waitUntil(projectSelectWork);
-							}
-						}
-						if (action.action_id === "open_follow_up_modal" && action.value && triggerId) {
-							anyHandled = true;
-							logger.info({
-								teamId,
-								actionId: action.action_id
-							}, "Handling block_action: open_follow_up_modal");
-							const followUpModalWork = handleOpenFollowUpModal({
-								triggerId,
-								actionValue: action.value,
-								teamId,
-								responseUrl: responseUrl || void 0
-							}).catch((err) => {
-								const errorMessage = err instanceof Error ? err.message : String(err);
-								logger.error({
-									errorMessage,
-									actionId: action.action_id
-								}, "Failed to open follow-up modal");
-							}).finally(() => flushTraces());
-							if (waitUntil) waitUntil(followUpModalWork);
-						}
-					}
-					outcome = anyHandled ? "handled" : "ignored_no_action_match";
-					span.setAttribute(SLACK_SPAN_KEYS.OUTCOME, outcome);
-					if (!anyHandled) logger.info({
-						teamId,
-						actionIds,
-						eventType
-					}, "Ignoring block_actions: no matching action handlers");
-				} else {
-					outcome = "ignored_no_action_match";
-					span.setAttribute(SLACK_SPAN_KEYS.OUTCOME, outcome);
-					logger.info({
-						teamId,
-						eventType,
-						hasActions: Boolean(actions)
-					}, "Ignoring block_actions: missing actions or teamId");
-				}
-			}
-			if (eventType === "message_action") {
-				const callbackId = eventBody.callback_id;
-				span.setAttribute(SLACK_SPAN_KEYS.CALLBACK_ID, callbackId || "unknown");
-				span.updateName(`${SLACK_SPAN_NAMES.WEBHOOK} message_action.${callbackId || "unknown"}`);
-				if (callbackId === "ask_agent_shortcut") {
-					const triggerId = eventBody.trigger_id;
-					const teamId = eventBody.team?.id;
-					const channelId = eventBody.channel?.id;
-					const userId = eventBody.user?.id;
-					const message = eventBody.message;
-					const responseUrl = eventBody.response_url;
-					if (teamId) span.setAttribute(SLACK_SPAN_KEYS.TEAM_ID, teamId);
-					if (channelId) span.setAttribute(SLACK_SPAN_KEYS.CHANNEL_ID, channelId);
-					if (userId) span.setAttribute(SLACK_SPAN_KEYS.USER_ID, userId);
-					if (triggerId && teamId && channelId && userId && message?.ts) {
-						outcome = "handled";
-						span.setAttribute(SLACK_SPAN_KEYS.OUTCOME, outcome);
-						logger.info({
-							teamId,
-							channelId,
-							userId,
-							callbackId
-						}, "Handling message_action: ask_agent_shortcut");
-						const shortcutWork = handleMessageShortcut({
-							triggerId,
-							teamId,
-							channelId,
-							userId,
-							messageTs: message.ts,
-							messageText: message.text || "",
-							threadTs: message.thread_ts,
-							responseUrl
-						}).catch((err) => {
-							const errorMessage = err instanceof Error ? err.message : String(err);
-							logger.error({
-								errorMessage,
-								callbackId
-							}, "Failed to handle message shortcut");
-						}).finally(() => flushTraces());
-						if (waitUntil) waitUntil(shortcutWork);
-					} else {
-						outcome = "ignored_unknown_event";
-						span.setAttribute(SLACK_SPAN_KEYS.OUTCOME, outcome);
-						logger.info({
-							teamId,
-							channelId,
-							userId,
-							callbackId,
-							hasTriggerId: Boolean(triggerId)
-						}, "Ignoring message_action: missing required fields");
-					}
-				} else {
-					outcome = "ignored_unknown_event";
-					span.setAttribute(SLACK_SPAN_KEYS.OUTCOME, outcome);
-					logger.info({ callbackId }, `Ignoring unhandled message_action: ${callbackId}`);
-				}
-			}
-			if (eventType === "view_submission") {
-				const callbackId = eventBody.view?.callback_id;
-				span.setAttribute(SLACK_SPAN_KEYS.CALLBACK_ID, callbackId || "unknown");
-				span.updateName(`${SLACK_SPAN_NAMES.WEBHOOK} view_submission.${callbackId || "unknown"}`);
-				if (callbackId === "agent_selector_modal") {
-					const view = eventBody.view;
-					const agentSelect = view.state?.values?.agent_select_block?.agent_select;
-					if (!agentSelect?.selected_option?.value || agentSelect.selected_option.value === "none") {
-						outcome = "validation_error";
-						span.setAttribute(SLACK_SPAN_KEYS.OUTCOME, outcome);
-						logger.info({ callbackId }, "Rejecting view_submission: no agent selected");
-						span.end();
-						return c.json({
-							response_action: "errors",
-							errors: { agent_select_block: "Please select an agent. If none are available, add agents to this project in the dashboard." }
-						});
-					}
-					outcome = "handled";
-					span.setAttribute(SLACK_SPAN_KEYS.OUTCOME, outcome);
-					logger.info({ callbackId }, "Handling view_submission: agent_selector_modal");
-					const modalWork = handleModalSubmission(view).catch((err) => {
-						const errorMessage = err instanceof Error ? err.message : String(err);
-						logger.error({
-							errorMessage,
-							callbackId
-						}, "Failed to handle modal submission");
-					}).finally(() => flushTraces());
-					if (waitUntil) waitUntil(modalWork);
-					span.end();
-					return new Response(null, { status: 200 });
-				}
-				if (callbackId === "follow_up_modal") {
-					const view = eventBody.view;
-					outcome = "handled";
-					span.setAttribute(SLACK_SPAN_KEYS.OUTCOME, outcome);
-					logger.info({ callbackId }, "Handling view_submission: follow_up_modal");
-					const followUpWork = handleFollowUpSubmission(view).catch((err) => {
-						const errorMessage = err instanceof Error ? err.message : String(err);
-						logger.error({
-							errorMessage,
-							callbackId
-						}, "Failed to handle follow-up submission");
-					}).finally(() => flushTraces());
-					if (waitUntil) waitUntil(followUpWork);
-					span.end();
-					return new Response(null, { status: 200 });
-				}
-				outcome = "ignored_unknown_event";
-				span.setAttribute(SLACK_SPAN_KEYS.OUTCOME, outcome);
-				logger.info({ callbackId }, `Ignoring unhandled view_submission: ${callbackId}`);
-			}
-			if (eventType !== "event_callback" && eventType !== "block_actions" && eventType !== "interactive_message" && eventType !== "message_action" && eventType !== "view_submission") {
-				outcome = "ignored_unknown_event";
-				span.setAttribute(SLACK_SPAN_KEYS.OUTCOME, outcome);
-				logger.info({ eventType }, `Ignoring unhandled Slack event type: ${eventType}`);
+			const registerBackgroundWork = (work) => {
+				if (waitUntil) waitUntil(work);
+			};
+			const result = await dispatchSlackEvent(eventType || "", eventBody, { registerBackgroundWork }, span);
+			outcome = result.outcome;
+			if (result.response) {
+				span.end();
+				return c.json(result.response);
 			}
 			span.end();
 			return c.json({ ok: true });

package/dist/slack/socket-mode.d.ts

@@ -0,0 +1,4 @@
+//#region src/slack/socket-mode.d.ts
+declare function startSocketMode(appToken: string): Promise<void>;
+//#endregion
+export { startSocketMode };

package/dist/slack/socket-mode.js

@@ -0,0 +1,130 @@
+import { __toESM } from "../_virtual/rolldown_runtime.js";
+import { getLogger } from "../logger.js";
+import { handleCommand } from "./services/commands/index.js";
+import { SLACK_SPAN_KEYS, SLACK_SPAN_NAMES, tracer } from "./tracer.js";
+import "./services/index.js";
+import { dispatchSlackEvent } from "./dispatcher.js";
+import { flushTraces } from "@inkeep/agents-core";
+import { SpanStatusCode } from "@opentelemetry/api";
+
+//#region src/slack/socket-mode.ts
+const logger = getLogger("slack-socket-mode");
+const GLOBAL_KEY = "__inkeep_slack_socket_mode_client__";
+async function startSocketMode(appToken) {
+	if (globalThis[GLOBAL_KEY]) {
+		logger.info({}, "Socket Mode client already running (HMR reload detected), skipping");
+		return;
+	}
+	const { SocketModeClient } = await import("../node_modules/.pnpm/@slack_socket-mode@2.0.5/node_modules/@slack/socket-mode/dist/src/index.js").then((m) => /* @__PURE__ */ __toESM(m.default, 1));
+	const client = new SocketModeClient({ appToken });
+	setupSocketModeListeners(client);
+	await client.start();
+	globalThis[GLOBAL_KEY] = client;
+	logger.info({}, "Slack Socket Mode client started");
+}
+function registerBackgroundWork(work) {
+	work.catch((err) => {
+		logger.error({ error: err }, "Background work failed in Socket Mode");
+	});
+}
+function setupSocketModeListeners(client) {
+	client.on("error", (...args) => {
+		logger.error({ error: args[0] }, "Socket Mode client error");
+	});
+	client.on("disconnected", () => {
+		logger.warn({}, "Socket Mode client disconnected");
+	});
+	client.on("reconnecting", () => {
+		logger.info({}, "Socket Mode client reconnecting...");
+	});
+	client.on("slack_event", async (...args) => {
+		const { ack, body, type } = args[0];
+		if (type !== "events_api") return;
+		await ack();
+		await tracer.startActiveSpan(SLACK_SPAN_NAMES.WEBHOOK, async (span) => {
+			try {
+				const eventType = body.event?.type ? "event_callback" : body.type || "";
+				span.setAttribute(SLACK_SPAN_KEYS.EVENT_TYPE, eventType);
+				span.updateName(`${SLACK_SPAN_NAMES.WEBHOOK} ${eventType}`);
+				await dispatchSlackEvent(eventType, body, { registerBackgroundWork }, span);
+			} catch (error) {
+				span.setAttribute(SLACK_SPAN_KEYS.OUTCOME, "error");
+				span.setStatus({
+					code: SpanStatusCode.ERROR,
+					message: String(error)
+				});
+				if (error instanceof Error) span.recordException(error);
+				logger.error({ error }, "Error handling Socket Mode event");
+			} finally {
+				span.end();
+				await flushTraces();
+			}
+		});
+	});
+	client.on("interactive", async (...args) => {
+		const { ack, body } = args[0];
+		const eventType = body.type || "";
+		await ack((await tracer.startActiveSpan(`${SLACK_SPAN_NAMES.WEBHOOK} ${eventType}`, async (span) => {
+			try {
+				span.setAttribute(SLACK_SPAN_KEYS.EVENT_TYPE, eventType);
+				return await dispatchSlackEvent(eventType, body, { registerBackgroundWork }, span);
+			} catch (error) {
+				span.setAttribute(SLACK_SPAN_KEYS.OUTCOME, "error");
+				span.setStatus({
+					code: SpanStatusCode.ERROR,
+					message: String(error)
+				});
+				if (error instanceof Error) span.recordException(error);
+				logger.error({ error }, "Error handling Socket Mode interactive event");
+				return { outcome: "error" };
+			} finally {
+				span.end();
+			}
+		})).response);
+		await flushTraces();
+	});
+	client.on("slash_commands", async (...args) => {
+		const { ack, body } = args[0];
+		await ack();
+		await tracer.startActiveSpan(`${SLACK_SPAN_NAMES.WEBHOOK} slash_command`, async (span) => {
+			try {
+				span.setAttribute(SLACK_SPAN_KEYS.EVENT_TYPE, "slash_command");
+				if (body.command) span.setAttribute("slack.command", body.command);
+				if (body.team_id) span.setAttribute(SLACK_SPAN_KEYS.TEAM_ID, body.team_id);
+				const commandPayload = {
+					command: body.command || "",
+					text: body.text || "",
+					userId: body.user_id || "",
+					userName: body.user_name || "",
+					teamId: body.team_id || "",
+					teamDomain: body.team_domain || "",
+					enterpriseId: body.enterprise_id,
+					channelId: body.channel_id || "",
+					channelName: body.channel_name || "",
+					responseUrl: body.response_url || "",
+					triggerId: body.trigger_id || ""
+				};
+				const response = await handleCommand(commandPayload);
+				if (Object.keys(response).length > 0 && commandPayload.responseUrl) await fetch(commandPayload.responseUrl, {
+					method: "POST",
+					headers: { "Content-Type": "application/json" },
+					body: JSON.stringify(response)
+				});
+			} catch (error) {
+				span.setAttribute(SLACK_SPAN_KEYS.OUTCOME, "error");
+				span.setStatus({
+					code: SpanStatusCode.ERROR,
+					message: String(error)
+				});
+				if (error instanceof Error) span.recordException(error);
+				logger.error({ error }, "Error handling Socket Mode slash command");
+			} finally {
+				span.end();
+				await flushTraces();
+			}
+		});
+	});
+}
+
+//#endregion
+export { startSocketMode };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inkeep/agents-work-apps",
-  "version": "0.0.0-dev-20260219045007",
+  "version": "0.0.0-dev-20260219103848",
   "description": "First party integrations for Inkeep Agents",
   "type": "module",
   "license": "SEE LICENSE IN LICENSE.md",
@@ -33,13 +33,14 @@
     "jose": "^6.1.0",
     "minimatch": "^10.1.1",
     "slack-block-builder": "^2.8.0",
-    "@inkeep/agents-core": "0.0.0-dev-20260219045007"
+    "@inkeep/agents-core": "0.0.0-dev-20260219103848"
   },
   "peerDependencies": {
     "@hono/zod-openapi": "^1.1.5",
     "zod": "^4.3.6"
   },
   "devDependencies": {
+    "@slack/socket-mode": "^2.0.5",
     "@types/node": "^20.11.24",
     "typescript": "^5.9.2",
     "vitest": "^3.2.4"