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

package/dist/slack/services/commands/index.js

@@ -0,0 +1,538 @@
+import { env } from "../../../env.js";
+import { getLogger } from "../../../logger.js";
+import runDbClient_default from "../../../db/runDbClient.js";
+import { findWorkspaceConnectionByTeamId } from "../nango.js";
+import { resolveEffectiveAgent } from "../agent-resolution.js";
+import { SlackStrings } from "../../i18n/strings.js";
+import { createAgentListMessage, createAlreadyLinkedMessage, createContextBlock, createErrorMessage, createJwtLinkMessage, createNotLinkedMessage, createStatusMessage, createUnlinkSuccessMessage, createUpdatedHelpMessage } from "../blocks/index.js";
+import { getSlackClient } from "../client.js";
+import { fetchAgentsForProject, fetchProjectsForTenant, getChannelAgentConfig, sendResponseUrlMessage } from "../events/utils.js";
+import { buildAgentSelectorModal } from "../modals.js";
+import { deleteWorkAppSlackUserMapping, findWorkAppSlackUserMapping, findWorkAppSlackUserMappingBySlackUser, signSlackLinkToken, signSlackUserToken } from "@inkeep/agents-core";
+
+//#region src/slack/services/commands/index.ts
+/**
+* Fetch all agents from the manage API.
+* This uses the proper ref-middleware and Dolt branch resolution.
+* Requires an auth token to access the manage API.
+*/
+const INTERNAL_FETCH_TIMEOUT_MS = 1e4;
+async function fetchAgentsFromManageApi(tenantId, authToken) {
+	const apiBaseUrl = env.INKEEP_AGENTS_API_URL || "http://localhost:3002";
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(), INTERNAL_FETCH_TIMEOUT_MS);
+	try {
+		const projectsResponse = await fetch(`${apiBaseUrl}/manage/tenants/${tenantId}/projects`, {
+			method: "GET",
+			headers: {
+				"Content-Type": "application/json",
+				Authorization: `Bearer ${authToken}`
+			},
+			signal: controller.signal
+		});
+		if (!projectsResponse.ok) {
+			logger.error({
+				status: projectsResponse.status,
+				tenantId
+			}, "Failed to fetch projects from manage API");
+			return [];
+		}
+		const projectsData = await projectsResponse.json();
+		const projects = projectsData.data || projectsData || [];
+		logger.info({
+			projectCount: projects.length,
+			tenantId
+		}, "Fetched projects from manage API");
+		return (await Promise.all(projects.map(async (project) => {
+			try {
+				const agentsResponse = await fetch(`${apiBaseUrl}/manage/tenants/${tenantId}/projects/${project.id}/agents`, {
+					method: "GET",
+					headers: {
+						"Content-Type": "application/json",
+						Authorization: `Bearer ${authToken}`
+					},
+					signal: controller.signal
+				});
+				if (agentsResponse.ok) {
+					const agentsData = await agentsResponse.json();
+					return (agentsData.data || agentsData || []).map((agent) => ({
+						id: agent.id,
+						name: agent.name,
+						projectId: project.id,
+						projectName: project.name
+					}));
+				}
+				return [];
+			} catch (error) {
+				logger.error({
+					error,
+					projectId: project.id
+				}, "Failed to fetch agents for project");
+				return [];
+			}
+		}))).flat();
+	} catch (error) {
+		logger.error({
+			error,
+			tenantId
+		}, "Failed to fetch agents from manage API");
+		return [];
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+/**
+* Find an agent by name or ID from the manage API.
+*/
+async function findAgentByIdentifier(tenantId, identifier, authToken) {
+	return (await fetchAgentsFromManageApi(tenantId, authToken)).find((a) => a.id === identifier || a.name?.toLowerCase() === identifier.toLowerCase()) || null;
+}
+const DEFAULT_CLIENT_ID = "work-apps-slack";
+const LINK_CODE_TTL_MINUTES = 10;
+const logger = getLogger("slack-commands");
+/**
+* Parse agent name and question from command text.
+* Agent name must be in quotes: "agent name" question
+*/
+function parseAgentAndQuestion(text) {
+	if (!text.trim()) return {
+		agentName: null,
+		question: null
+	};
+	const quotedMatch = text.match(/^["']([^"']+)["']\s+(.+)$/);
+	if (quotedMatch) return {
+		agentName: quotedMatch[1].trim(),
+		question: quotedMatch[2].trim()
+	};
+	return {
+		agentName: null,
+		question: null
+	};
+}
+async function handleLinkCommand(payload, dashboardUrl, tenantId) {
+	const existingLink = await findWorkAppSlackUserMapping(runDbClient_default)(tenantId, payload.userId, payload.teamId, DEFAULT_CLIENT_ID);
+	if (existingLink) return {
+		response_type: "ephemeral",
+		...createAlreadyLinkedMessage(existingLink.slackEmail || existingLink.slackUsername || "Unknown", existingLink.linkedAt, dashboardUrl)
+	};
+	try {
+		const linkToken = await signSlackLinkToken({
+			tenantId,
+			slackTeamId: payload.teamId,
+			slackUserId: payload.userId,
+			slackEnterpriseId: payload.enterpriseId,
+			slackUsername: payload.userName
+		});
+		const linkUrl = `${env.INKEEP_AGENTS_MANAGE_UI_URL || "http://localhost:3000"}/link?token=${encodeURIComponent(linkToken)}`;
+		logger.info({
+			slackUserId: payload.userId,
+			tenantId
+		}, "Generated JWT link token");
+		return {
+			response_type: "ephemeral",
+			...createJwtLinkMessage(linkUrl, LINK_CODE_TTL_MINUTES)
+		};
+	} catch (error) {
+		logger.error({
+			error,
+			slackUserId: payload.userId,
+			tenantId
+		}, "Failed to generate link token");
+		return {
+			response_type: "ephemeral",
+			...createErrorMessage("Failed to generate link. Please try again.")
+		};
+	}
+}
+async function handleUnlinkCommand(payload, tenantId) {
+	if (!await findWorkAppSlackUserMapping(runDbClient_default)(tenantId, payload.userId, payload.teamId, DEFAULT_CLIENT_ID)) return {
+		response_type: "ephemeral",
+		...createNotLinkedMessage()
+	};
+	try {
+		if (await deleteWorkAppSlackUserMapping(runDbClient_default)(tenantId, payload.userId, payload.teamId, DEFAULT_CLIENT_ID)) {
+			logger.info({
+				slackUserId: payload.userId,
+				tenantId
+			}, "User unlinked Slack account");
+			return {
+				response_type: "ephemeral",
+				...createUnlinkSuccessMessage()
+			};
+		}
+		return {
+			response_type: "ephemeral",
+			...createErrorMessage("Failed to unlink account. Please try again.")
+		};
+	} catch (error) {
+		logger.error({
+			error,
+			slackUserId: payload.userId,
+			tenantId
+		}, "Failed to unlink account");
+		return {
+			response_type: "ephemeral",
+			...createErrorMessage("Failed to unlink account. Please try again.")
+		};
+	}
+}
+async function handleStatusCommand(payload, dashboardUrl, tenantId) {
+	const existingLink = await findWorkAppSlackUserMapping(runDbClient_default)(tenantId, payload.userId, payload.teamId, DEFAULT_CLIENT_ID);
+	if (existingLink) {
+		const { getAgentConfigSources } = await import("../agent-resolution.js");
+		const agentConfigs = await getAgentConfigSources({
+			tenantId,
+			teamId: payload.teamId,
+			channelId: payload.channelId,
+			userId: payload.userId
+		});
+		return {
+			response_type: "ephemeral",
+			...createStatusMessage(existingLink.slackEmail || existingLink.slackUsername || payload.userName, existingLink.linkedAt, dashboardUrl, agentConfigs)
+		};
+	}
+	return {
+		response_type: "ephemeral",
+		...createNotLinkedMessage()
+	};
+}
+async function handleHelpCommand() {
+	return {
+		response_type: "ephemeral",
+		...createUpdatedHelpMessage()
+	};
+}
+/**
+* Handle `/inkeep` with no arguments - opens the agent picker modal
+* Similar to @mention behavior in channels
+*/
+async function handleAgentPickerCommand(payload, tenantId, workspaceConnection) {
+	const { triggerId, teamId, channelId, userId, responseUrl } = payload;
+	try {
+		const connection = workspaceConnection ?? await findWorkspaceConnectionByTeamId(teamId);
+		if (!connection?.botToken) {
+			logger.error({ teamId }, "No bot token for agent picker modal");
+			return {
+				response_type: "ephemeral",
+				...createErrorMessage(SlackStrings.errors.generic)
+			};
+		}
+		const slackClient = getSlackClient(connection.botToken);
+		const [projectListResult, defaultAgent] = await Promise.all([fetchProjectsForTenant(tenantId), getChannelAgentConfig(teamId, channelId)]);
+		let projectList = projectListResult;
+		if (projectList.length === 0 && defaultAgent) projectList = [{
+			id: defaultAgent.projectId,
+			name: defaultAgent.projectName || defaultAgent.projectId
+		}];
+		if (projectList.length === 0) return {
+			response_type: "ephemeral",
+			...createErrorMessage(SlackStrings.status.noProjectsConfigured)
+		};
+		const firstProject = projectList[0];
+		let agentList = await fetchAgentsForProject(tenantId, firstProject.id);
+		if (agentList.length === 0 && defaultAgent && defaultAgent.projectId === firstProject.id) agentList = [{
+			id: defaultAgent.agentId,
+			name: defaultAgent.agentName || defaultAgent.agentId,
+			projectId: defaultAgent.projectId,
+			projectName: defaultAgent.projectName || defaultAgent.projectId
+		}];
+		const now = Date.now();
+		const modalMetadata = {
+			channel: channelId,
+			messageTs: `${Math.floor(now / 1e3)}.${String(now % 1e3).padStart(3, "0")}000`,
+			teamId,
+			slackUserId: userId,
+			tenantId,
+			isInThread: false,
+			buttonResponseUrl: responseUrl
+		};
+		const modal = buildAgentSelectorModal({
+			projects: projectList,
+			agents: agentList.map((a) => ({
+				id: a.id,
+				name: a.name,
+				projectId: a.projectId,
+				projectName: a.projectName || a.projectId
+			})),
+			metadata: modalMetadata,
+			selectedProjectId: firstProject.id
+		});
+		await slackClient.views.open({
+			trigger_id: triggerId,
+			view: modal
+		});
+		logger.info({
+			teamId,
+			channelId,
+			projectCount: projectList.length,
+			agentCount: agentList.length
+		}, "Opened agent picker modal from slash command");
+		return {};
+	} catch (error) {
+		logger.error({
+			error,
+			teamId
+		}, "Failed to open agent picker modal from slash command");
+		return {
+			response_type: "ephemeral",
+			...createErrorMessage(SlackStrings.errors.failedToOpenSelector)
+		};
+	}
+}
+async function generateLinkCodeWithIntent(payload, tenantId) {
+	try {
+		const linkToken = await signSlackLinkToken({
+			tenantId,
+			slackTeamId: payload.teamId,
+			slackUserId: payload.userId,
+			slackEnterpriseId: payload.enterpriseId,
+			slackUsername: payload.userName
+		});
+		const linkUrl = `${env.INKEEP_AGENTS_MANAGE_UI_URL || "http://localhost:3000"}/link?token=${encodeURIComponent(linkToken)}`;
+		logger.info({
+			slackUserId: payload.userId,
+			tenantId
+		}, "Generated JWT link token with intent");
+		return {
+			response_type: "ephemeral",
+			...createJwtLinkMessage(linkUrl, LINK_CODE_TTL_MINUTES)
+		};
+	} catch (error) {
+		logger.error({
+			error,
+			slackUserId: payload.userId,
+			tenantId
+		}, "Failed to generate link token");
+		return {
+			response_type: "ephemeral",
+			...createErrorMessage("Failed to generate link. Please try again.")
+		};
+	}
+}
+async function handleQuestionCommand(payload, question, _dashboardUrl, tenantId) {
+	const existingLink = await findWorkAppSlackUserMappingBySlackUser(runDbClient_default)(payload.userId, payload.teamId, DEFAULT_CLIENT_ID);
+	if (!existingLink) return generateLinkCodeWithIntent(payload, tenantId);
+	const userTenantId = existingLink.tenantId;
+	const resolvedAgent = await resolveEffectiveAgent({
+		tenantId: userTenantId,
+		teamId: payload.teamId,
+		channelId: payload.channelId,
+		userId: payload.userId
+	});
+	if (!resolvedAgent) return {
+		response_type: "ephemeral",
+		...createErrorMessage("No default agent configured. Ask your admin to set a workspace default in the dashboard.\n\nUse `/inkeep list` to see available agents.")
+	};
+	executeAgentInBackground(payload, existingLink, {
+		id: resolvedAgent.agentId,
+		name: resolvedAgent.agentName || null,
+		projectId: resolvedAgent.projectId
+	}, question, userTenantId).catch((error) => {
+		logger.error({ error }, "Background execution promise rejected");
+	});
+	return {};
+}
+async function executeAgentInBackground(payload, existingLink, targetAgent, question, tenantId) {
+	try {
+		const slackUserToken = await signSlackUserToken({
+			inkeepUserId: existingLink.inkeepUserId,
+			tenantId,
+			slackTeamId: payload.teamId,
+			slackUserId: payload.userId,
+			slackEnterpriseId: payload.enterpriseId
+		});
+		const apiBaseUrl = env.INKEEP_AGENTS_API_URL || "http://localhost:3002";
+		const controller = new AbortController();
+		const timeout = setTimeout(() => controller.abort(), 3e4);
+		let response;
+		try {
+			response = await fetch(`${apiBaseUrl}/run/api/chat`, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					Authorization: `Bearer ${slackUserToken}`,
+					"x-inkeep-project-id": targetAgent.projectId,
+					"x-inkeep-agent-id": targetAgent.id
+				},
+				body: JSON.stringify({
+					messages: [{
+						role: "user",
+						content: question
+					}],
+					stream: false
+				}),
+				signal: controller.signal
+			});
+		} catch (error) {
+			clearTimeout(timeout);
+			if (error.name === "AbortError") {
+				await sendResponseUrlMessage(payload.responseUrl, {
+					response_type: "ephemeral",
+					text: "Request timed out. Please try again."
+				});
+				return;
+			}
+			throw error;
+		} finally {
+			clearTimeout(timeout);
+		}
+		if (!response.ok) {
+			const errorText = await response.text();
+			logger.error({
+				status: response.status,
+				error: errorText,
+				agentId: targetAgent.id,
+				projectId: targetAgent.projectId
+			}, "Run API call failed");
+			await sendResponseUrlMessage(payload.responseUrl, {
+				response_type: "ephemeral",
+				text: `Failed to run agent: ${response.status} ${response.statusText}`
+			});
+		} else {
+			const result = await response.json();
+			const assistantMessage = result.choices?.[0]?.message?.content || result.message?.content || "No response received";
+			logger.info({
+				slackUserId: payload.userId,
+				agentId: targetAgent.id,
+				projectId: targetAgent.projectId,
+				tenantId
+			}, "Agent execution completed via Slack");
+			const contextBlock = createContextBlock({ agentName: targetAgent.name || targetAgent.id });
+			await sendResponseUrlMessage(payload.responseUrl, {
+				response_type: "ephemeral",
+				text: assistantMessage,
+				blocks: [{
+					type: "section",
+					text: {
+						type: "mrkdwn",
+						text: assistantMessage
+					}
+				}, contextBlock]
+			});
+		}
+	} catch (error) {
+		logger.error({
+			error,
+			slackUserId: payload.userId
+		}, "Background agent execution failed");
+		await sendResponseUrlMessage(payload.responseUrl, {
+			response_type: "ephemeral",
+			text: "An error occurred while running the agent. Please try again."
+		});
+	}
+}
+async function handleRunCommand(payload, agentIdentifier, question, _dashboardUrl, tenantId) {
+	const existingLink = await findWorkAppSlackUserMappingBySlackUser(runDbClient_default)(payload.userId, payload.teamId, DEFAULT_CLIENT_ID);
+	if (!existingLink) return generateLinkCodeWithIntent(payload, tenantId);
+	const userTenantId = existingLink.tenantId;
+	try {
+		const targetAgent = await findAgentByIdentifier(userTenantId, agentIdentifier, await signSlackUserToken({
+			inkeepUserId: existingLink.inkeepUserId,
+			tenantId: userTenantId,
+			slackTeamId: payload.teamId,
+			slackUserId: payload.userId,
+			slackEnterpriseId: payload.enterpriseId
+		}));
+		if (!targetAgent) return {
+			response_type: "ephemeral",
+			...createErrorMessage(`Agent "${agentIdentifier}" not found. Use \`/inkeep list\` to see available agents.`)
+		};
+		executeAgentInBackground(payload, existingLink, targetAgent, question, userTenantId).catch((error) => {
+			logger.error({ error }, "Background execution promise rejected");
+		});
+		return {};
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : "Unknown error";
+		logger.error({
+			error: errorMessage,
+			tenantId: userTenantId
+		}, "Failed to run agent");
+		return {
+			response_type: "ephemeral",
+			...createErrorMessage("Failed to run agent. Please try again or visit the dashboard.")
+		};
+	}
+}
+async function handleAgentListCommand(payload, dashboardUrl, _tenantId) {
+	const existingLink = await findWorkAppSlackUserMappingBySlackUser(runDbClient_default)(payload.userId, payload.teamId, DEFAULT_CLIENT_ID);
+	if (!existingLink) return {
+		response_type: "ephemeral",
+		...createNotLinkedMessage()
+	};
+	const userTenantId = existingLink.tenantId;
+	logger.info({
+		slackUserId: payload.userId,
+		existingLinkTenantId: existingLink.tenantId,
+		existingLinkInkeepUserId: existingLink.inkeepUserId
+	}, "Found user mapping for list command");
+	try {
+		const allAgents = await fetchAgentsFromManageApi(userTenantId, await signSlackUserToken({
+			inkeepUserId: existingLink.inkeepUserId,
+			tenantId: userTenantId,
+			slackTeamId: payload.teamId,
+			slackUserId: payload.userId,
+			slackEnterpriseId: payload.enterpriseId
+		}));
+		logger.info({
+			slackUserId: payload.userId,
+			tenantId: userTenantId,
+			agentCount: allAgents.length
+		}, "Listed agents for linked Slack user");
+		if (allAgents.length === 0) return {
+			response_type: "ephemeral",
+			...createErrorMessage("No agents found. Create an agent in the Inkeep dashboard first.")
+		};
+		return {
+			response_type: "ephemeral",
+			...createAgentListMessage(allAgents, dashboardUrl.replace("/work-apps/slack", ""))
+		};
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : "Unknown error";
+		logger.error({
+			error: errorMessage,
+			tenantId: userTenantId
+		}, "Failed to list agents");
+		return {
+			response_type: "ephemeral",
+			...createErrorMessage("Failed to list agents. Please try again or visit the dashboard.")
+		};
+	}
+}
+async function handleCommand(payload) {
+	const text = payload.text.trim();
+	const subcommand = text.split(/\s+/)[0]?.toLowerCase() || "";
+	const manageUiUrl = env.INKEEP_AGENTS_MANAGE_UI_URL || "http://localhost:3000";
+	const workspaceConnection = await findWorkspaceConnectionByTeamId(payload.teamId);
+	const tenantId = workspaceConnection?.tenantId || "default";
+	const dashboardUrl = `${manageUiUrl}/${tenantId}/work-apps/slack`;
+	logger.info({
+		command: payload.command,
+		subcommand,
+		slackUserId: payload.userId,
+		teamId: payload.teamId,
+		tenantId
+	}, "Slack command received");
+	switch (subcommand) {
+		case "link":
+		case "connect": return handleLinkCommand(payload, dashboardUrl, tenantId);
+		case "status": return handleStatusCommand(payload, dashboardUrl, tenantId);
+		case "unlink":
+		case "logout":
+		case "disconnect": return handleUnlinkCommand(payload, tenantId);
+		case "list": return handleAgentListCommand(payload, dashboardUrl, tenantId);
+		case "run": {
+			const parsed = parseAgentAndQuestion(text.slice(4).trim());
+			if (!parsed.agentName || !parsed.question) return {
+				response_type: "ephemeral",
+				...createErrorMessage("Usage: `/inkeep run \"agent name\" [question]`\n\nExample: `/inkeep run \"my agent\" What is the weather?`\n\nAgent name must be in quotes.")
+			};
+			return handleRunCommand(payload, parsed.agentName, parsed.question, dashboardUrl, tenantId);
+		}
+		case "help": return handleHelpCommand();
+		case "": return handleAgentPickerCommand(payload, tenantId, workspaceConnection);
+		default: return handleQuestionCommand(payload, text, dashboardUrl, tenantId);
+	}
+}
+
+//#endregion
+export { handleAgentListCommand, handleAgentPickerCommand, handleCommand, handleHelpCommand, handleLinkCommand, handleQuestionCommand, handleRunCommand, handleStatusCommand, handleUnlinkCommand };

