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

package/dist/slack/services/agent-resolution.d.ts

@@ -0,0 +1,41 @@
+//#region src/slack/services/agent-resolution.d.ts
+/**
+ * Slack Agent Resolution Service
+ *
+ * Determines which agent to use for a given Slack interaction.
+ * Priority: Channel default > Workspace default (all admin-controlled)
+ */
+/** Configuration for a resolved agent */
+interface ResolvedAgentConfig {
+  projectId: string;
+  agentId: string;
+  agentName?: string;
+  source: 'channel' | 'workspace' | 'none';
+}
+interface AgentResolutionParams {
+  tenantId: string;
+  teamId: string;
+  channelId?: string;
+  userId?: string;
+}
+/**
+ * Resolve the effective agent configuration.
+ * Priority: Channel default > Workspace default
+ *
+ * @param params - Resolution parameters including tenant, team, and channel IDs
+ * @returns The resolved agent configuration, or null if no agent is configured
+ */
+declare function resolveEffectiveAgent(params: AgentResolutionParams): Promise<ResolvedAgentConfig | null>;
+/**
+ * Get all agent configuration sources for display purposes.
+ *
+ * @param params - Resolution parameters
+ * @returns Object containing channel, workspace configs, and the effective choice
+ */
+declare function getAgentConfigSources(params: AgentResolutionParams): Promise<{
+  channelConfig: ResolvedAgentConfig | null;
+  workspaceConfig: ResolvedAgentConfig | null;
+  effective: ResolvedAgentConfig | null;
+}>;
+//#endregion
+export { AgentResolutionParams, ResolvedAgentConfig, getAgentConfigSources, resolveEffectiveAgent };

package/dist/slack/services/agent-resolution.js

@@ -0,0 +1,99 @@
+import { getLogger } from "../../logger.js";
+import runDbClient_default from "../../db/runDbClient.js";
+import { getWorkspaceDefaultAgentFromNango } from "./nango.js";
+import { findWorkAppSlackChannelAgentConfig } from "@inkeep/agents-core";
+
+//#region src/slack/services/agent-resolution.ts
+/**
+* Slack Agent Resolution Service
+*
+* Determines which agent to use for a given Slack interaction.
+* Priority: Channel default > Workspace default (all admin-controlled)
+*/
+const logger = getLogger("slack-agent-resolution");
+/**
+* Resolve the effective agent configuration.
+* Priority: Channel default > Workspace default
+*
+* @param params - Resolution parameters including tenant, team, and channel IDs
+* @returns The resolved agent configuration, or null if no agent is configured
+*/
+async function resolveEffectiveAgent(params) {
+	const { tenantId, teamId, channelId } = params;
+	logger.debug({
+		tenantId,
+		teamId,
+		channelId
+	}, "Resolving effective agent");
+	if (channelId) {
+		const channelConfig = await findWorkAppSlackChannelAgentConfig(runDbClient_default)(tenantId, teamId, channelId);
+		if (channelConfig?.enabled) {
+			logger.info({
+				channelId,
+				agentId: channelConfig.agentId,
+				source: "channel"
+			}, "Resolved agent from channel config");
+			return {
+				projectId: channelConfig.projectId,
+				agentId: channelConfig.agentId,
+				agentName: channelConfig.agentName || void 0,
+				source: "channel"
+			};
+		}
+	}
+	const workspaceConfig = await getWorkspaceDefaultAgentFromNango(teamId);
+	if (workspaceConfig?.agentId && workspaceConfig.projectId) {
+		logger.info({
+			teamId,
+			agentId: workspaceConfig.agentId,
+			source: "workspace"
+		}, "Resolved agent from workspace config");
+		return {
+			projectId: workspaceConfig.projectId,
+			agentId: workspaceConfig.agentId,
+			agentName: workspaceConfig.agentName,
+			source: "workspace"
+		};
+	}
+	logger.debug({
+		tenantId,
+		teamId,
+		channelId
+	}, "No agent configuration found");
+	return null;
+}
+/**
+* Get all agent configuration sources for display purposes.
+*
+* @param params - Resolution parameters
+* @returns Object containing channel, workspace configs, and the effective choice
+*/
+async function getAgentConfigSources(params) {
+	const { tenantId, teamId, channelId } = params;
+	let channelConfig = null;
+	let workspaceConfig = null;
+	if (channelId) {
+		const config = await findWorkAppSlackChannelAgentConfig(runDbClient_default)(tenantId, teamId, channelId);
+		if (config?.enabled) channelConfig = {
+			projectId: config.projectId,
+			agentId: config.agentId,
+			agentName: config.agentName || void 0,
+			source: "channel"
+		};
+	}
+	const wsConfig = await getWorkspaceDefaultAgentFromNango(teamId);
+	if (wsConfig?.agentId && wsConfig.projectId) workspaceConfig = {
+		projectId: wsConfig.projectId,
+		agentId: wsConfig.agentId,
+		agentName: wsConfig.agentName,
+		source: "workspace"
+	};
+	return {
+		channelConfig,
+		workspaceConfig,
+		effective: channelConfig || workspaceConfig
+	};
+}
+
+//#endregion
+export { getAgentConfigSources, resolveEffectiveAgent };

