@rv404/mcp-launchpad 1.0.0

package/dist/backends/slack.js

@@ -0,0 +1,1725 @@
+import axios from 'axios';
+import fs from 'fs';
+import path from 'path';
+const SLACK_BOT_TOKEN = process.env.SLACK_BOT_TOKEN || '';
+const BASE_URL = 'https://slack.com/api';
+const headers = () => ({
+    'Authorization': `Bearer ${SLACK_BOT_TOKEN}`,
+    'Content-Type': 'application/json',
+});
+// ============================================================================
+// ACTION DEFINITIONS
+// ============================================================================
+const actions = [
+    // --------------------------------------------------------------------------
+    // CONVERSATIONS / CHANNELS
+    // --------------------------------------------------------------------------
+    {
+        name: 'list_channels',
+        description: 'List public channels in the workspace with pagination',
+        params: [
+            { name: 'limit', type: 'number', required: false, description: 'Maximum number of channels to return (default 100, max 1000)' },
+            { name: 'cursor', type: 'string', required: false, description: 'Pagination cursor for next page of results' },
+            { name: 'types', type: 'string', required: false, description: 'Channel types: public_channel, private_channel, mpim, im (comma-separated, default: public_channel)' },
+            { name: 'exclude_archived', type: 'boolean', required: false, description: 'Exclude archived channels (default: false)' },
+        ],
+    },
+    {
+        name: 'get_channel_info',
+        description: 'Get detailed information about a channel',
+        params: [
+            { name: 'channel_id', type: 'string', required: true, description: 'The ID of the channel' },
+            { name: 'include_num_members', type: 'boolean', required: false, description: 'Include member count (default: false)' },
+        ],
+    },
+    {
+        name: 'create_channel',
+        description: 'Create a new public or private channel',
+        params: [
+            { name: 'name', type: 'string', required: true, description: 'Name of the channel (no spaces, lowercase, max 80 chars)' },
+            { name: 'is_private', type: 'boolean', required: false, description: 'Create as private channel (default: false)' },
+            { name: 'description', type: 'string', required: false, description: 'Channel description' },
+        ],
+    },
+    {
+        name: 'archive_channel',
+        description: 'Archive a channel',
+        params: [
+            { name: 'channel_id', type: 'string', required: true, description: 'The ID of the channel to archive' },
+        ],
+    },
+    {
+        name: 'unarchive_channel',
+        description: 'Unarchive a channel',
+        params: [
+            { name: 'channel_id', type: 'string', required: true, description: 'The ID of the channel to unarchive' },
+        ],
+    },
+    {
+        name: 'rename_channel',
+        description: 'Rename a channel',
+        params: [
+            { name: 'channel_id', type: 'string', required: true, description: 'The ID of the channel' },
+            { name: 'name', type: 'string', required: true, description: 'New name for the channel' },
+        ],
+    },
+    {
+        name: 'set_channel_topic',
+        description: 'Set the topic of a channel',
+        params: [
+            { name: 'channel_id', type: 'string', required: true, description: 'The ID of the channel' },
+            { name: 'topic', type: 'string', required: true, description: 'The new topic (max 250 chars)' },
+        ],
+    },
+    {
+        name: 'set_channel_purpose',
+        description: 'Set the purpose of a channel',
+        params: [
+            { name: 'channel_id', type: 'string', required: true, description: 'The ID of the channel' },
+            { name: 'purpose', type: 'string', required: true, description: 'The new purpose (max 250 chars)' },
+        ],
+    },
+    {
+        name: 'join_channel',
+        description: 'Join a public channel',
+        params: [
+            { name: 'channel_id', type: 'string', required: true, description: 'The ID of the channel to join' },
+        ],
+    },
+    {
+        name: 'leave_channel',
+        description: 'Leave a channel',
+        params: [
+            { name: 'channel_id', type: 'string', required: true, description: 'The ID of the channel to leave' },
+        ],
+    },
+    {
+        name: 'invite_to_channel',
+        description: 'Invite users to a channel',
+        params: [
+            { name: 'channel_id', type: 'string', required: true, description: 'The ID of the channel' },
+            { name: 'user_ids', type: 'array', required: true, description: 'Array of user IDs to invite' },
+        ],
+    },
+    {
+        name: 'kick_from_channel',
+        description: 'Remove a user from a channel',
+        params: [
+            { name: 'channel_id', type: 'string', required: true, description: 'The ID of the channel' },
+            { name: 'user_id', type: 'string', required: true, description: 'The ID of the user to remove' },
+        ],
+    },
+    {
+        name: 'get_channel_members',
+        description: 'Get members of a channel',
+        params: [
+            { name: 'channel_id', type: 'string', required: true, description: 'The ID of the channel' },
+            { name: 'limit', type: 'number', required: false, description: 'Maximum members to return (default 100, max 1000)' },
+            { name: 'cursor', type: 'string', required: false, description: 'Pagination cursor' },
+        ],
+    },
+    // --------------------------------------------------------------------------
+    // DIRECT MESSAGES
+    // --------------------------------------------------------------------------
+    {
+        name: 'open_dm',
+        description: 'Open a direct message channel with a user (or get existing DM channel)',
+        params: [
+            { name: 'user_id', type: 'string', required: false, description: 'User ID to open DM with (for 1:1 DM)' },
+            { name: 'user_ids', type: 'array', required: false, description: 'Array of user IDs for group DM (2-8 users)' },
+            { name: 'return_im', type: 'boolean', required: false, description: 'Return the full IM object (default: false)' },
+        ],
+    },
+    {
+        name: 'post_dm',
+        description: 'Send a direct message to a user',
+        params: [
+            { name: 'user_id', type: 'string', required: true, description: 'The ID of the user to message' },
+            { name: 'text', type: 'string', required: true, description: 'The message text' },
+            { name: 'blocks', type: 'array', required: false, description: 'Block Kit blocks for rich formatting' },
+        ],
+    },
+    // --------------------------------------------------------------------------
+    // MESSAGES
+    // --------------------------------------------------------------------------
+    {
+        name: 'post_message',
+        description: 'Post a new message to a Slack channel',
+        params: [
+            { name: 'channel_id', type: 'string', required: true, description: 'The ID of the channel to post to' },
+            { name: 'text', type: 'string', required: true, description: 'The message text to post' },
+            { name: 'blocks', type: 'array', required: false, description: 'Block Kit blocks for rich formatting' },
+            { name: 'attachments', type: 'array', required: false, description: 'Secondary attachments' },
+            { name: 'unfurl_links', type: 'boolean', required: false, description: 'Enable link unfurling (default: true)' },
+            { name: 'unfurl_media', type: 'boolean', required: false, description: 'Enable media unfurling (default: true)' },
+            { name: 'mrkdwn', type: 'boolean', required: false, description: 'Enable markdown parsing (default: true)' },
+        ],
+    },
+    {
+        name: 'reply_to_thread',
+        description: 'Reply to a specific message thread in Slack',
+        params: [
+            { name: 'channel_id', type: 'string', required: true, description: 'The ID of the channel containing the thread' },
+            { name: 'thread_ts', type: 'string', required: true, description: "The timestamp of the parent message (format: '1234567890.123456')" },
+            { name: 'text', type: 'string', required: true, description: 'The reply text' },
+            { name: 'blocks', type: 'array', required: false, description: 'Block Kit blocks for rich formatting' },
+            { name: 'broadcast', type: 'boolean', required: false, description: 'Also post to channel (default: false)' },
+        ],
+    },
+    {
+        name: 'update_message',
+        description: 'Update an existing message',
+        params: [
+            { name: 'channel_id', type: 'string', required: true, description: 'The ID of the channel' },
+            { name: 'ts', type: 'string', required: true, description: 'Timestamp of the message to update' },
+            { name: 'text', type: 'string', required: true, description: 'New message text' },
+            { name: 'blocks', type: 'array', required: false, description: 'Block Kit blocks for rich formatting' },
+            { name: 'attachments', type: 'array', required: false, description: 'Secondary attachments' },
+        ],
+    },
+    {
+        name: 'delete_message',
+        description: 'Delete a message',
+        params: [
+            { name: 'channel_id', type: 'string', required: true, description: 'The ID of the channel' },
+            { name: 'ts', type: 'string', required: true, description: 'Timestamp of the message to delete' },
+        ],
+    },
+    {
+        name: 'get_channel_history',
+        description: 'Get recent messages from a channel',
+        params: [
+            { name: 'channel_id', type: 'string', required: true, description: 'The ID of the channel' },
+            { name: 'limit', type: 'number', required: false, description: 'Number of messages to retrieve (default 100, max 1000)' },
+            { name: 'cursor', type: 'string', required: false, description: 'Pagination cursor' },
+            { name: 'oldest', type: 'string', required: false, description: 'Start of time range (Unix timestamp)' },
+            { name: 'latest', type: 'string', required: false, description: 'End of time range (Unix timestamp)' },
+            { name: 'inclusive', type: 'boolean', required: false, description: 'Include messages with oldest/latest timestamps' },
+        ],
+    },
+    {
+        name: 'get_thread_replies',
+        description: 'Get all replies in a message thread',
+        params: [
+            { name: 'channel_id', type: 'string', required: true, description: 'The ID of the channel containing the thread' },
+            { name: 'thread_ts', type: 'string', required: true, description: "The timestamp of the parent message (format: '1234567890.123456')" },
+            { name: 'limit', type: 'number', required: false, description: 'Number of replies to retrieve (default 100, max 1000)' },
+            { name: 'cursor', type: 'string', required: false, description: 'Pagination cursor' },
+        ],
+    },
+    {
+        name: 'get_permalink',
+        description: 'Get a permalink URL for a message',
+        params: [
+            { name: 'channel_id', type: 'string', required: true, description: 'The ID of the channel' },
+            { name: 'message_ts', type: 'string', required: true, description: 'Timestamp of the message' },
+        ],
+    },
+    // --------------------------------------------------------------------------
+    // SCHEDULED MESSAGES
+    // --------------------------------------------------------------------------
+    {
+        name: 'schedule_message',
+        description: 'Schedule a message to be sent at a future time',
+        params: [
+            { name: 'channel_id', type: 'string', required: true, description: 'The ID of the channel' },
+            { name: 'text', type: 'string', required: true, description: 'The message text' },
+            { name: 'post_at', type: 'number', required: true, description: 'Unix timestamp for when to send (must be in future)' },
+            { name: 'blocks', type: 'array', required: false, description: 'Block Kit blocks for rich formatting' },
+            { name: 'thread_ts', type: 'string', required: false, description: 'Thread timestamp to reply to' },
+        ],
+    },
+    {
+        name: 'list_scheduled_messages',
+        description: 'List scheduled messages',
+        params: [
+            { name: 'channel_id', type: 'string', required: false, description: 'Filter by channel ID' },
+            { name: 'limit', type: 'number', required: false, description: 'Maximum number to return (default 100, max 100)' },
+            { name: 'cursor', type: 'string', required: false, description: 'Pagination cursor' },
+        ],
+    },
+    {
+        name: 'delete_scheduled_message',
+        description: 'Delete a scheduled message before it is sent',
+        params: [
+            { name: 'channel_id', type: 'string', required: true, description: 'The ID of the channel' },
+            { name: 'scheduled_message_id', type: 'string', required: true, description: 'ID of the scheduled message to delete' },
+        ],
+    },
+    // --------------------------------------------------------------------------
+    // REACTIONS
+    // --------------------------------------------------------------------------
+    {
+        name: 'add_reaction',
+        description: 'Add a reaction emoji to a message',
+        params: [
+            { name: 'channel_id', type: 'string', required: true, description: 'The ID of the channel containing the message' },
+            { name: 'timestamp', type: 'string', required: true, description: 'The timestamp of the message to react to' },
+            { name: 'reaction', type: 'string', required: true, description: 'The name of the emoji reaction (without ::)' },
+        ],
+    },
+    {
+        name: 'remove_reaction',
+        description: 'Remove a reaction from a message',
+        params: [
+            { name: 'channel_id', type: 'string', required: true, description: 'The ID of the channel' },
+            { name: 'timestamp', type: 'string', required: true, description: 'The timestamp of the message' },
+            { name: 'reaction', type: 'string', required: true, description: 'The name of the emoji reaction to remove' },
+        ],
+    },
+    {
+        name: 'get_reactions',
+        description: 'Get reactions for a specific message',
+        params: [
+            { name: 'channel_id', type: 'string', required: true, description: 'The ID of the channel' },
+            { name: 'timestamp', type: 'string', required: true, description: 'The timestamp of the message' },
+            { name: 'full', type: 'boolean', required: false, description: 'Include full user info for each reaction' },
+        ],
+    },
+    {
+        name: 'list_reactions',
+        description: 'List items the calling user has reacted to',
+        params: [
+            { name: 'user_id', type: 'string', required: false, description: 'User ID to show reactions for (default: calling user)' },
+            { name: 'limit', type: 'number', required: false, description: 'Maximum items to return (default 100, max 100)' },
+            { name: 'cursor', type: 'string', required: false, description: 'Pagination cursor' },
+        ],
+    },
+    // --------------------------------------------------------------------------
+    // PINS
+    // --------------------------------------------------------------------------
+    {
+        name: 'pin_message',
+        description: 'Pin a message to a channel',
+        params: [
+            { name: 'channel_id', type: 'string', required: true, description: 'The ID of the channel' },
+            { name: 'timestamp', type: 'string', required: true, description: 'The timestamp of the message to pin' },
+        ],
+    },
+    {
+        name: 'unpin_message',
+        description: 'Unpin a message from a channel',
+        params: [
+            { name: 'channel_id', type: 'string', required: true, description: 'The ID of the channel' },
+            { name: 'timestamp', type: 'string', required: true, description: 'The timestamp of the message to unpin' },
+        ],
+    },
+    {
+        name: 'list_pins',
+        description: 'List pinned items in a channel',
+        params: [
+            { name: 'channel_id', type: 'string', required: true, description: 'The ID of the channel' },
+        ],
+    },
+    // --------------------------------------------------------------------------
+    // BOOKMARKS
+    // --------------------------------------------------------------------------
+    {
+        name: 'add_bookmark',
+        description: 'Add a bookmark to a channel',
+        params: [
+            { name: 'channel_id', type: 'string', required: true, description: 'The ID of the channel' },
+            { name: 'title', type: 'string', required: true, description: 'Title for the bookmark' },
+            { name: 'type', type: 'string', required: true, description: 'Type of bookmark: link' },
+            { name: 'link', type: 'string', required: false, description: 'URL for link bookmarks' },
+            { name: 'emoji', type: 'string', required: false, description: 'Emoji icon for the bookmark' },
+        ],
+    },
+    {
+        name: 'edit_bookmark',
+        description: 'Edit a bookmark',
+        params: [
+            { name: 'channel_id', type: 'string', required: true, description: 'The ID of the channel' },
+            { name: 'bookmark_id', type: 'string', required: true, description: 'The ID of the bookmark to edit' },
+            { name: 'title', type: 'string', required: false, description: 'New title' },
+            { name: 'link', type: 'string', required: false, description: 'New URL' },
+            { name: 'emoji', type: 'string', required: false, description: 'New emoji icon' },
+        ],
+    },
+    {
+        name: 'remove_bookmark',
+        description: 'Remove a bookmark from a channel',
+        params: [
+            { name: 'channel_id', type: 'string', required: true, description: 'The ID of the channel' },
+            { name: 'bookmark_id', type: 'string', required: true, description: 'The ID of the bookmark to remove' },
+        ],
+    },
+    {
+        name: 'list_bookmarks',
+        description: 'List bookmarks in a channel',
+        params: [
+            { name: 'channel_id', type: 'string', required: true, description: 'The ID of the channel' },
+        ],
+    },
+    // --------------------------------------------------------------------------
+    // FILES
+    // --------------------------------------------------------------------------
+    {
+        name: 'upload_file',
+        description: 'Upload a file (PDF, PNG, image, document, etc.) to a Slack channel',
+        params: [
+            { name: 'channel_id', type: 'string', required: true, description: 'The ID of the channel to upload to' },
+            { name: 'file_path', type: 'string', required: true, description: 'Absolute path to the file on disk' },
+            { name: 'title', type: 'string', required: false, description: 'Title for the file in Slack (defaults to filename)' },
+            { name: 'initial_comment', type: 'string', required: false, description: 'Message to include with the file' },
+            { name: 'thread_ts', type: 'string', required: false, description: 'Thread timestamp to reply with file (for threaded uploads)' },
+        ],
+    },
+    {
+        name: 'list_files',
+        description: 'List files shared in the workspace',
+        params: [
+            { name: 'channel_id', type: 'string', required: false, description: 'Filter by channel ID' },
+            { name: 'user_id', type: 'string', required: false, description: 'Filter by user ID' },
+            { name: 'types', type: 'string', required: false, description: 'File types: all, spaces, snippets, images, gdocs, zips, pdfs' },
+            { name: 'limit', type: 'number', required: false, description: 'Maximum files to return (default 100, max 100)' },
+            { name: 'cursor', type: 'string', required: false, description: 'Pagination cursor' },
+        ],
+    },
+    {
+        name: 'get_file_info',
+        description: 'Get information about a file',
+        params: [
+            { name: 'file_id', type: 'string', required: true, description: 'The ID of the file' },
+        ],
+    },
+    {
+        name: 'delete_file',
+        description: 'Delete a file',
+        params: [
+            { name: 'file_id', type: 'string', required: true, description: 'The ID of the file to delete' },
+        ],
+    },
+    {
+        name: 'share_file',
+        description: 'Share a file to a channel',
+        params: [
+            { name: 'file_id', type: 'string', required: true, description: 'The ID of the file' },
+            { name: 'channel_id', type: 'string', required: true, description: 'The ID of the channel to share to' },
+        ],
+    },
+    // --------------------------------------------------------------------------
+    // REMINDERS
+    // --------------------------------------------------------------------------
+    {
+        name: 'create_reminder',
+        description: 'Create a reminder',
+        params: [
+            { name: 'text', type: 'string', required: true, description: 'The reminder text' },
+            { name: 'time', type: 'string', required: true, description: 'When to remind: Unix timestamp, or natural language like "in 20 minutes", "tomorrow at 9am"' },
+            { name: 'user_id', type: 'string', required: false, description: 'User to remind (default: calling user)' },
+        ],
+    },
+    {
+        name: 'list_reminders',
+        description: 'List reminders for the calling user',
+        params: [],
+    },
+    {
+        name: 'delete_reminder',
+        description: 'Delete a reminder',
+        params: [
+            { name: 'reminder_id', type: 'string', required: true, description: 'The ID of the reminder to delete' },
+        ],
+    },
+    {
+        name: 'complete_reminder',
+        description: 'Mark a reminder as complete',
+        params: [
+            { name: 'reminder_id', type: 'string', required: true, description: 'The ID of the reminder to complete' },
+        ],
+    },
+    // --------------------------------------------------------------------------
+    // USERS
+    // --------------------------------------------------------------------------
+    {
+        name: 'get_users',
+        description: 'Get a list of all users in the workspace with their basic profile information',
+        params: [
+            { name: 'limit', type: 'number', required: false, description: 'Maximum number of users to return (default 100, max 200)' },
+            { name: 'cursor', type: 'string', required: false, description: 'Pagination cursor for next page of results' },
+        ],
+    },
+    {
+        name: 'get_user_profile',
+        description: 'Get detailed profile information for a specific user',
+        params: [
+            { name: 'user_id', type: 'string', required: true, description: 'The ID of the user' },
+        ],
+    },
+    {
+        name: 'get_user_by_email',
+        description: 'Find a user by their email address',
+        params: [
+            { name: 'email', type: 'string', required: true, description: 'Email address to look up' },
+        ],
+    },
+    {
+        name: 'get_user_presence',
+        description: 'Get a user\'s current presence status',
+        params: [
+            { name: 'user_id', type: 'string', required: true, description: 'The ID of the user' },
+        ],
+    },
+    {
+        name: 'set_user_presence',
+        description: 'Set the calling user\'s presence (auto or away)',
+        params: [
+            { name: 'presence', type: 'string', required: true, description: 'Presence status: auto or away' },
+        ],
+    },
+    // --------------------------------------------------------------------------
+    // USER GROUPS
+    // --------------------------------------------------------------------------
+    {
+        name: 'list_usergroups',
+        description: 'List user groups in the workspace',
+        params: [
+            { name: 'include_count', type: 'boolean', required: false, description: 'Include user counts (default: false)' },
+            { name: 'include_disabled', type: 'boolean', required: false, description: 'Include disabled groups (default: false)' },
+            { name: 'include_users', type: 'boolean', required: false, description: 'Include user lists (default: false)' },
+        ],
+    },
+    {
+        name: 'create_usergroup',
+        description: 'Create a user group',
+        params: [
+            { name: 'name', type: 'string', required: true, description: 'Name of the user group' },
+            { name: 'handle', type: 'string', required: false, description: 'Mention handle (without @)' },
+            { name: 'description', type: 'string', required: false, description: 'Description of the group' },
+            { name: 'channels', type: 'array', required: false, description: 'Default channels for the group' },
+        ],
+    },
+    {
+        name: 'update_usergroup',
+        description: 'Update a user group',
+        params: [
+            { name: 'usergroup_id', type: 'string', required: true, description: 'The ID of the user group' },
+            { name: 'name', type: 'string', required: false, description: 'New name' },
+            { name: 'handle', type: 'string', required: false, description: 'New mention handle' },
+            { name: 'description', type: 'string', required: false, description: 'New description' },
+            { name: 'channels', type: 'array', required: false, description: 'New default channels' },
+        ],
+    },
+    {
+        name: 'enable_usergroup',
+        description: 'Enable a disabled user group',
+        params: [
+            { name: 'usergroup_id', type: 'string', required: true, description: 'The ID of the user group' },
+        ],
+    },
+    {
+        name: 'disable_usergroup',
+        description: 'Disable a user group',
+        params: [
+            { name: 'usergroup_id', type: 'string', required: true, description: 'The ID of the user group' },
+        ],
+    },
+    {
+        name: 'list_usergroup_users',
+        description: 'List users in a user group',
+        params: [
+            { name: 'usergroup_id', type: 'string', required: true, description: 'The ID of the user group' },
+            { name: 'include_disabled', type: 'boolean', required: false, description: 'Include disabled users' },
+        ],
+    },
+    {
+        name: 'update_usergroup_users',
+        description: 'Update the members of a user group',
+        params: [
+            { name: 'usergroup_id', type: 'string', required: true, description: 'The ID of the user group' },
+            { name: 'user_ids', type: 'array', required: true, description: 'Array of user IDs to set as members' },
+        ],
+    },
+    // --------------------------------------------------------------------------
+    // STARS
+    // --------------------------------------------------------------------------
+    {
+        name: 'add_star',
+        description: 'Star an item (message, file, channel)',
+        params: [
+            { name: 'channel_id', type: 'string', required: false, description: 'Channel ID (for starring a channel or message)' },
+            { name: 'timestamp', type: 'string', required: false, description: 'Message timestamp (for starring a message)' },
+            { name: 'file_id', type: 'string', required: false, description: 'File ID (for starring a file)' },
+        ],
+    },
+    {
+        name: 'remove_star',
+        description: 'Remove a star from an item',
+        params: [
+            { name: 'channel_id', type: 'string', required: false, description: 'Channel ID' },
+            { name: 'timestamp', type: 'string', required: false, description: 'Message timestamp' },
+            { name: 'file_id', type: 'string', required: false, description: 'File ID' },
+        ],
+    },
+    {
+        name: 'list_stars',
+        description: 'List starred items for the calling user',
+        params: [
+            { name: 'limit', type: 'number', required: false, description: 'Maximum items to return (default 100, max 100)' },
+            { name: 'cursor', type: 'string', required: false, description: 'Pagination cursor' },
+        ],
+    },
+    // --------------------------------------------------------------------------
+    // EMOJI
+    // --------------------------------------------------------------------------
+    {
+        name: 'list_emoji',
+        description: 'List custom emoji in the workspace',
+        params: [
+            { name: 'include_categories', type: 'boolean', required: false, description: 'Include emoji categories' },
+        ],
+    },
+    // --------------------------------------------------------------------------
+    // TEAM / WORKSPACE
+    // --------------------------------------------------------------------------
+    {
+        name: 'get_team_info',
+        description: 'Get information about the workspace/team',
+        params: [],
+    },
+    // --------------------------------------------------------------------------
+    // SEARCH
+    // --------------------------------------------------------------------------
+    {
+        name: 'search_messages',
+        description: 'Search for messages in the workspace',
+        params: [
+            { name: 'query', type: 'string', required: true, description: 'Search query (supports Slack search modifiers)' },
+            { name: 'sort', type: 'string', required: false, description: 'Sort order: score or timestamp (default: score)' },
+            { name: 'sort_dir', type: 'string', required: false, description: 'Sort direction: asc or desc (default: desc)' },
+            { name: 'count', type: 'number', required: false, description: 'Number of results per page (default 20, max 100)' },
+            { name: 'page', type: 'number', required: false, description: 'Page number (default 1)' },
+        ],
+    },
+    {
+        name: 'search_files',
+        description: 'Search for files in the workspace',
+        params: [
+            { name: 'query', type: 'string', required: true, description: 'Search query (supports Slack search modifiers)' },
+            { name: 'sort', type: 'string', required: false, description: 'Sort order: score or timestamp (default: score)' },
+            { name: 'sort_dir', type: 'string', required: false, description: 'Sort direction: asc or desc (default: desc)' },
+            { name: 'count', type: 'number', required: false, description: 'Number of results per page (default 20, max 100)' },
+            { name: 'page', type: 'number', required: false, description: 'Page number (default 1)' },
+        ],
+    },
+    {
+        name: 'search_all',
+        description: 'Search for messages and files in the workspace',
+        params: [
+            { name: 'query', type: 'string', required: true, description: 'Search query (supports Slack search modifiers)' },
+            { name: 'sort', type: 'string', required: false, description: 'Sort order: score or timestamp (default: score)' },
+            { name: 'sort_dir', type: 'string', required: false, description: 'Sort direction: asc or desc (default: desc)' },
+            { name: 'count', type: 'number', required: false, description: 'Number of results per page (default 20, max 100)' },
+            { name: 'page', type: 'number', required: false, description: 'Page number (default 1)' },
+        ],
+    },
+    // --------------------------------------------------------------------------
+    // APP HOME / VIEWS
+    // --------------------------------------------------------------------------
+    {
+        name: 'publish_home_view',
+        description: 'Publish a view to a user\'s App Home tab',
+        params: [
+            { name: 'user_id', type: 'string', required: true, description: 'User ID to publish to' },
+            { name: 'view', type: 'object', required: true, description: 'View payload with type: home and blocks array' },
+        ],
+    },
+    // --------------------------------------------------------------------------
+    // DO NOT DISTURB
+    // --------------------------------------------------------------------------
+    {
+        name: 'get_dnd_info',
+        description: 'Get Do Not Disturb settings for a user',
+        params: [
+            { name: 'user_id', type: 'string', required: false, description: 'User ID (default: calling user)' },
+        ],
+    },
+    {
+        name: 'set_snooze',
+        description: 'Turn on Do Not Disturb for the calling user',
+        params: [
+            { name: 'num_minutes', type: 'number', required: true, description: 'Number of minutes to snooze' },
+        ],
+    },
+    {
+        name: 'end_snooze',
+        description: 'End Do Not Disturb for the calling user',
+        params: [],
+    },
+    {
+        name: 'end_dnd',
+        description: 'End the current DND session immediately',
+        params: [],
+    },
+];
+// ============================================================================
+// ACTION IMPLEMENTATIONS
+// ============================================================================
+// --------------------------------------------------------------------------
+// CONVERSATIONS / CHANNELS
+// --------------------------------------------------------------------------
+async function listChannels(params) {
+    const { limit = 100, cursor, types = 'public_channel', exclude_archived = false } = params;
+    const queryParams = {
+        limit: Math.min(Number(limit) || 100, 1000),
+        types: String(types),
+        exclude_archived: Boolean(exclude_archived),
+    };
+    if (cursor)
+        queryParams.cursor = cursor;
+    const response = await axios.get(`${BASE_URL}/conversations.list`, {
+        headers: headers(),
+        params: queryParams,
+    });
+    return response.data;
+}
+async function getChannelInfo(params) {
+    const { channel_id, include_num_members = false } = params;
+    if (!channel_id)
+        throw new Error('channel_id is required');
+    const response = await axios.get(`${BASE_URL}/conversations.info`, {
+        headers: headers(),
+        params: {
+            channel: channel_id,
+            include_num_members: Boolean(include_num_members),
+        },
+    });
+    return response.data;
+}
+async function createChannel(params) {
+    const { name, is_private = false, description } = params;
+    if (!name)
+        throw new Error('name is required');
+    const payload = {
+        name: String(name),
+        is_private: Boolean(is_private),
+    };
+    const response = await axios.post(`${BASE_URL}/conversations.create`, payload, { headers: headers() });
+    // Set description/purpose if provided
+    if (response.data.ok && description && response.data.channel?.id) {
+        await axios.post(`${BASE_URL}/conversations.setPurpose`, {
+            channel: response.data.channel.id,
+            purpose: String(description),
+        }, { headers: headers() });
+    }
+    return response.data;
+}
+async function archiveChannel(params) {
+    const { channel_id } = params;
+    if (!channel_id)
+        throw new Error('channel_id is required');
+    const response = await axios.post(`${BASE_URL}/conversations.archive`, {
+        channel: channel_id,
+    }, { headers: headers() });
+    return response.data;
+}
+async function unarchiveChannel(params) {
+    const { channel_id } = params;
+    if (!channel_id)
+        throw new Error('channel_id is required');
+    const response = await axios.post(`${BASE_URL}/conversations.unarchive`, {
+        channel: channel_id,
+    }, { headers: headers() });
+    return response.data;
+}
+async function renameChannel(params) {
+    const { channel_id, name } = params;
+    if (!channel_id || !name)
+        throw new Error('channel_id and name are required');
+    const response = await axios.post(`${BASE_URL}/conversations.rename`, {
+        channel: channel_id,
+        name: String(name),
+    }, { headers: headers() });
+    return response.data;
+}
+async function setChannelTopic(params) {
+    const { channel_id, topic } = params;
+    if (!channel_id || topic === undefined)
+        throw new Error('channel_id and topic are required');
+    const response = await axios.post(`${BASE_URL}/conversations.setTopic`, {
+        channel: channel_id,
+        topic: String(topic),
+    }, { headers: headers() });
+    return response.data;
+}
+async function setChannelPurpose(params) {
+    const { channel_id, purpose } = params;
+    if (!channel_id || purpose === undefined)
+        throw new Error('channel_id and purpose are required');
+    const response = await axios.post(`${BASE_URL}/conversations.setPurpose`, {
+        channel: channel_id,
+        purpose: String(purpose),
+    }, { headers: headers() });
+    return response.data;
+}
+async function joinChannel(params) {
+    const { channel_id } = params;
+    if (!channel_id)
+        throw new Error('channel_id is required');
+    const response = await axios.post(`${BASE_URL}/conversations.join`, {
+        channel: channel_id,
+    }, { headers: headers() });
+    return response.data;
+}
+async function leaveChannel(params) {
+    const { channel_id } = params;
+    if (!channel_id)
+        throw new Error('channel_id is required');
+    const response = await axios.post(`${BASE_URL}/conversations.leave`, {
+        channel: channel_id,
+    }, { headers: headers() });
+    return response.data;
+}
+async function inviteToChannel(params) {
+    const { channel_id, user_ids } = params;
+    if (!channel_id || !user_ids)
+        throw new Error('channel_id and user_ids are required');
+    const users = Array.isArray(user_ids) ? user_ids.join(',') : String(user_ids);
+    const response = await axios.post(`${BASE_URL}/conversations.invite`, {
+        channel: channel_id,
+        users,
+    }, { headers: headers() });
+    return response.data;
+}
+async function kickFromChannel(params) {
+    const { channel_id, user_id } = params;
+    if (!channel_id || !user_id)
+        throw new Error('channel_id and user_id are required');
+    const response = await axios.post(`${BASE_URL}/conversations.kick`, {
+        channel: channel_id,
+        user: user_id,
+    }, { headers: headers() });
+    return response.data;
+}
+async function getChannelMembers(params) {
+    const { channel_id, limit = 100, cursor } = params;
+    if (!channel_id)
+        throw new Error('channel_id is required');
+    const queryParams = {
+        channel: channel_id,
+        limit: Math.min(Number(limit) || 100, 1000),
+    };
+    if (cursor)
+        queryParams.cursor = cursor;
+    const response = await axios.get(`${BASE_URL}/conversations.members`, {
+        headers: headers(),
+        params: queryParams,
+    });
+    return response.data;
+}
+// --------------------------------------------------------------------------
+// DIRECT MESSAGES
+// --------------------------------------------------------------------------
+async function openDm(params) {
+    const { user_id, user_ids, return_im = false } = params;
+    const payload = {
+        return_im: Boolean(return_im),
+    };
+    if (user_ids && Array.isArray(user_ids)) {
+        payload.users = user_ids.join(',');
+    }
+    else if (user_id) {
+        payload.users = String(user_id);
+    }
+    else {
+        throw new Error('user_id or user_ids is required');
+    }
+    const response = await axios.post(`${BASE_URL}/conversations.open`, payload, { headers: headers() });
+    return response.data;
+}
+async function postDm(params) {
+    const { user_id, text, blocks } = params;
+    if (!user_id || !text)
+        throw new Error('user_id and text are required');
+    // First open/get the DM channel
+    const openResponse = await axios.post(`${BASE_URL}/conversations.open`, {
+        users: String(user_id),
+    }, { headers: headers() });
+    if (!openResponse.data.ok) {
+        throw new Error(`Failed to open DM: ${openResponse.data.error}`);
+    }
+    const channelId = openResponse.data.channel.id;
+    // Then post the message
+    const payload = {
+        channel: channelId,
+        text: String(text),
+    };
+    if (blocks)
+        payload.blocks = blocks;
+    const response = await axios.post(`${BASE_URL}/chat.postMessage`, payload, { headers: headers() });
+    return response.data;
+}
+// --------------------------------------------------------------------------
+// MESSAGES
+// --------------------------------------------------------------------------
+async function postMessage(params) {
+    const { channel_id, text, blocks, attachments, unfurl_links, unfurl_media, mrkdwn } = params;
+    if (!channel_id || !text)
+        throw new Error('channel_id and text are required');
+    const payload = {
+        channel: channel_id,
+        text: String(text),
+    };
+    if (blocks)
+        payload.blocks = blocks;
+    if (attachments)
+        payload.attachments = attachments;
+    if (unfurl_links !== undefined)
+        payload.unfurl_links = Boolean(unfurl_links);
+    if (unfurl_media !== undefined)
+        payload.unfurl_media = Boolean(unfurl_media);
+    if (mrkdwn !== undefined)
+        payload.mrkdwn = Boolean(mrkdwn);
+    const response = await axios.post(`${BASE_URL}/chat.postMessage`, payload, { headers: headers() });
+    return response.data;
+}
+async function replyToThread(params) {
+    const { channel_id, thread_ts, text, blocks, broadcast = false } = params;
+    if (!channel_id || !thread_ts || !text)
+        throw new Error('channel_id, thread_ts, and text are required');
+    const payload = {
+        channel: channel_id,
+        thread_ts: String(thread_ts),
+        text: String(text),
+        reply_broadcast: Boolean(broadcast),
+    };
+    if (blocks)
+        payload.blocks = blocks;
+    const response = await axios.post(`${BASE_URL}/chat.postMessage`, payload, { headers: headers() });
+    return response.data;
+}
+async function updateMessage(params) {
+    const { channel_id, ts, text, blocks, attachments } = params;
+    if (!channel_id || !ts || !text)
+        throw new Error('channel_id, ts, and text are required');
+    const payload = {
+        channel: channel_id,
+        ts: String(ts),
+        text: String(text),
+    };
+    if (blocks)
+        payload.blocks = blocks;
+    if (attachments)
+        payload.attachments = attachments;
+    const response = await axios.post(`${BASE_URL}/chat.update`, payload, { headers: headers() });
+    return response.data;
+}
+async function deleteMessage(params) {
+    const { channel_id, ts } = params;
+    if (!channel_id || !ts)
+        throw new Error('channel_id and ts are required');
+    const response = await axios.post(`${BASE_URL}/chat.delete`, {
+        channel: channel_id,
+        ts: String(ts),
+    }, { headers: headers() });
+    return response.data;
+}
+async function getChannelHistory(params) {
+    const { channel_id, limit = 100, cursor, oldest, latest, inclusive } = params;
+    if (!channel_id)
+        throw new Error('channel_id is required');
+    const queryParams = {
+        channel: channel_id,
+        limit: Math.min(Number(limit) || 100, 1000),
+    };
+    if (cursor)
+        queryParams.cursor = cursor;
+    if (oldest)
+        queryParams.oldest = String(oldest);
+    if (latest)
+        queryParams.latest = String(latest);
+    if (inclusive !== undefined)
+        queryParams.inclusive = Boolean(inclusive);
+    const response = await axios.get(`${BASE_URL}/conversations.history`, {
+        headers: headers(),
+        params: queryParams,
+    });
+    return response.data;
+}
+async function getThreadReplies(params) {
+    const { channel_id, thread_ts, limit = 100, cursor } = params;
+    if (!channel_id || !thread_ts)
+        throw new Error('channel_id and thread_ts are required');
+    const queryParams = {
+        channel: channel_id,
+        ts: thread_ts,
+        limit: Math.min(Number(limit) || 100, 1000),
+    };
+    if (cursor)
+        queryParams.cursor = cursor;
+    const response = await axios.get(`${BASE_URL}/conversations.replies`, {
+        headers: headers(),
+        params: queryParams,
+    });
+    return response.data;
+}
+async function getPermalink(params) {
+    const { channel_id, message_ts } = params;
+    if (!channel_id || !message_ts)
+        throw new Error('channel_id and message_ts are required');
+    const response = await axios.get(`${BASE_URL}/chat.getPermalink`, {
+        headers: headers(),
+        params: {
+            channel: channel_id,
+            message_ts: String(message_ts),
+        },
+    });
+    return response.data;
+}
+// --------------------------------------------------------------------------
+// SCHEDULED MESSAGES
+// --------------------------------------------------------------------------
+async function scheduleMessage(params) {
+    const { channel_id, text, post_at, blocks, thread_ts } = params;
+    if (!channel_id || !text || !post_at)
+        throw new Error('channel_id, text, and post_at are required');
+    const payload = {
+        channel: channel_id,
+        text: String(text),
+        post_at: Number(post_at),
+    };
+    if (blocks)
+        payload.blocks = blocks;
+    if (thread_ts)
+        payload.thread_ts = String(thread_ts);
+    const response = await axios.post(`${BASE_URL}/chat.scheduleMessage`, payload, { headers: headers() });
+    return response.data;
+}
+async function listScheduledMessages(params) {
+    const { channel_id, limit = 100, cursor } = params;
+    const queryParams = {
+        limit: Math.min(Number(limit) || 100, 100),
+    };
+    if (channel_id)
+        queryParams.channel = channel_id;
+    if (cursor)
+        queryParams.cursor = cursor;
+    const response = await axios.post(`${BASE_URL}/chat.scheduledMessages.list`, queryParams, { headers: headers() });
+    return response.data;
+}
+async function deleteScheduledMessage(params) {
+    const { channel_id, scheduled_message_id } = params;
+    if (!channel_id || !scheduled_message_id)
+        throw new Error('channel_id and scheduled_message_id are required');
+    const response = await axios.post(`${BASE_URL}/chat.deleteScheduledMessage`, {
+        channel: channel_id,
+        scheduled_message_id: String(scheduled_message_id),
+    }, { headers: headers() });
+    return response.data;
+}
+// --------------------------------------------------------------------------
+// REACTIONS
+// --------------------------------------------------------------------------
+async function addReaction(params) {
+    const { channel_id, timestamp, reaction } = params;
+    if (!channel_id || !timestamp || !reaction)
+        throw new Error('channel_id, timestamp, and reaction are required');
+    const response = await axios.post(`${BASE_URL}/reactions.add`, {
+        channel: channel_id,
+        timestamp: String(timestamp),
+        name: String(reaction),
+    }, { headers: headers() });
+    return response.data;
+}
+async function removeReaction(params) {
+    const { channel_id, timestamp, reaction } = params;
+    if (!channel_id || !timestamp || !reaction)
+        throw new Error('channel_id, timestamp, and reaction are required');
+    const response = await axios.post(`${BASE_URL}/reactions.remove`, {
+        channel: channel_id,
+        timestamp: String(timestamp),
+        name: String(reaction),
+    }, { headers: headers() });
+    return response.data;
+}
+async function getReactions(params) {
+    const { channel_id, timestamp, full = false } = params;
+    if (!channel_id || !timestamp)
+        throw new Error('channel_id and timestamp are required');
+    const response = await axios.get(`${BASE_URL}/reactions.get`, {
+        headers: headers(),
+        params: {
+            channel: channel_id,
+            timestamp: String(timestamp),
+            full: Boolean(full),
+        },
+    });
+    return response.data;
+}
+async function listReactions(params) {
+    const { user_id, limit = 100, cursor } = params;
+    const queryParams = {
+        count: Math.min(Number(limit) || 100, 100),
+    };
+    if (user_id)
+        queryParams.user = user_id;
+    if (cursor)
+        queryParams.cursor = cursor;
+    const response = await axios.get(`${BASE_URL}/reactions.list`, {
+        headers: headers(),
+        params: queryParams,
+    });
+    return response.data;
+}
+// --------------------------------------------------------------------------
+// PINS
+// --------------------------------------------------------------------------
+async function pinMessage(params) {
+    const { channel_id, timestamp } = params;
+    if (!channel_id || !timestamp)
+        throw new Error('channel_id and timestamp are required');
+    const response = await axios.post(`${BASE_URL}/pins.add`, {
+        channel: channel_id,
+        timestamp: String(timestamp),
+    }, { headers: headers() });
+    return response.data;
+}
+async function unpinMessage(params) {
+    const { channel_id, timestamp } = params;
+    if (!channel_id || !timestamp)
+        throw new Error('channel_id and timestamp are required');
+    const response = await axios.post(`${BASE_URL}/pins.remove`, {
+        channel: channel_id,
+        timestamp: String(timestamp),
+    }, { headers: headers() });
+    return response.data;
+}
+async function listPins(params) {
+    const { channel_id } = params;
+    if (!channel_id)
+        throw new Error('channel_id is required');
+    const response = await axios.get(`${BASE_URL}/pins.list`, {
+        headers: headers(),
+        params: { channel: channel_id },
+    });
+    return response.data;
+}
+// --------------------------------------------------------------------------
+// BOOKMARKS
+// --------------------------------------------------------------------------
+async function addBookmark(params) {
+    const { channel_id, title, type, link, emoji } = params;
+    if (!channel_id || !title || !type)
+        throw new Error('channel_id, title, and type are required');
+    const payload = {
+        channel_id: String(channel_id),
+        title: String(title),
+        type: String(type),
+    };
+    if (link)
+        payload.link = String(link);
+    if (emoji)
+        payload.emoji = String(emoji);
+    const response = await axios.post(`${BASE_URL}/bookmarks.add`, payload, { headers: headers() });
+    return response.data;
+}
+async function editBookmark(params) {
+    const { channel_id, bookmark_id, title, link, emoji } = params;
+    if (!channel_id || !bookmark_id)
+        throw new Error('channel_id and bookmark_id are required');
+    const payload = {
+        channel_id: String(channel_id),
+        bookmark_id: String(bookmark_id),
+    };
+    if (title)
+        payload.title = String(title);
+    if (link)
+        payload.link = String(link);
+    if (emoji)
+        payload.emoji = String(emoji);
+    const response = await axios.post(`${BASE_URL}/bookmarks.edit`, payload, { headers: headers() });
+    return response.data;
+}
+async function removeBookmark(params) {
+    const { channel_id, bookmark_id } = params;
+    if (!channel_id || !bookmark_id)
+        throw new Error('channel_id and bookmark_id are required');
+    const response = await axios.post(`${BASE_URL}/bookmarks.remove`, {
+        channel_id: String(channel_id),
+        bookmark_id: String(bookmark_id),
+    }, { headers: headers() });
+    return response.data;
+}
+async function listBookmarks(params) {
+    const { channel_id } = params;
+    if (!channel_id)
+        throw new Error('channel_id is required');
+    const response = await axios.get(`${BASE_URL}/bookmarks.list`, {
+        headers: headers(),
+        params: { channel_id },
+    });
+    return response.data;
+}
+// --------------------------------------------------------------------------
+// FILES
+// --------------------------------------------------------------------------
+async function uploadFile(params) {
+    const { channel_id, file_path, title, initial_comment, thread_ts } = params;
+    if (!channel_id || !file_path)
+        throw new Error('channel_id and file_path are required');
+    const filePath = String(file_path);
+    if (!fs.existsSync(filePath))
+        throw new Error(`File not found: ${filePath}`);
+    const stats = fs.statSync(filePath);
+    if (stats.size === 0)
+        throw new Error('File is empty');
+    const filename = path.basename(filePath);
+    const fileSize = stats.size;
+    // Step 1: Get upload URL
+    const uploadUrlResponse = await axios.get(`${BASE_URL}/files.getUploadURLExternal`, {
+        headers: headers(),
+        params: { filename, length: fileSize },
+    });
+    if (!uploadUrlResponse.data.ok) {
+        throw new Error(`Slack API error (getUploadURLExternal): ${uploadUrlResponse.data.error}`);
+    }
+    const { upload_url, file_id } = uploadUrlResponse.data;
+    // Step 2: Upload file content
+    const fileContent = fs.readFileSync(filePath);
+    await axios.post(upload_url, fileContent, {
+        headers: { 'Content-Type': 'application/octet-stream' },
+        maxContentLength: Infinity,
+        maxBodyLength: Infinity,
+    });
+    // Step 3: Complete the upload
+    const fileTitle = title ? String(title) : filename;
+    const completePayload = {
+        files: [{ id: file_id, title: fileTitle }],
+        channel_id: String(channel_id),
+    };
+    if (initial_comment)
+        completePayload.initial_comment = String(initial_comment);
+    if (thread_ts)
+        completePayload.thread_ts = String(thread_ts);
+    const completeResponse = await axios.post(`${BASE_URL}/files.completeUploadExternal`, completePayload, { headers: headers() });
+    if (!completeResponse.data.ok) {
+        throw new Error(`Slack API error (completeUploadExternal): ${completeResponse.data.error}`);
+    }
+    const uploadedFile = completeResponse.data.files?.[0];
+    return {
+        ok: true,
+        file: {
+            id: uploadedFile?.id || file_id,
+            name: uploadedFile?.name || filename,
+            title: uploadedFile?.title || fileTitle,
+            mimetype: uploadedFile?.mimetype,
+            size: fileSize,
+            url_private: uploadedFile?.url_private,
+            permalink: uploadedFile?.permalink,
+        },
+        channel: channel_id,
+        thread_ts: thread_ts || null,
+    };
+}
+async function listFiles(params) {
+    const { channel_id, user_id, types, limit = 100, cursor } = params;
+    const queryParams = {
+        count: Math.min(Number(limit) || 100, 100),
+    };
+    if (channel_id)
+        queryParams.channel = channel_id;
+    if (user_id)
+        queryParams.user = user_id;
+    if (types)
+        queryParams.types = String(types);
+    if (cursor)
+        queryParams.cursor = cursor;
+    const response = await axios.get(`${BASE_URL}/files.list`, {
+        headers: headers(),
+        params: queryParams,
+    });
+    return response.data;
+}
+async function getFileInfo(params) {
+    const { file_id } = params;
+    if (!file_id)
+        throw new Error('file_id is required');
+    const response = await axios.get(`${BASE_URL}/files.info`, {
+        headers: headers(),
+        params: { file: file_id },
+    });
+    return response.data;
+}
+async function deleteFile(params) {
+    const { file_id } = params;
+    if (!file_id)
+        throw new Error('file_id is required');
+    const response = await axios.post(`${BASE_URL}/files.delete`, {
+        file: file_id,
+    }, { headers: headers() });
+    return response.data;
+}
+async function shareFile(params) {
+    const { file_id, channel_id } = params;
+    if (!file_id || !channel_id)
+        throw new Error('file_id and channel_id are required');
+    const response = await axios.post(`${BASE_URL}/files.sharedPublicURL`, {
+        file: file_id,
+    }, { headers: headers() });
+    // Also share to channel
+    if (response.data.ok) {
+        // Use chat.postMessage with the file
+        await axios.post(`${BASE_URL}/chat.postMessage`, {
+            channel: channel_id,
+            text: `<${response.data.file?.permalink_public || ''}>`,
+        }, { headers: headers() });
+    }
+    return response.data;
+}
+// --------------------------------------------------------------------------
+// REMINDERS
+// --------------------------------------------------------------------------
+async function createReminder(params) {
+    const { text, time, user_id } = params;
+    if (!text || !time)
+        throw new Error('text and time are required');
+    const payload = {
+        text: String(text),
+        time: String(time),
+    };
+    if (user_id)
+        payload.user = String(user_id);
+    const response = await axios.post(`${BASE_URL}/reminders.add`, payload, { headers: headers() });
+    return response.data;
+}
+async function listReminders() {
+    const response = await axios.get(`${BASE_URL}/reminders.list`, { headers: headers() });
+    return response.data;
+}
+async function deleteReminder(params) {
+    const { reminder_id } = params;
+    if (!reminder_id)
+        throw new Error('reminder_id is required');
+    const response = await axios.post(`${BASE_URL}/reminders.delete`, {
+        reminder: reminder_id,
+    }, { headers: headers() });
+    return response.data;
+}
+async function completeReminder(params) {
+    const { reminder_id } = params;
+    if (!reminder_id)
+        throw new Error('reminder_id is required');
+    const response = await axios.post(`${BASE_URL}/reminders.complete`, {
+        reminder: reminder_id,
+    }, { headers: headers() });
+    return response.data;
+}
+// --------------------------------------------------------------------------
+// USERS
+// --------------------------------------------------------------------------
+async function getUsers(params) {
+    const { limit = 100, cursor } = params;
+    const queryParams = {
+        limit: Math.min(Number(limit) || 100, 200),
+    };
+    if (cursor)
+        queryParams.cursor = cursor;
+    const response = await axios.get(`${BASE_URL}/users.list`, {
+        headers: headers(),
+        params: queryParams,
+    });
+    return response.data;
+}
+async function getUserProfile(params) {
+    const { user_id } = params;
+    if (!user_id)
+        throw new Error('user_id is required');
+    const response = await axios.get(`${BASE_URL}/users.profile.get`, {
+        headers: headers(),
+        params: { user: user_id },
+    });
+    return response.data;
+}
+async function getUserByEmail(params) {
+    const { email } = params;
+    if (!email)
+        throw new Error('email is required');
+    const response = await axios.get(`${BASE_URL}/users.lookupByEmail`, {
+        headers: headers(),
+        params: { email: String(email) },
+    });
+    return response.data;
+}
+async function getUserPresence(params) {
+    const { user_id } = params;
+    if (!user_id)
+        throw new Error('user_id is required');
+    const response = await axios.get(`${BASE_URL}/users.getPresence`, {
+        headers: headers(),
+        params: { user: user_id },
+    });
+    return response.data;
+}
+async function setUserPresence(params) {
+    const { presence } = params;
+    if (!presence)
+        throw new Error('presence is required (auto or away)');
+    const response = await axios.post(`${BASE_URL}/users.setPresence`, {
+        presence: String(presence),
+    }, { headers: headers() });
+    return response.data;
+}
+// --------------------------------------------------------------------------
+// USER GROUPS
+// --------------------------------------------------------------------------
+async function listUsergroups(params) {
+    const { include_count = false, include_disabled = false, include_users = false } = params;
+    const response = await axios.get(`${BASE_URL}/usergroups.list`, {
+        headers: headers(),
+        params: {
+            include_count: Boolean(include_count),
+            include_disabled: Boolean(include_disabled),
+            include_users: Boolean(include_users),
+        },
+    });
+    return response.data;
+}
+async function createUsergroup(params) {
+    const { name, handle, description, channels } = params;
+    if (!name)
+        throw new Error('name is required');
+    const payload = { name: String(name) };
+    if (handle)
+        payload.handle = String(handle);
+    if (description)
+        payload.description = String(description);
+    if (channels && Array.isArray(channels))
+        payload.channels = channels.join(',');
+    const response = await axios.post(`${BASE_URL}/usergroups.create`, payload, { headers: headers() });
+    return response.data;
+}
+async function updateUsergroup(params) {
+    const { usergroup_id, name, handle, description, channels } = params;
+    if (!usergroup_id)
+        throw new Error('usergroup_id is required');
+    const payload = { usergroup: usergroup_id };
+    if (name)
+        payload.name = String(name);
+    if (handle)
+        payload.handle = String(handle);
+    if (description)
+        payload.description = String(description);
+    if (channels && Array.isArray(channels))
+        payload.channels = channels.join(',');
+    const response = await axios.post(`${BASE_URL}/usergroups.update`, payload, { headers: headers() });
+    return response.data;
+}
+async function enableUsergroup(params) {
+    const { usergroup_id } = params;
+    if (!usergroup_id)
+        throw new Error('usergroup_id is required');
+    const response = await axios.post(`${BASE_URL}/usergroups.enable`, {
+        usergroup: usergroup_id,
+    }, { headers: headers() });
+    return response.data;
+}
+async function disableUsergroup(params) {
+    const { usergroup_id } = params;
+    if (!usergroup_id)
+        throw new Error('usergroup_id is required');
+    const response = await axios.post(`${BASE_URL}/usergroups.disable`, {
+        usergroup: usergroup_id,
+    }, { headers: headers() });
+    return response.data;
+}
+async function listUsergroupUsers(params) {
+    const { usergroup_id, include_disabled = false } = params;
+    if (!usergroup_id)
+        throw new Error('usergroup_id is required');
+    const response = await axios.get(`${BASE_URL}/usergroups.users.list`, {
+        headers: headers(),
+        params: {
+            usergroup: usergroup_id,
+            include_disabled: Boolean(include_disabled),
+        },
+    });
+    return response.data;
+}
+async function updateUsergroupUsers(params) {
+    const { usergroup_id, user_ids } = params;
+    if (!usergroup_id || !user_ids)
+        throw new Error('usergroup_id and user_ids are required');
+    const users = Array.isArray(user_ids) ? user_ids.join(',') : String(user_ids);
+    const response = await axios.post(`${BASE_URL}/usergroups.users.update`, {
+        usergroup: usergroup_id,
+        users,
+    }, { headers: headers() });
+    return response.data;
+}
+// --------------------------------------------------------------------------
+// STARS
+// --------------------------------------------------------------------------
+async function addStar(params) {
+    const { channel_id, timestamp, file_id } = params;
+    if (!channel_id && !file_id)
+        throw new Error('channel_id or file_id is required');
+    const payload = {};
+    if (channel_id)
+        payload.channel = channel_id;
+    if (timestamp)
+        payload.timestamp = String(timestamp);
+    if (file_id)
+        payload.file = file_id;
+    const response = await axios.post(`${BASE_URL}/stars.add`, payload, { headers: headers() });
+    return response.data;
+}
+async function removeStar(params) {
+    const { channel_id, timestamp, file_id } = params;
+    if (!channel_id && !file_id)
+        throw new Error('channel_id or file_id is required');
+    const payload = {};
+    if (channel_id)
+        payload.channel = channel_id;
+    if (timestamp)
+        payload.timestamp = String(timestamp);
+    if (file_id)
+        payload.file = file_id;
+    const response = await axios.post(`${BASE_URL}/stars.remove`, payload, { headers: headers() });
+    return response.data;
+}
+async function listStars(params) {
+    const { limit = 100, cursor } = params;
+    const queryParams = {
+        count: Math.min(Number(limit) || 100, 100),
+    };
+    if (cursor)
+        queryParams.cursor = cursor;
+    const response = await axios.get(`${BASE_URL}/stars.list`, {
+        headers: headers(),
+        params: queryParams,
+    });
+    return response.data;
+}
+// --------------------------------------------------------------------------
+// EMOJI
+// --------------------------------------------------------------------------
+async function listEmoji(params) {
+    const { include_categories = false } = params;
+    const response = await axios.get(`${BASE_URL}/emoji.list`, {
+        headers: headers(),
+        params: { include_categories: Boolean(include_categories) },
+    });
+    return response.data;
+}
+// --------------------------------------------------------------------------
+// TEAM / WORKSPACE
+// --------------------------------------------------------------------------
+async function getTeamInfo() {
+    const response = await axios.get(`${BASE_URL}/team.info`, { headers: headers() });
+    return response.data;
+}
+// --------------------------------------------------------------------------
+// SEARCH
+// --------------------------------------------------------------------------
+async function searchMessages(params) {
+    const { query, sort = 'score', sort_dir = 'desc', count = 20, page = 1 } = params;
+    if (!query)
+        throw new Error('query is required');
+    const response = await axios.get(`${BASE_URL}/search.messages`, {
+        headers: headers(),
+        params: {
+            query: String(query),
+            sort: String(sort),
+            sort_dir: String(sort_dir),
+            count: Math.min(Number(count) || 20, 100),
+            page: Number(page) || 1,
+        },
+    });
+    return response.data;
+}
+async function searchFiles(params) {
+    const { query, sort = 'score', sort_dir = 'desc', count = 20, page = 1 } = params;
+    if (!query)
+        throw new Error('query is required');
+    const response = await axios.get(`${BASE_URL}/search.files`, {
+        headers: headers(),
+        params: {
+            query: String(query),
+            sort: String(sort),
+            sort_dir: String(sort_dir),
+            count: Math.min(Number(count) || 20, 100),
+            page: Number(page) || 1,
+        },
+    });
+    return response.data;
+}
+async function searchAll(params) {
+    const { query, sort = 'score', sort_dir = 'desc', count = 20, page = 1 } = params;
+    if (!query)
+        throw new Error('query is required');
+    const response = await axios.get(`${BASE_URL}/search.all`, {
+        headers: headers(),
+        params: {
+            query: String(query),
+            sort: String(sort),
+            sort_dir: String(sort_dir),
+            count: Math.min(Number(count) || 20, 100),
+            page: Number(page) || 1,
+        },
+    });
+    return response.data;
+}
+// --------------------------------------------------------------------------
+// APP HOME / VIEWS
+// --------------------------------------------------------------------------
+async function publishHomeView(params) {
+    const { user_id, view } = params;
+    if (!user_id || !view)
+        throw new Error('user_id and view are required');
+    const response = await axios.post(`${BASE_URL}/views.publish`, {
+        user_id: String(user_id),
+        view,
+    }, { headers: headers() });
+    return response.data;
+}
+// --------------------------------------------------------------------------
+// DO NOT DISTURB
+// --------------------------------------------------------------------------
+async function getDndInfo(params) {
+    const { user_id } = params;
+    const queryParams = {};
+    if (user_id)
+        queryParams.user = user_id;
+    const response = await axios.get(`${BASE_URL}/dnd.info`, {
+        headers: headers(),
+        params: queryParams,
+    });
+    return response.data;
+}
+async function setSnooze(params) {
+    const { num_minutes } = params;
+    if (!num_minutes)
+        throw new Error('num_minutes is required');
+    const response = await axios.post(`${BASE_URL}/dnd.setSnooze`, {
+        num_minutes: Number(num_minutes),
+    }, { headers: headers() });
+    return response.data;
+}
+async function endSnooze() {
+    const response = await axios.post(`${BASE_URL}/dnd.endSnooze`, {}, { headers: headers() });
+    return response.data;
+}
+async function endDnd() {
+    const response = await axios.post(`${BASE_URL}/dnd.endDnd`, {}, { headers: headers() });
+    return response.data;
+}
+// ============================================================================
+// BACKEND EXPORT
+// ============================================================================
+export const slackBackend = {
+    name: 'slack',
+    description: 'Comprehensive Slack workspace integration: messaging, channels, DMs, files, reminders, search, user groups, reactions, pins, bookmarks, and more',
+    actions,
+    async execute(action, params) {
+        switch (action) {
+            // Conversations / Channels
+            case 'list_channels': return listChannels(params);
+            case 'get_channel_info': return getChannelInfo(params);
+            case 'create_channel': return createChannel(params);
+            case 'archive_channel': return archiveChannel(params);
+            case 'unarchive_channel': return unarchiveChannel(params);
+            case 'rename_channel': return renameChannel(params);
+            case 'set_channel_topic': return setChannelTopic(params);
+            case 'set_channel_purpose': return setChannelPurpose(params);
+            case 'join_channel': return joinChannel(params);
+            case 'leave_channel': return leaveChannel(params);
+            case 'invite_to_channel': return inviteToChannel(params);
+            case 'kick_from_channel': return kickFromChannel(params);
+            case 'get_channel_members': return getChannelMembers(params);
+            // Direct Messages
+            case 'open_dm': return openDm(params);
+            case 'post_dm': return postDm(params);
+            // Messages
+            case 'post_message': return postMessage(params);
+            case 'reply_to_thread': return replyToThread(params);
+            case 'update_message': return updateMessage(params);
+            case 'delete_message': return deleteMessage(params);
+            case 'get_channel_history': return getChannelHistory(params);
+            case 'get_thread_replies': return getThreadReplies(params);
+            case 'get_permalink': return getPermalink(params);
+            // Scheduled Messages
+            case 'schedule_message': return scheduleMessage(params);
+            case 'list_scheduled_messages': return listScheduledMessages(params);
+            case 'delete_scheduled_message': return deleteScheduledMessage(params);
+            // Reactions
+            case 'add_reaction': return addReaction(params);
+            case 'remove_reaction': return removeReaction(params);
+            case 'get_reactions': return getReactions(params);
+            case 'list_reactions': return listReactions(params);
+            // Pins
+            case 'pin_message': return pinMessage(params);
+            case 'unpin_message': return unpinMessage(params);
+            case 'list_pins': return listPins(params);
+            // Bookmarks
+            case 'add_bookmark': return addBookmark(params);
+            case 'edit_bookmark': return editBookmark(params);
+            case 'remove_bookmark': return removeBookmark(params);
+            case 'list_bookmarks': return listBookmarks(params);
+            // Files
+            case 'upload_file': return uploadFile(params);
+            case 'list_files': return listFiles(params);
+            case 'get_file_info': return getFileInfo(params);
+            case 'delete_file': return deleteFile(params);
+            case 'share_file': return shareFile(params);
+            // Reminders
+            case 'create_reminder': return createReminder(params);
+            case 'list_reminders': return listReminders();
+            case 'delete_reminder': return deleteReminder(params);
+            case 'complete_reminder': return completeReminder(params);
+            // Users
+            case 'get_users': return getUsers(params);
+            case 'get_user_profile': return getUserProfile(params);
+            case 'get_user_by_email': return getUserByEmail(params);
+            case 'get_user_presence': return getUserPresence(params);
+            case 'set_user_presence': return setUserPresence(params);
+            // User Groups
+            case 'list_usergroups': return listUsergroups(params);
+            case 'create_usergroup': return createUsergroup(params);
+            case 'update_usergroup': return updateUsergroup(params);
+            case 'enable_usergroup': return enableUsergroup(params);
+            case 'disable_usergroup': return disableUsergroup(params);
+            case 'list_usergroup_users': return listUsergroupUsers(params);
+            case 'update_usergroup_users': return updateUsergroupUsers(params);
+            // Stars
+            case 'add_star': return addStar(params);
+            case 'remove_star': return removeStar(params);
+            case 'list_stars': return listStars(params);
+            // Emoji
+            case 'list_emoji': return listEmoji(params);
+            // Team / Workspace
+            case 'get_team_info': return getTeamInfo();
+            // Search
+            case 'search_messages': return searchMessages(params);
+            case 'search_files': return searchFiles(params);
+            case 'search_all': return searchAll(params);
+            // App Home / Views
+            case 'publish_home_view': return publishHomeView(params);
+            // Do Not Disturb
+            case 'get_dnd_info': return getDndInfo(params);
+            case 'set_snooze': return setSnooze(params);
+            case 'end_snooze': return endSnooze();
+            case 'end_dnd': return endDnd();
+            default:
+                throw new Error(`Unknown action: ${action}`);
+        }
+    },
+    async healthCheck() {
+        if (!SLACK_BOT_TOKEN) {
+            return { status: 'unavailable', latency_ms: 0, error: 'SLACK_BOT_TOKEN not configured' };
+        }
+        try {
+            const start = Date.now();
+            const response = await axios.post(`${BASE_URL}/auth.test`, {}, { headers: headers() });
+            const latency = Date.now() - start;
+            if (response.data.ok) {
+                return { status: 'healthy', latency_ms: latency };
+            }
+            return { status: 'unavailable', latency_ms: latency, error: response.data.error };
+        }
+        catch (error) {
+            return { status: 'unavailable', latency_ms: 0, error: error instanceof Error ? error.message : String(error) };
+        }
+    },
+};
+//# sourceMappingURL=slack.js.map