package/dist/slack/services/events/app-mention.d.ts

@@ -0,0 +1,40 @@
+//#region src/slack/services/events/app-mention.d.ts
+/**
+ * Handler for Slack @mention events
+ *
+ * Flow:
+ * 1. Resolve workspace connection (single lookup, cached)
+ * 2. Parallel: resolve agent config + check user link
+ * 3. If no agent configured → prompt to set up in dashboard
+ * 4. If not linked → prompt to link account
+ * 5. Handle based on context:
+ *    - Channel + no query → Show usage hint
+ *    - Channel + query → Execute agent with streaming response
+ *    - Thread + no query → Auto-execute agent with thread context as query
+ *    - Thread + query → Execute agent with thread context included
+ */
+/**
+ * Metadata passed to the agent selector modal via button value
+ */
+interface InlineSelectorMetadata {
+  channel: string;
+  threadTs?: string;
+  messageTs: string;
+  teamId: string;
+  slackUserId: string;
+  tenantId: string;
+  threadMessageCount?: number;
+}
+/**
+ * Main handler for @mention events in Slack
+ */
+declare function handleAppMention(params: {
+  slackUserId: string;
+  channel: string;
+  text: string;
+  threadTs: string;
+  messageTs: string;
+  teamId: string;
+}): Promise<void>;
+//#endregion
+export { InlineSelectorMetadata, handleAppMention };