package/dist/slack/services/blocks/index.d.ts

@@ -0,0 +1,73 @@
+import * as slack_block_builder0 from "slack-block-builder";
+
+//#region src/slack/services/blocks/index.d.ts
+declare function createErrorMessage(message: string): Readonly<slack_block_builder0.SlackMessageDto>;
+interface ContextBlockParams {
+  agentName: string;
+  isPrivate?: boolean;
+}
+declare function createContextBlock(params: ContextBlockParams): {
+  type: "context";
+  elements: {
+    type: "mrkdwn";
+    text: string;
+  }[];
+};
+interface FollowUpButtonParams {
+  conversationId: string;
+  agentId: string;
+  projectId: string;
+  tenantId: string;
+  teamId: string;
+  slackUserId: string;
+  channel: string;
+}
+declare function buildFollowUpButton(params: FollowUpButtonParams): {
+  type: "button";
+  text: {
+    type: "plain_text";
+    text: "Follow Up";
+    emoji: boolean;
+  };
+  action_id: string;
+  value: string;
+}[];
+/**
+ * Build Block Kit blocks for a private conversational response.
+ * Shows the user's message, a divider, the agent response, context, and a Follow Up button.
+ */
+declare function buildConversationResponseBlocks(params: {
+  userMessage: string;
+  responseText: string;
+  agentName: string;
+  isError: boolean;
+  followUpParams: FollowUpButtonParams;
+}): any[];
+declare function createAgentListMessage(agents: Array<{
+  id: string;
+  name: string | null;
+  projectName: string | null;
+}>, dashboardUrl: string): Readonly<slack_block_builder0.SlackMessageDto>;
+declare function createUpdatedHelpMessage(): Readonly<slack_block_builder0.SlackMessageDto>;
+declare function createAlreadyLinkedMessage(email: string, linkedAt: string, dashboardUrl: string): Readonly<slack_block_builder0.SlackMessageDto>;
+declare function createUnlinkSuccessMessage(): Readonly<slack_block_builder0.SlackMessageDto>;
+declare function createNotLinkedMessage(): Readonly<slack_block_builder0.SlackMessageDto>;
+interface AgentConfigSources {
+  channelConfig: {
+    agentName?: string;
+    agentId: string;
+  } | null;
+  workspaceConfig: {
+    agentName?: string;
+    agentId: string;
+  } | null;
+  effective: {
+    agentName?: string;
+    agentId: string;
+    source: string;
+  } | null;
+}
+declare function createStatusMessage(email: string, linkedAt: string, dashboardUrl: string, agentConfigs: AgentConfigSources): Readonly<slack_block_builder0.SlackMessageDto>;
+declare function createJwtLinkMessage(linkUrl: string, expiresInMinutes: number): Readonly<slack_block_builder0.SlackMessageDto>;
+//#endregion
+export { AgentConfigSources, ContextBlockParams, FollowUpButtonParams, buildConversationResponseBlocks, buildFollowUpButton, createAgentListMessage, createAlreadyLinkedMessage, createContextBlock, createErrorMessage, createJwtLinkMessage, createNotLinkedMessage, createStatusMessage, createUnlinkSuccessMessage, createUpdatedHelpMessage };

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

