@inkeep/agents-work-apps 0.0.0-dev-20260211191741 → 0.0.0-dev-20260211220939

package/dist/slack/routes/events.js

@@ -0,0 +1,390 @@
+import { env } from "../../env.js";
+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 { 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 { OpenAPIHono } from "@hono/zod-openapi";
+import { deleteAllWorkAppSlackChannelAgentConfigsByTeam, deleteAllWorkAppSlackUserMappingsByTeam, deleteWorkAppSlackWorkspaceByNangoConnectionId } from "@inkeep/agents-core";
+
+//#region src/slack/routes/events.ts
+/**
+* Slack Events Routes
+*
+* Endpoints for handling Slack events, commands, and webhooks:
+* - POST /commands - Handle /inkeep slash commands
+* - POST /events - Handle Slack events & interactivity
+* - POST /nango-webhook - Handle Nango auth webhooks
+*/
+const logger = getLogger("slack-events");
+const app = new OpenAPIHono();
+app.post("/commands", async (c) => {
+	const body = await c.req.text();
+	const timestamp = c.req.header("x-slack-request-timestamp") || "";
+	const signature = c.req.header("x-slack-signature") || "";
+	if (!env.SLACK_SIGNING_SECRET) {
+		logger.error({}, "SLACK_SIGNING_SECRET not configured - rejecting request");
+		return c.json({
+			response_type: "ephemeral",
+			text: "Server configuration error"
+		}, 500);
+	}
+	if (!verifySlackRequest(env.SLACK_SIGNING_SECRET, body, timestamp, signature)) {
+		logger.error({}, "Invalid Slack request signature");
+		return c.json({
+			response_type: "ephemeral",
+			text: "Invalid request signature"
+		}, 401);
+	}
+	const params = parseSlackCommandBody(body);
+	const response = await handleCommand({
+		command: params.command || "",
+		text: params.text || "",
+		userId: params.user_id || "",
+		userName: params.user_name || "",
+		teamId: params.team_id || "",
+		teamDomain: params.team_domain || "",
+		enterpriseId: params.enterprise_id,
+		channelId: params.channel_id || "",
+		channelName: params.channel_name || "",
+		responseUrl: params.response_url || "",
+		triggerId: params.trigger_id || ""
+	});
+	if (Object.keys(response).length === 0) return c.body(null, 200);
+	return c.json(response);
+});
+app.post("/events", async (c) => {
+	const contentType = c.req.header("content-type") || "";
+	const body = await c.req.text();
+	const timestamp = c.req.header("x-slack-request-timestamp") || "";
+	const signature = c.req.header("x-slack-signature") || "";
+	let eventBody;
+	try {
+		eventBody = parseSlackEventBody(body, contentType);
+	} catch (error) {
+		logger.error({
+			error,
+			contentType,
+			bodyPreview: body.slice(0, 200)
+		}, "Failed to parse Slack event body");
+		return c.json({ error: "Invalid payload" }, 400);
+	}
+	logger.debug({ eventType: eventBody.type }, "Slack event received");
+	const eventType = eventBody.type;
+	if (eventType === "url_verification") {
+		logger.info({}, "Responding to Slack URL verification challenge");
+		return c.text(String(eventBody.challenge));
+	}
+	if (!env.SLACK_SIGNING_SECRET) {
+		logger.error({}, "SLACK_SIGNING_SECRET not configured - rejecting request");
+		return c.json({ error: "Server configuration error" }, 500);
+	}
+	if (!verifySlackRequest(env.SLACK_SIGNING_SECRET, body, timestamp, signature)) {
+		logger.error({}, "Invalid Slack request signature");
+		return c.json({ error: "Invalid request signature" }, 401);
+	}
+	if (eventType === "event_callback") {
+		const teamId = eventBody.team_id;
+		const event = eventBody.event;
+		if (event?.bot_id || event?.subtype === "bot_message") {
+			logger.debug({ botId: event.bot_id }, "Ignoring bot message");
+			return c.json({ ok: true });
+		}
+		logger.debug({
+			eventType: event?.type,
+			teamId
+		}, "Slack event callback");
+		if (event?.type === "app_mention" && event.channel && event.user && teamId) {
+			const question = (event.text || "").replace(/<@[A-Z0-9]+>/g, "").trim();
+			logger.info({
+				userId: event.user,
+				channel: event.channel,
+				teamId
+			}, "Bot was mentioned");
+			handleAppMention({
+				slackUserId: event.user,
+				channel: event.channel,
+				text: question,
+				threadTs: event.thread_ts || event.ts || "",
+				messageTs: event.ts || "",
+				teamId
+			}).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)");
+			});
+		}
+	}
+	if (eventType === "block_actions" || eventType === "interactive_message") {
+		logger.debug({ eventType }, "Slack interactive event received");
+		const actions = eventBody.actions;
+		const teamId = eventBody.team?.id;
+		const responseUrl = eventBody.response_url;
+		const triggerId = eventBody.trigger_id;
+		if (actions && teamId) for (const action of actions) {
+			if (action.action_id === "open_agent_selector_modal" && action.value && triggerId) 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(() => {});
+			});
+			if (action.action_id === "modal_project_select") {
+				const selectedProjectId = action.selected_option?.value;
+				const view = eventBody.view;
+				if (selectedProjectId && view?.id) (async () => {
+					try {
+						const metadata = JSON.parse(view.private_metadata || "{}");
+						const tenantId = metadata.tenantId || "default";
+						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");
+					}
+				})();
+			}
+			if (action.action_id === "open_follow_up_modal" && action.value && triggerId) 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");
+			});
+		}
+	}
+	if (eventType === "message_action") {
+		const callbackId = eventBody.callback_id;
+		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 (triggerId && teamId && channelId && userId && message?.ts) 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");
+			});
+		}
+	}
+	if (eventType === "view_submission") {
+		const callbackId = eventBody.view?.callback_id;
+		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") 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." }
+			});
+			handleModalSubmission(view).catch((err) => {
+				const errorMessage = err instanceof Error ? err.message : String(err);
+				logger.error({
+					errorMessage,
+					callbackId
+				}, "Failed to handle modal submission");
+			});
+			return new Response(null, { status: 200 });
+		}
+		if (callbackId === "follow_up_modal") {
+			const view = eventBody.view;
+			handleFollowUpSubmission(view).catch((err) => {
+				const errorMessage = err instanceof Error ? err.message : String(err);
+				logger.error({
+					errorMessage,
+					callbackId
+				}, "Failed to handle follow-up submission");
+			});
+			return new Response(null, { status: 200 });
+		}
+	}
+	return c.json({ ok: true });
+});
+app.post("/nango-webhook", async (c) => {
+	const body = await c.req.text();
+	if (env.NANGO_SECRET_KEY) {
+		const signature = c.req.header("x-nango-signature");
+		if (!signature) {
+			logger.warn({}, "Missing Nango webhook signature");
+			return c.json({ error: "Missing signature" }, 401);
+		}
+		const crypto = await import("node:crypto");
+		const expectedSignature = crypto.createHmac("sha256", env.NANGO_SECRET_KEY).update(body).digest("hex");
+		if (signature.length !== expectedSignature.length || !crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expectedSignature))) {
+			logger.warn({ signature }, "Invalid Nango webhook signature");
+			return c.json({ error: "Invalid signature" }, 401);
+		}
+	}
+	let payload;
+	try {
+		payload = JSON.parse(body);
+	} catch (error) {
+		logger.error({
+			error,
+			bodyPreview: body.slice(0, 200)
+		}, "Failed to parse Nango webhook JSON");
+		return c.json({ error: "Invalid JSON" }, 400);
+	}
+	logger.debug({ payload }, "Nango webhook received");
+	if (payload.type === "connection_deleted" && payload.connectionId && payload.providerConfigKey) {
+		const { connectionId, providerConfigKey } = payload;
+		if (providerConfigKey === getSlackIntegrationId()) try {
+			const teamMatch = connectionId.match(/T:([A-Z0-9]+)/);
+			if (teamMatch) {
+				const teamId = teamMatch[1];
+				const tenantId = (await findWorkspaceConnectionByTeamId(teamId))?.tenantId || "default";
+				if (await deleteWorkAppSlackWorkspaceByNangoConnectionId(runDbClient_default)(connectionId)) logger.info({ connectionId }, "Deleted workspace from database via Nango webhook");
+				const deletedMappings = await deleteAllWorkAppSlackUserMappingsByTeam(runDbClient_default)(tenantId, teamId);
+				if (deletedMappings > 0) logger.info({
+					teamId,
+					deletedMappings
+				}, "Deleted user mappings via Nango webhook");
+				const deletedChannelConfigs = await deleteAllWorkAppSlackChannelAgentConfigsByTeam(runDbClient_default)(tenantId, teamId);
+				if (deletedChannelConfigs > 0) logger.info({
+					teamId,
+					deletedChannelConfigs
+				}, "Deleted channel configs via Nango webhook");
+				logger.info({
+					connectionId,
+					teamId
+				}, "Processed Nango connection deletion webhook");
+			}
+		} catch (error) {
+			logger.error({
+				error,
+				connectionId
+			}, "Failed to process Nango deletion webhook");
+			return c.json({ error: "Deletion processing failed" }, 500);
+		}
+		return c.json({ received: true });
+	}
+	if (payload.type === "auth" && payload.success && payload.endUser && payload.connectionId) {
+		const { endUser, connectionId } = payload;
+		const integrationId = getSlackIntegrationId();
+		try {
+			const rawResponse = (await getSlackNango().getConnection(integrationId, connectionId)).credentials?.raw;
+			logger.debug({ teamId: rawResponse?.team?.id }, "Retrieved Nango connection info");
+			if (rawResponse?.ok && rawResponse.access_token) {
+				const slackUserId = rawResponse.authed_user?.id || "";
+				const slackTeamId = rawResponse.team?.id || "";
+				const accessToken = rawResponse.access_token;
+				let slackUsername = "";
+				let slackDisplayName = "";
+				let slackEmail = "";
+				let isSlackAdmin = false;
+				let isSlackOwner = false;
+				if (slackUserId && accessToken) {
+					const userInfo = await getSlackUserInfo(getSlackClient(accessToken), slackUserId);
+					if (userInfo) {
+						slackUsername = userInfo.name || "";
+						slackDisplayName = userInfo.displayName || userInfo.realName || "";
+						slackEmail = userInfo.email || "";
+						isSlackAdmin = userInfo.isAdmin || false;
+						isSlackOwner = userInfo.isOwner || false;
+					}
+				}
+				const tenantId = payload.organization?.id || "default";
+				await updateConnectionMetadata(connectionId, {
+					linked_at: (/* @__PURE__ */ new Date()).toISOString(),
+					app_user_id: endUser.endUserId,
+					app_user_email: endUser.endUserEmail || "",
+					tenant_id: tenantId,
+					slack_user_id: slackUserId,
+					slack_team_id: slackTeamId,
+					slack_team_name: rawResponse.team?.name || "",
+					slack_username: slackUsername,
+					slack_display_name: slackDisplayName,
+					slack_email: slackEmail,
+					is_slack_admin: String(isSlackAdmin),
+					is_slack_owner: String(isSlackOwner),
+					enterprise_id: rawResponse.enterprise?.id || "",
+					enterprise_name: rawResponse.enterprise?.name || ""
+				});
+				logger.info({
+					appUserId: endUser.endUserId,
+					slackUserId,
+					slackEmail
+				}, "User linked to Slack with enriched metadata");
+			}
+		} catch (error) {
+			logger.error({
+				error,
+				connectionId
+			}, "Failed to process Nango webhook");
+		}
+	}
+	return c.json({ received: true });
+});
+var events_default = app;
+
+//#endregion
+export { events_default as default };