@@ -0,0 +1,103 @@
+import { SlackStrings } from "../../i18n/strings.js";
+import { Blocks, Elements, Md, Message } from "slack-block-builder";
+
+//#region src/slack/services/blocks/index.ts
+function createErrorMessage(message) {
+	return Message().blocks(Blocks.Section().text(`❌ ${message}`)).buildToObject();
+}
+function createContextBlock(params) {
+	const { agentName, isPrivate = false } = params;
+	let text = SlackStrings.context.poweredBy(agentName);
+	if (isPrivate) text = `${SlackStrings.context.privateResponse} • ${text}`;
+	return {
+		type: "context",
+		elements: [{
+			type: "mrkdwn",
+			text
+		}]
+	};
+}
+function buildFollowUpButton(params) {
+	return [{
+		type: "button",
+		text: {
+			type: "plain_text",
+			text: SlackStrings.buttons.followUp,
+			emoji: true
+		},
+		action_id: "open_follow_up_modal",
+		value: JSON.stringify(params)
+	}];
+}
+/**
+* Build Block Kit blocks for a private conversational response.
+* Shows the user's message, a divider, the agent response, context, and a Follow Up button.
+*/
+function buildConversationResponseBlocks(params) {
+	const { userMessage, responseText, agentName, isError, followUpParams } = params;
+	const blocks = [
+		{
+			type: "context",
+			elements: [{
+				type: "mrkdwn",
+				text: `💬 *You:* ${userMessage.length > 200 ? `${userMessage.slice(0, 200)}...` : userMessage}`
+			}]
+		},
+		{ type: "divider" },
+		{
+			type: "section",
+			text: {
+				type: "mrkdwn",
+				text: responseText
+			}
+		}
+	];
+	if (!isError) {
+		const contextBlock = createContextBlock({
+			agentName,
+			isPrivate: true
+		});
+		blocks.push(contextBlock);
+		blocks.push({
+			type: "actions",
+			elements: buildFollowUpButton(followUpParams)
+		});
+	}
+	return blocks;
+}
+function createAgentListMessage(agents, dashboardUrl) {
+	const agentList = agents.slice(0, 15).map((a) => `• ${Md.bold(a.name || a.id)} ${a.projectName ? `(${Md.italic(a.projectName)})` : ""}`).join("\n");
+	const moreText = agents.length > 15 ? `\n\n${SlackStrings.agentList.andMore(agents.length - 15)}` : "";
+	return Message().blocks(Blocks.Section().text(`${Md.bold(SlackStrings.agentList.title)}\n\n` + agentList + moreText + `
+
+${Md.bold(SlackStrings.agentList.usage)}\n• ${SlackStrings.agentList.runUsage}`), Blocks.Actions().elements(Elements.Button().text(SlackStrings.buttons.openDashboard).url(dashboardUrl).actionId("view_agents"))).buildToObject();
+}
+function createUpdatedHelpMessage() {
+	return Message().blocks(Blocks.Section().text(`${Md.bold(SlackStrings.help.title)}`), Blocks.Section().text(SlackStrings.help.publicSection), Blocks.Divider(), Blocks.Section().text(SlackStrings.help.privateSection), Blocks.Divider(), Blocks.Section().text(SlackStrings.help.otherCommands)).buildToObject();
+}
+function createAlreadyLinkedMessage(email, linkedAt, dashboardUrl) {
+	return Message().blocks(Blocks.Section().text(Md.bold("✅ Already Linked!") + "\n\nYour Slack account is already connected to Inkeep.\n\n" + Md.bold("Inkeep Account:") + ` ${email}\n` + Md.bold("Linked:") + ` ${new Date(linkedAt).toLocaleDateString()}\n\nTo switch accounts, first run \`/inkeep unlink\``), Blocks.Actions().elements(Elements.Button().text(SlackStrings.buttons.openDashboard).url(dashboardUrl).actionId("open_dashboard"))).buildToObject();
+}
+function createUnlinkSuccessMessage() {
+	return Message().blocks(Blocks.Section().text(Md.bold("✅ Account Unlinked") + "\n\nYour Slack account has been disconnected from Inkeep.\n\nTo use Inkeep agents again, run `/inkeep link` to connect a new account.")).buildToObject();
+}
+function createNotLinkedMessage() {
+	return Message().blocks(Blocks.Section().text(Md.bold("❌ Not Linked") + "\n\nYour Slack account is not connected to Inkeep.\n\nRun `/inkeep link` to connect your account.")).buildToObject();
+}
+function createStatusMessage(email, linkedAt, dashboardUrl, agentConfigs) {
+	const { effective } = agentConfigs;
+	let agentLine;
+	if (effective) agentLine = `${Md.bold("Agent:")} ${effective.agentName || effective.agentId}`;
+	else agentLine = `${Md.bold("Agent:")} None configured\n${Md.italic("Ask your admin to set up an agent in the dashboard.")}`;
+	return Message().blocks(Blocks.Section().text(Md.bold("✅ Connected to Inkeep") + `\n\n${Md.bold("Account:")} ${email}\n${Md.bold("Linked:")} ${new Date(linkedAt).toLocaleDateString()}\n` + agentLine), Blocks.Actions().elements(Elements.Button().text(SlackStrings.buttons.openDashboard).url(dashboardUrl).actionId("open_dashboard"))).buildToObject();
+}
+function createJwtLinkMessage(linkUrl, expiresInMinutes) {
+	return Message().blocks(Blocks.Section().text(`${Md.bold("🔗 Link your Inkeep account")}\n\nConnect your Slack and Inkeep accounts to unlock AI-powered assistance:`), Blocks.Section().text(`${Md.bold("What you can do after linking:")}\n• Ask questions with \`/inkeep [question]\` or \`@Inkeep\`
+• Get personalized responses from AI agents
+• Set your own default agent preferences`), Blocks.Section().text(`${Md.bold("How to link:")}\n1. Click the button below
+2. Sign in to Inkeep (or create an account)
+3. Done! Come back here and start asking questions`), Blocks.Actions().elements(Elements.Button().text("🔗 Link Account").url(linkUrl).actionId("link_account").primary()), Blocks.Context().elements(`${Md.emoji("clock")} This link expires in ${expiresInMinutes} minutes`)).buildToObject();
+}
+
+//#endregion
+export { buildConversationResponseBlocks, buildFollowUpButton, createAgentListMessage, createAlreadyLinkedMessage, createContextBlock, createErrorMessage, createJwtLinkMessage, createNotLinkedMessage, createStatusMessage, createUnlinkSuccessMessage, createUpdatedHelpMessage };

package/dist/slack/services/client.d.ts

@@ -0,0 +1,105 @@
+import * as _slack_web_api0 from "@slack/web-api";
+import { WebClient } from "@slack/web-api";
+
+//#region src/slack/services/client.d.ts
+
+/**
+ * Create a Slack WebClient with the provided bot token.
+ *
+ * @param token - Bot OAuth token from Nango connection
+ * @returns Configured Slack WebClient instance
+ */
+declare function getSlackClient(token: string): WebClient;
+/**
+ * Fetch user profile information from Slack.
+ *
+ * @param client - Authenticated Slack WebClient
+ * @param userId - Slack user ID (e.g., U0ABC123)
+ * @returns User profile object, or null if not found
+ */
+declare function getSlackUserInfo(client: WebClient, userId: string): Promise<{
+  id: string | undefined;
+  name: string | undefined;
+  realName: string | undefined;
+  displayName: string | undefined;
+  email: string | undefined;
+  isAdmin: boolean | undefined;
+  isOwner: boolean | undefined;
+  avatar: string | undefined;
+} | null>;
+/**
+ * Fetch workspace (team) information from Slack.
+ *
+ * @param client - Authenticated Slack WebClient
+ * @returns Team info object, or null if not available
+ */
+declare function getSlackTeamInfo(client: WebClient): Promise<{
+  id: string | undefined;
+  name: string | undefined;
+  domain: string | undefined;
+  icon: string | undefined;
+  url: string | undefined;
+} | null>;
+/**
+ * List channels in the workspace (public, private, and shared).
+ *
+ * Note: The bot must be a member of private channels to see them.
+ * Users can invite the bot with `/invite @BotName` in the private channel.
+ *
+ * @param client - Authenticated Slack WebClient
+ * @param limit - Maximum number of channels to return (default 20)
+ * @returns Array of channel objects with id, name, member count, and privacy status
+ */
+declare function getSlackChannels(client: WebClient, limit?: number): Promise<{
+  id: string | undefined;
+  name: string | undefined;
+  memberCount: number | undefined;
+  isBotMember: boolean | undefined;
+  isPrivate: boolean;
+  isShared: boolean;
+}[]>;
+/**
+ * Post a message to a Slack channel.
+ *
+ * @param client - Authenticated Slack WebClient
+ * @param channel - Channel ID to post to
+ * @param text - Fallback text for notifications
+ * @param blocks - Optional Block Kit blocks for rich formatting
+ * @returns Slack API response with message timestamp
+ */
+declare function postMessage(client: WebClient, channel: string, text: string, blocks?: unknown[]): Promise<_slack_web_api0.ChatPostMessageResponse>;
+/**
+ * Post a message as a reply in a thread.
+ *
+ * @param client - Authenticated Slack WebClient
+ * @param channel - Channel ID containing the thread
+ * @param threadTs - Thread parent message timestamp
+ * @param text - Fallback text for notifications
+ * @param blocks - Optional Block Kit blocks for rich formatting
+ * @returns Slack API response with message timestamp
+ */
+declare function postMessageInThread(client: WebClient, channel: string, threadTs: string, text: string, blocks?: unknown[]): Promise<_slack_web_api0.ChatPostMessageResponse>;
+/**
+ * Check if a user is a member of a Slack channel.
+ *
+ * Uses conversations.members to verify membership. Handles pagination
+ * for channels with many members.
+ *
+ * @param client - Authenticated Slack WebClient
+ * @param channelId - Channel ID to check membership for
+ * @param userId - Slack user ID to check
+ * @returns true if user is a member, false otherwise
+ */
+declare function checkUserIsChannelMember(client: WebClient, channelId: string, userId: string): Promise<boolean>;
+/**
+ * Revoke a Slack bot token.
+ *
+ * This should be called when uninstalling a workspace to ensure
+ * the token can no longer be used to make API calls.
+ *
+ * @param token - Bot OAuth token to revoke
+ * @returns true if revocation succeeded or token was already invalid
+ */
+declare function revokeSlackToken(token: string): Promise<boolean>;
+//#endregion
+export { checkUserIsChannelMember, getSlackChannels, getSlackClient, getSlackTeamInfo, getSlackUserInfo, postMessage, postMessageInThread, revokeSlackToken };