package/dist/slack/routes/index.d.ts

@@ -0,0 +1,10 @@
+import { WorkAppsVariables } from "../types.js";
+import { OpenAPIHono } from "@hono/zod-openapi";
+
+//#region src/slack/routes/index.d.ts
+
+declare const app: OpenAPIHono<{
+  Variables: WorkAppsVariables;
+}, {}, "/">;
+//#endregion
+export { app as default };

package/dist/slack/routes/index.js

@@ -0,0 +1,47 @@
+import events_default from "./events.js";
+import oauth_default from "./oauth.js";
+import users_default from "./users.js";
+import workspaces_default from "./workspaces.js";
+import { OpenAPIHono } from "@hono/zod-openapi";
+
+//#region src/slack/routes/index.ts
+/**
+* Slack Work App Routes - Main Router
+*
+* Modular RESTful API structure:
+*
+* OAuth & Installation (oauth.ts):
+*   GET  /install                    - Redirect to Slack OAuth
+*   GET  /oauth_redirect             - OAuth callback
+*
+* Workspaces (workspaces.ts):
+*   GET  /workspaces                 - List all workspaces
+*   GET  /workspaces/:teamId         - Get workspace details
+*   GET  /workspaces/:teamId/settings - Get workspace settings
+*   PUT  /workspaces/:teamId/settings - Update workspace settings [ADMIN]
+*   DELETE /workspaces/:teamId       - Uninstall workspace [ADMIN]
+*   GET  /workspaces/:teamId/channels - List channels
+*   GET/PUT/DELETE /workspaces/:teamId/channels/:channelId/settings - Channel config
+*   GET  /workspaces/:teamId/users   - List linked users
+*
+* Users (users.ts):
+*   GET  /users/link-status          - Check link status
+*   POST /users/link/verify-token    - Verify JWT link token (primary linking method)
+*   POST /users/connect              - Create Nango session
+*   POST /users/disconnect           - Disconnect/unlink user
+*   GET  /users/status               - Get user connection status
+*
+* Events & Commands (events.ts):
+*   POST /commands                   - Handle slash commands
+*   POST /events                     - Handle Slack events
+*   POST /nango-webhook              - Handle Nango webhooks
+*/
+const app = new OpenAPIHono();
+app.route("/workspaces", workspaces_default);
+app.route("/users", users_default);
+app.route("/", oauth_default);
+app.route("/", events_default);
+var routes_default = app;
+
+//#endregion
+export { routes_default as default };

package/dist/slack/routes/oauth.d.ts

@@ -0,0 +1,20 @@
+import { WorkAppsVariables } from "../types.js";
+import { getBotTokenForTeam, setBotTokenForTeam } from "../services/workspace-tokens.js";
+import "../services/index.js";
+import { OpenAPIHono } from "@hono/zod-openapi";
+
+//#region src/slack/routes/oauth.d.ts
+
+interface OAuthState {
+  nonce: string;
+  tenantId?: string;
+  timestamp: number;
+}
+declare function getStateSigningSecret(): string;
+declare function createOAuthState(tenantId?: string): string;
+declare function parseOAuthState(stateStr: string): OAuthState | null;
+declare const app: OpenAPIHono<{
+  Variables: WorkAppsVariables;
+}, {}, "/">;
+//#endregion
+export { createOAuthState, app as default, getBotTokenForTeam, getStateSigningSecret, parseOAuthState, setBotTokenForTeam };