package/dist/slack/services/client.js

@@ -0,0 +1,220 @@
+import { getLogger } from "../../logger.js";
+import { WebClient } from "@slack/web-api";
+
+//#region src/slack/services/client.ts
+/**
+* Slack Web API Client Utilities
+*
+* Wrapper functions for common Slack Web API operations.
+* Tokens are fetched from Nango at runtime and passed to these functions.
+*/
+const logger = getLogger("slack-client");
+/**
+* Create a Slack WebClient with the provided bot token.
+*
+* @param token - Bot OAuth token from Nango connection
+* @returns Configured Slack WebClient instance
+*/
+function getSlackClient(token) {
+	return new WebClient(token);
+}
+/**
+* Fetch user profile information from Slack.
+*
+* @param client - Authenticated Slack WebClient
+* @param userId - Slack user ID (e.g., U0ABC123)
+* @returns User profile object, or null if not found
+*/
+async function getSlackUserInfo(client, userId) {
+	try {
+		const result = await client.users.info({ user: userId });
+		if (result.ok && result.user) return {
+			id: result.user.id,
+			name: result.user.name,
+			realName: result.user.real_name,
+			displayName: result.user.profile?.display_name,
+			email: result.user.profile?.email,
+			isAdmin: result.user.is_admin,
+			isOwner: result.user.is_owner,
+			avatar: result.user.profile?.image_72
+		};
+		return null;
+	} catch (error) {
+		logger.error({
+			error,
+			userId
+		}, "Failed to fetch Slack user info");
+		return null;
+	}
+}
+/**
+* Fetch workspace (team) information from Slack.
+*
+* @param client - Authenticated Slack WebClient
+* @returns Team info object, or null if not available
+*/
+async function getSlackTeamInfo(client) {
+	try {
+		const result = await client.team.info();
+		if (result.ok && result.team) return {
+			id: result.team.id,
+			name: result.team.name,
+			domain: result.team.domain,
+			icon: result.team.icon?.image_68,
+			url: result.team.url
+		};
+		return null;
+	} catch (error) {
+		logger.error({ error }, "Failed to fetch Slack team info");
+		return null;
+	}
+}
+/**
+* List channels in the workspace (public, private, and shared).
+*
+* Note: The bot must be a member of private channels to see them.
+* Users can invite the bot with `/invite @BotName` in the private channel.
+*
+* @param client - Authenticated Slack WebClient
+* @param limit - Maximum number of channels to return (default 20)
+* @returns Array of channel objects with id, name, member count, and privacy status
+*/
+async function getSlackChannels(client, limit = 20) {
+	try {
+		const result = await client.conversations.list({
+			types: "public_channel,private_channel",
+			exclude_archived: true,
+			limit
+		});
+		if (result.ok && result.channels) return result.channels.map((ch) => ({
+			id: ch.id,
+			name: ch.name,
+			memberCount: ch.num_members,
+			isBotMember: ch.is_member,
+			isPrivate: ch.is_private ?? false,
+			isShared: ch.is_shared ?? ch.is_ext_shared ?? false
+		}));
+		return [];
+	} catch (error) {
+		logger.error({ error }, "Failed to fetch Slack channels");
+		return [];
+	}
+}
+/**
+* Post a message to a Slack channel.
+*
+* @param client - Authenticated Slack WebClient
+* @param channel - Channel ID to post to
+* @param text - Fallback text for notifications
+* @param blocks - Optional Block Kit blocks for rich formatting
+* @returns Slack API response with message timestamp
+*/
+async function postMessage(client, channel, text, blocks) {
+	try {
+		const args = {
+			channel,
+			text
+		};
+		if (blocks) args.blocks = blocks;
+		return await client.chat.postMessage(args);
+	} catch (error) {
+		logger.error({
+			error,
+			channel
+		}, "Failed to post Slack message");
+		throw error;
+	}
+}
+/**
+* Post a message as a reply in a thread.
+*
+* @param client - Authenticated Slack WebClient
+* @param channel - Channel ID containing the thread
+* @param threadTs - Thread parent message timestamp
+* @param text - Fallback text for notifications
+* @param blocks - Optional Block Kit blocks for rich formatting
+* @returns Slack API response with message timestamp
+*/
+async function postMessageInThread(client, channel, threadTs, text, blocks) {
+	try {
+		const args = {
+			channel,
+			text,
+			thread_ts: threadTs
+		};
+		if (blocks) args.blocks = blocks;
+		return await client.chat.postMessage(args);
+	} catch (error) {
+		logger.error({
+			error,
+			channel,
+			threadTs
+		}, "Failed to post Slack message in thread");
+		throw error;
+	}
+}
+/**
+* Check if a user is a member of a Slack channel.
+*
+* Uses conversations.members to verify membership. Handles pagination
+* for channels with many members.
+*
+* @param client - Authenticated Slack WebClient
+* @param channelId - Channel ID to check membership for
+* @param userId - Slack user ID to check
+* @returns true if user is a member, false otherwise
+*/
+async function checkUserIsChannelMember(client, channelId, userId) {
+	try {
+		let cursor;
+		do {
+			const result = await client.conversations.members({
+				channel: channelId,
+				limit: 200,
+				cursor
+			});
+			if (!result.ok || !result.members) return false;
+			if (result.members.includes(userId)) return true;
+			cursor = result.response_metadata?.next_cursor;
+		} while (cursor);
+		return false;
+	} catch (error) {
+		logger.error({
+			error,
+			channelId,
+			userId
+		}, "Failed to check channel membership");
+		return false;
+	}
+}
+/**
+* Revoke a Slack bot token.
+*
+* This should be called when uninstalling a workspace to ensure
+* the token can no longer be used to make API calls.
+*
+* @param token - Bot OAuth token to revoke
+* @returns true if revocation succeeded or token was already invalid
+*/
+async function revokeSlackToken(token) {
+	try {
+		const result = await new WebClient(token).auth.revoke();
+		if (result.ok) {
+			logger.info({}, "Successfully revoked Slack token");
+			return true;
+		}
+		logger.warn({ error: result.error }, "Token revocation returned non-ok status");
+		return false;
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		if (errorMessage.includes("token_revoked") || errorMessage.includes("invalid_auth")) {
+			logger.info({}, "Token already revoked or invalid");
+			return true;
+		}
+		logger.error({ error }, "Failed to revoke Slack token");
+		return false;
+	}
+}
+
+//#endregion
+export { checkUserIsChannelMember, getSlackChannels, getSlackClient, getSlackTeamInfo, getSlackUserInfo, postMessage, postMessageInThread, revokeSlackToken };

package/dist/slack/services/commands/index.d.ts

@@ -0,0 +1,19 @@
+import { SlackWorkspaceConnection } from "../nango.js";
+import { SlackCommandPayload, SlackCommandResponse } from "../types.js";
+
+//#region src/slack/services/commands/index.d.ts
+declare function handleLinkCommand(payload: SlackCommandPayload, dashboardUrl: string, tenantId: string): Promise<SlackCommandResponse>;
+declare function handleUnlinkCommand(payload: SlackCommandPayload, tenantId: string): Promise<SlackCommandResponse>;
+declare function handleStatusCommand(payload: SlackCommandPayload, dashboardUrl: string, tenantId: string): Promise<SlackCommandResponse>;
+declare function handleHelpCommand(): Promise<SlackCommandResponse>;
+/**
+ * Handle `/inkeep` with no arguments - opens the agent picker modal
+ * Similar to @mention behavior in channels
+ */
+declare function handleAgentPickerCommand(payload: SlackCommandPayload, tenantId: string, workspaceConnection?: SlackWorkspaceConnection | null): Promise<SlackCommandResponse>;
+declare function handleQuestionCommand(payload: SlackCommandPayload, question: string, _dashboardUrl: string, tenantId: string): Promise<SlackCommandResponse>;
+declare function handleRunCommand(payload: SlackCommandPayload, agentIdentifier: string, question: string, _dashboardUrl: string, tenantId: string): Promise<SlackCommandResponse>;
+declare function handleAgentListCommand(payload: SlackCommandPayload, dashboardUrl: string, _tenantId: string): Promise<SlackCommandResponse>;
+declare function handleCommand(payload: SlackCommandPayload): Promise<SlackCommandResponse>;
+//#endregion
+export { handleAgentListCommand, handleAgentPickerCommand, handleCommand, handleHelpCommand, handleLinkCommand, handleQuestionCommand, handleRunCommand, handleStatusCommand, handleUnlinkCommand };