@frogbotai/piece-slack 0.29.0 → 0.30.0

package/dist/actions.js

@@ -1,29 +1,33 @@
+import { filesCollectionSlug } from 'frogbot/pieces';
 import { z } from 'zod';
-import { slackApiResult, slackResponse, slackValue, slackValues, } from './client.js';
+import { slackApiResult, slackResponse, slackValue, slackValues } from './client.js';
 import { defineAction } from './define.js';
 import { loadSlackFile, slackFile } from './files.js';
 import { channelOptions, userOptions } from './options.js';
-const channel = z.string().min(1).meta({ label: 'Channel' });
-const user = z.string().min(1).meta({ label: 'User' });
+const channel = z.string().min(1).meta({
+    label: 'Channel'
+});
+const user = z.string().min(1).meta({
+    label: 'User'
+});
 const timestamp = z.string().regex(/^(?:.*\/p\d{16}|\d+\.\d{6})$/, 'Invalid Slack timestamp.');
 const blocks = z.array(slackValue).default([]);
 const messageResult = slackResponse.extend({
     channel: z.string().optional(),
-    ts: z.string().optional(),
+    ts: z.string().optional()
 });
 function normalizeTimestamp(value) {
     const link = value.match(/\/p(\d+)(\d{6})$/);
     return link ? `${link[1]}.${link[2]}` : value;
 }
-async function upload({ client, file, channelId, title, initialComment, threadTimestamp, token = 'bot', signal, }) {
-    const created = await client.request('files.getUploadURLExternal', { filename: file.name, length: file.data.size }, token);
+async function upload({ client, file, channelId, title, initialComment, threadTimestamp, token = 'bot', signal }) {
+    const created = await client.request('files.getUploadURLExternal', {
+        filename: file.name,
+        length: file.data.size
+    }, token);
     const uploadUrl = typeof created.upload_url === 'string' ? new URL(created.upload_url) : undefined;
     const fileId = typeof created.file_id === 'string' ? created.file_id : undefined;
-    if (!uploadUrl ||
-        !fileId ||
-        uploadUrl.protocol !== 'https:' ||
-        uploadUrl.username ||
-        uploadUrl.password) {
+    if (!uploadUrl || !fileId || uploadUrl.protocol !== 'https:' || uploadUrl.username || uploadUrl.password) {
         throw new Error('Slack returned an invalid file upload target.');
     }
     if (uploadUrl.hostname !== 'files.slack.com' && !uploadUrl.hostname.endsWith('.slack.com')) {
@@ -33,15 +37,19 @@ async function upload({ client, file, channelId, title, initialComment, threadTi
         method: 'POST',
         body: file.data,
         redirect: 'error',
-        signal,
+        signal
     });
-    if (!response.ok)
-        throw new Error(`Slack file upload failed (${response.status}).`);
+    if (!response.ok) throw new Error(`Slack file upload failed (${response.status}).`);
     return client.request('files.completeUploadExternal', {
-        files: [{ id: fileId, title }],
+        files: [
+            {
+                id: fileId,
+                title
+            }
+        ],
         channel_id: channelId,
         initial_comment: initialComment,
-        thread_ts: threadTimestamp,
+        thread_ts: threadTimestamp
     }, token);
 }
 const messageFields = {
@@ -50,17 +58,22 @@ const messageFields = {
     profilePicture: z.url().optional(),
     iconEmoji: z.string().optional(),
     blocks,
-    unfurlLinks: z.boolean().default(true),
+    unfurlLinks: z.boolean().default(true)
 };
-const sendDirectMessageInput = z.object({ userId: user, ...messageFields });
+const sendDirectMessageInput = z.object({
+    userId: user,
+    ...messageFields
+});
 export const sendDirectMessage = defineAction({
     slug: 'sendDirectMessage',
     description: 'Send a direct message to a Slack user.',
     input: sendDirectMessageInput,
     output: messageResult,
     idempotent: false,
-    options: { userId: userOptions },
-    async run({ client, input }) {
+    options: {
+        userId: userOptions
+    },
+    async run ({ client, input }) {
         return client.request('chat.postMessage', {
             channel: input.userId,
             text: input.text,
@@ -68,12 +81,11 @@ export const sendDirectMessage = defineAction({
             icon_url: input.profilePicture,
             icon_emoji: input.iconEmoji,
             blocks: input.blocks,
-            unfurl_links: input.unfurlLinks,
+            unfurl_links: input.unfurlLinks
         });
-    },
+    }
 });
-const sendChannelInput = z
-    .object({
+const sendChannelInput = z.object({
     channel,
     text: z.string().optional(),
     sendAsBot: z.boolean().default(true),
@@ -84,10 +96,9 @@ const sendChannelInput = z
     file: slackFile.optional(),
     replyBroadcast: z.boolean().default(false),
     unfurlLinks: z.boolean().default(true),
-    blocks,
-})
-    .refine(({ text, blocks: value }) => Boolean(text) || value.length > 0, {
-    message: 'A message or Block Kit blocks are required.',
+    blocks
+}).refine(({ text, blocks: value })=>Boolean(text) || value.length > 0, {
+    message: 'A message or Block Kit blocks are required.'
 });
 export const sendChannelMessage = defineAction({
     slug: 'sendChannelMessage',
@@ -95,8 +106,10 @@ export const sendChannelMessage = defineAction({
     input: sendChannelInput,
     output: slackResponse,
     idempotent: false,
-    options: { channel: channelOptions },
-    async run({ client, input, req }) {
+    options: {
+        channel: channelOptions
+    },
+    async run ({ client, input, req }) {
         const token = input.sendAsBot ? 'bot' : 'user';
         if (input.file) {
             const file = await loadSlackFile(req, input.file);
@@ -105,11 +118,9 @@ export const sendChannelMessage = defineAction({
                 file,
                 channelId: input.channel,
                 initialComment: input.text,
-                threadTimestamp: input.threadTimestamp
-                    ? normalizeTimestamp(input.threadTimestamp)
-                    : undefined,
+                threadTimestamp: input.threadTimestamp ? normalizeTimestamp(input.threadTimestamp) : undefined,
                 token,
-                signal: req.signal,
+                signal: req.signal
             });
         }
         return client.request('chat.postMessage', {
@@ -121,15 +132,15 @@ export const sendChannelMessage = defineAction({
             icon_emoji: input.iconEmoji,
             reply_broadcast: input.replyBroadcast,
             unfurl_links: input.unfurlLinks,
-            blocks: input.blocks,
+            blocks: input.blocks
         }, token);
-    },
+    }
 });
 const addReactionInput = z.object({
     channel,
     timestamp,
     reaction: z.string().min(1),
-    reactAsUser: z.boolean().default(false),
+    reactAsUser: z.boolean().default(false)
 });
 export const addReaction = defineAction({
     slug: 'addReaction',
@@ -137,20 +148,22 @@ export const addReaction = defineAction({
     input: addReactionInput,
     output: slackResponse,
     idempotent: true,
-    options: { channel: channelOptions },
-    async run({ client, input }) {
+    options: {
+        channel: channelOptions
+    },
+    async run ({ client, input }) {
         return client.request('reactions.add', {
             channel: input.channel,
             timestamp: normalizeTimestamp(input.timestamp),
-            name: input.reaction,
+            name: input.reaction
         }, input.reactAsUser ? 'user' : 'bot');
-    },
+    }
 });
 const uploadFileInput = z.object({
     file: slackFile,
     title: z.string().optional(),
     filename: z.string().optional(),
-    channel: channel.optional(),
+    channel: channel.optional()
 });
 export const uploadFile = defineAction({
     slug: 'uploadFile',
@@ -158,65 +171,68 @@ export const uploadFile = defineAction({
     input: uploadFileInput,
     output: slackResponse,
     idempotent: false,
-    options: { channel: channelOptions },
-    async run({ client, input, req }) {
+    options: {
+        channel: channelOptions
+    },
+    async run ({ client, input, req }) {
         const loaded = await loadSlackFile(req, {
             ...input.file,
-            name: input.filename ?? input.file.name,
+            name: input.filename ?? input.file.name
         });
         return upload({
             client,
             file: loaded,
             channelId: input.channel,
             title: input.title,
-            signal: req.signal,
+            signal: req.signal
         });
-    },
+    }
+});
+const getFileInput = z.object({
+    fileId: z.string().min(1)
 });
-const getFileInput = z.object({ fileId: z.string().min(1) });
 export const getFile = defineAction({
     slug: 'getFile',
     description: 'Get Slack file metadata and safely download its contents.',
     input: getFileInput,
     output: slackValue,
     idempotent: true,
-    async run({ client, input, req }) {
-        const response = await client.request('files.info', { file: input.fileId });
+    async run ({ client, input, req }) {
+        const response = await client.request('files.info', {
+            file: input.fileId
+        });
         const file = response.file;
-        if (!file ||
-            typeof file !== 'object' ||
-            !('url_private_download' in file) ||
-            typeof file.url_private_download !== 'string') {
+        if (!file || typeof file !== 'object' || !('url_private_download' in file) || typeof file.url_private_download !== 'string') {
             throw new Error('Slack file has no download URL.');
         }
         const url = new URL(file.url_private_download);
-        if (url.protocol !== 'https:' ||
-            url.hostname !== 'files.slack.com' ||
-            url.username ||
-            url.password) {
+        if (url.protocol !== 'https:' || url.hostname !== 'files.slack.com' || url.username || url.password) {
             throw new Error('Slack file download URL is untrusted.');
         }
         const downloaded = await fetch(url, {
-            headers: { authorization: `Bearer ${client.token()}` },
+            headers: {
+                authorization: `Bearer ${client.token()}`
+            },
             redirect: 'error',
-            signal: req.signal,
+            signal: req.signal
         });
-        if (!downloaded.ok)
-            throw new Error(`Slack file download failed (${downloaded.status}).`);
+        if (!downloaded.ok) throw new Error(`Slack file download failed (${downloaded.status}).`);
         const data = Buffer.from(await downloaded.arrayBuffer());
         const name = 'name' in file && typeof file.name === 'string' ? file.name : `slack-${input.fileId}`;
         const mimeType = downloaded.headers.get('content-type')?.split(';')[0] || 'application/octet-stream';
-        const collection = req.frogbot.config.files?.slug;
-        if (!collection) {
-            throw new Error('[frogbot] Slack file downloads require the files collection.');
-        }
+        const collection = filesCollectionSlug(req, 'Slack');
         req.signal?.throwIfAborted();
         const saved = await req.frogbot.create({
             collection,
             data: {},
-            file: { data, name, mimetype: mimeType, size: data.length },
+            file: {
+                data,
+                name,
+                mimetype: mimeType,
+                size: data.length
+            },
             req,
-            overrideAccess: false,
+            overrideAccess: false
         });
         return {
             ...file,
@@ -225,96 +241,104 @@ export const getFile = defineAction({
                 name,
                 mimeType,
                 size: data.length,
-                url: typeof saved.url === 'string' ? saved.url : undefined,
-            },
+                url: typeof saved.url === 'string' ? saved.url : undefined
+            }
         };
-    },
+    }
+});
+const searchMessagesInput = z.object({
+    query: z.string().min(1)
 });
-const searchMessagesInput = z.object({ query: z.string().min(1) });
 export const searchMessages = defineAction({
     slug: 'searchMessages',
     description: 'Search all Slack messages matching a query.',
     input: searchMessagesInput,
     output: slackValues,
     idempotent: true,
-    async run({ client, input }) {
+    async run ({ client, input }) {
         const matches = [];
         let cursor = '*';
         do {
-            const response = await client.request('search.messages', { query: input.query, count: 100, cursor }, 'user');
+            const response = await client.request('search.messages', {
+                query: input.query,
+                count: 100,
+                cursor
+            }, 'user');
             const messages = response.messages;
-            if (!messages || typeof messages !== 'object')
-                break;
+            if (!messages || typeof messages !== 'object') break;
             if ('matches' in messages && Array.isArray(messages.matches)) {
-                for (const match of messages.matches) {
+                for (const match of messages.matches){
                     if (match && typeof match === 'object' && !Array.isArray(match)) {
                         matches.push(Object.fromEntries(Object.entries(match)));
                     }
                 }
             }
             const pagination = 'pagination' in messages ? messages.pagination : undefined;
-            cursor =
-                pagination && typeof pagination === 'object' && 'next_cursor' in pagination
-                    ? String(pagination.next_cursor || '') || undefined
-                    : undefined;
-        } while (cursor);
+            cursor = pagination && typeof pagination === 'object' && 'next_cursor' in pagination ? String(pagination.next_cursor || '') || undefined : undefined;
+        }while (cursor)
         return matches;
-    },
+    }
+});
+const emailInput = z.object({
+    email: z.email()
 });
-const emailInput = z.object({ email: z.email() });
 export const findUserByEmail = defineAction({
     slug: 'findUserByEmail',
     description: 'Find a Slack user by exact email address.',
     input: emailInput,
     output: slackResponse,
     idempotent: true,
-    async run({ client, input }) {
+    async run ({ client, input }) {
         return client.request('users.lookupByEmail', input);
-    },
+    }
+});
+const handleInput = z.object({
+    handle: z.string().min(1)
 });
-const handleInput = z.object({ handle: z.string().min(1) });
 export const findUserByHandle = defineAction({
     slug: 'findUserByHandle',
     description: 'Find a Slack user by display-name handle.',
     input: handleInput,
     output: slackValue,
     idempotent: true,
-    async run({ client, input }) {
+    async run ({ client, input }) {
         const handle = input.handle.replace(/^@/, '');
         const members = await client.paginate({
             path: 'users.list',
             item: 'members',
-            body: { limit: 1000 },
+            body: {
+                limit: 1000
+            }
         });
-        const found = members.find((member) => {
-            if (!member || typeof member !== 'object' || !('profile' in member))
-                return false;
+        const found = members.find((member)=>{
+            if (!member || typeof member !== 'object' || !('profile' in member)) return false;
             const profile = member.profile;
-            return (profile &&
-                typeof profile === 'object' &&
-                'display_name' in profile &&
-                profile.display_name === handle);
+            return profile && typeof profile === 'object' && 'display_name' in profile && profile.display_name === handle;
         });
         if (!found || typeof found !== 'object') {
             throw new Error(`Could not find user with handle @${handle}`);
         }
         return found;
-    },
+    }
+});
+const findUserByIdInput = z.object({
+    id: z.string().min(1)
 });
-const findUserByIdInput = z.object({ id: z.string().min(1) });
 export const findUserById = defineAction({
     slug: 'findUserById',
     description: 'Find a Slack user profile by ID.',
     input: findUserByIdInput,
     output: slackResponse,
     idempotent: true,
-    async run({ client, input }) {
-        return client.request('users.profile.get', { user: input.id });
-    },
+    async run ({ client, input }) {
+        return client.request('users.profile.get', {
+            user: input.id
+        });
+    }
 });
 const listUsersInput = z.object({
     includeBots: z.boolean().default(false),
-    includeDisabled: z.boolean().default(false),
+    includeDisabled: z.boolean().default(false)
 });
 export const listUsers = defineAction({
     slug: 'listUsers',
@@ -322,60 +346,79 @@ export const listUsers = defineAction({
     input: listUsersInput,
     output: slackValues,
     idempotent: true,
-    async run({ client, input }) {
+    async run ({ client, input }) {
         const members = await client.paginate({
             path: 'users.list',
             item: 'members',
-            body: { limit: 1000 },
+            body: {
+                limit: 1000
+            }
         });
-        return members.filter((member) => {
-            if (!member || typeof member !== 'object')
-                return false;
-            if (!input.includeBots && 'is_bot' in member && member.is_bot === true)
-                return false;
-            if (!input.includeDisabled && 'deleted' in member && member.deleted === true)
-                return false;
+        return members.filter((member)=>{
+            if (!member || typeof member !== 'object') return false;
+            if (!input.includeBots && 'is_bot' in member && member.is_bot === true) return false;
+            if (!input.includeDisabled && 'deleted' in member && member.deleted === true) return false;
             return true;
         });
-    },
+    }
+});
+const updateMessageInput = z.object({
+    channel,
+    timestamp,
+    text: z.string().min(1),
+    blocks
 });
-const updateMessageInput = z.object({ channel, timestamp, text: z.string().min(1), blocks });
 export const updateMessage = defineAction({
     slug: 'updateMessage',
     description: 'Update an existing Slack message.',
     input: updateMessageInput,
     output: slackResponse,
     idempotent: true,
-    options: { channel: channelOptions },
-    async run({ client, input }) {
+    options: {
+        channel: channelOptions
+    },
+    async run ({ client, input }) {
         return client.request('chat.update', {
             channel: input.channel,
             ts: normalizeTimestamp(input.timestamp),
             text: input.text,
-            blocks: input.blocks,
+            blocks: input.blocks
         });
-    },
+    }
+});
+const deleteMessageInput = z.object({
+    channel,
+    timestamp
 });
-const deleteMessageInput = z.object({ channel, timestamp });
 export const deleteMessage = defineAction({
     slug: 'deleteMessage',
     description: 'Delete a Slack message after confirming it exists.',
     input: deleteMessageInput,
     output: slackResponse,
     idempotent: false,
-    options: { channel: channelOptions },
-    async run({ client, input }) {
+    options: {
+        channel: channelOptions
+    },
+    async run ({ client, input }) {
         const ts = normalizeTimestamp(input.timestamp);
-        const history = await client.request('conversations.history', { channel: input.channel, oldest: ts, limit: 1, inclusive: true }, 'user');
+        const history = await client.request('conversations.history', {
+            channel: input.channel,
+            oldest: ts,
+            limit: 1,
+            inclusive: true
+        }, 'user');
         if (!Array.isArray(history.messages) || history.messages.length === 0) {
             throw new Error('No message found for the provided timestamp.');
         }
-        return client.request('chat.delete', { channel: input.channel, ts }, 'user');
-    },
+        return client.request('chat.delete', {
+            channel: input.channel,
+            ts
+        }, 'user');
+    }
 });
 const createChannelInput = z.object({
     channelName: z.string().min(1),
-    isPrivate: z.boolean().default(false),
+    isPrivate: z.boolean().default(false)
 });
 export const createChannel = defineAction({
     slug: 'createChannel',
@@ -383,18 +426,18 @@ export const createChannel = defineAction({
     input: createChannelInput,
     output: slackResponse,
     idempotent: false,
-    async run({ client, input }) {
+    async run ({ client, input }) {
         return client.request('conversations.create', {
             name: input.channelName,
-            is_private: input.isPrivate,
+            is_private: input.isPrivate
         });
-    },
+    }
 });
 const updateProfileInput = z.object({
     firstName: z.string().optional(),
     lastName: z.string().optional(),
     email: z.email().optional(),
-    userId: z.string().optional(),
+    userId: z.string().optional()
 });
 export const updateProfile = defineAction({
     slug: 'updateProfile',
@@ -402,19 +445,23 @@ export const updateProfile = defineAction({
     input: updateProfileInput,
     output: slackResponse,
     idempotent: true,
-    async run({ client, input }) {
+    async run ({ client, input }) {
         return client.request('users.profile.set', {
-            profile: { first_name: input.firstName, last_name: input.lastName, email: input.email },
-            user: input.userId,
+            profile: {
+                first_name: input.firstName,
+                last_name: input.lastName,
+                email: input.email
+            },
+            user: input.userId
         }, 'user');
-    },
+    }
 });
 const getChannelHistoryInput = z.object({
     channel,
     oldest: z.number().optional(),
     latest: z.number().optional(),
     inclusive: z.boolean().default(false),
-    includeAllMetadata: z.boolean().default(false),
+    includeAllMetadata: z.boolean().default(false)
 });
 export const getChannelHistory = defineAction({
     slug: 'getChannelHistory',
@@ -422,8 +469,10 @@ export const getChannelHistory = defineAction({
     input: getChannelHistoryInput,
     output: slackValues,
     idempotent: true,
-    options: { channel: channelOptions },
-    async run({ client, input }) {
+    options: {
+        channel: channelOptions
+    },
+    async run ({ client, input }) {
         return client.paginate({
             path: 'conversations.history',
             item: 'messages',
@@ -433,15 +482,15 @@ export const getChannelHistory = defineAction({
                 latest: input.latest,
                 inclusive: input.inclusive,
                 include_all_metadata: input.includeAllMetadata,
-                limit: 200,
-            },
+                limit: 200
+            }
         });
-    },
+    }
 });
 const setUserStatusInput = z.object({
     text: z.string().max(100),
     emoji: z.string().optional(),
-    expiration: z.number().int().optional(),
+    expiration: z.number().int().optional()
 });
 export const setUserStatus = defineAction({
     slug: 'setUserStatus',
@@ -449,88 +498,118 @@ export const setUserStatus = defineAction({
     input: setUserStatusInput,
     output: slackResponse,
     idempotent: true,
-    async run({ client, input }) {
+    async run ({ client, input }) {
         return client.request('users.profile.set', {
             profile: {
                 status_text: input.text,
                 status_emoji: input.emoji,
-                status_expiration: input.expiration,
-            },
+                status_expiration: input.expiration
+            }
         }, 'user');
-    },
+    }
+});
+const markdownToSlackInput = z.object({
+    markdown: z.string()
+});
+const markdownToSlackOutput = z.object({
+    text: z.string()
 });
-const markdownToSlackInput = z.object({ markdown: z.string() });
-const markdownToSlackOutput = z.object({ text: z.string() });
 export const markdownToSlack = defineAction({
     slug: 'markdownToSlack',
     description: 'Convert Markdown text to Slack mrkdwn.',
     input: markdownToSlackInput,
     output: markdownToSlackOutput,
     idempotent: true,
-    async run({ input }) {
-        const text = input.markdown
-            .replace(/\[([^\]]+)]\((https?:\/\/[^)]+)\)/g, '<$2|$1>')
-            .replace(/\*\*([^*]+)\*\*/g, '*$1*')
-            .replace(/^[-+] /gm, '• ');
-        return { text };
-    },
+    async run ({ input }) {
+        const text = input.markdown.replace(/\[([^\]]+)]\((https?:\/\/[^)]+)\)/g, '<$2|$1>').replace(/\*\*([^*]+)\*\*/g, '*$1*').replace(/^[-+] /gm, '• ');
+        return {
+            text
+        };
+    }
+});
+const listThreadMessagesInput = z.object({
+    channel,
+    threadTimestamp: timestamp
 });
-const listThreadMessagesInput = z.object({ channel, threadTimestamp: timestamp });
 export const listThreadMessages = defineAction({
     slug: 'listThreadMessages',
     description: 'Retrieve all messages in a Slack thread.',
     input: listThreadMessagesInput,
     output: slackValues,
     idempotent: true,
-    options: { channel: channelOptions },
-    async run({ client, input }) {
+    options: {
+        channel: channelOptions
+    },
+    async run ({ client, input }) {
         return client.paginate({
             path: 'conversations.replies',
             item: 'messages',
-            body: { channel: input.channel, ts: normalizeTimestamp(input.threadTimestamp) },
+            body: {
+                channel: input.channel,
+                ts: normalizeTimestamp(input.threadTimestamp)
+            }
         });
-    },
+    }
+});
+const setChannelTopicInput = z.object({
+    channel,
+    topic: z.string()
 });
-const setChannelTopicInput = z.object({ channel, topic: z.string() });
 export const setChannelTopic = defineAction({
     slug: 'setChannelTopic',
     description: 'Set a Slack channel topic.',
     input: setChannelTopicInput,
     output: slackResponse,
     idempotent: true,
-    options: { channel: channelOptions },
-    async run({ client, input }) {
-        return client.request('conversations.setTopic', input);
+    options: {
+        channel: channelOptions
     },
+    async run ({ client, input }) {
+        return client.request('conversations.setTopic', input);
+    }
+});
+const getMessageInput = z.object({
+    channel,
+    timestamp
 });
-const getMessageInput = z.object({ channel, timestamp });
 export const getMessage = defineAction({
     slug: 'getMessage',
     description: 'Get a Slack message by channel and timestamp.',
     input: getMessageInput,
     output: slackResponse,
     idempotent: true,
-    options: { channel: channelOptions },
-    async run({ client, input }) {
+    options: {
+        channel: channelOptions
+    },
+    async run ({ client, input }) {
         return client.request('conversations.history', {
             channel: input.channel,
             oldest: normalizeTimestamp(input.timestamp),
             limit: 1,
-            inclusive: true,
+            inclusive: true
         });
-    },
+    }
+});
+const inviteUserToChannelInput = z.object({
+    channel,
+    userId: user
 });
-const inviteUserToChannelInput = z.object({ channel, userId: user });
 export const inviteUserToChannel = defineAction({
     slug: 'inviteUserToChannel',
     description: 'Invite an existing user to a Slack channel.',
     input: inviteUserToChannelInput,
     output: slackResponse,
     idempotent: false,
-    options: { channel: channelOptions, userId: userOptions },
-    async run({ client, input }) {
-        return client.request('conversations.invite', { channel: input.channel, users: input.userId });
+    options: {
+        channel: channelOptions,
+        userId: userOptions
     },
+    async run ({ client, input }) {
+        return client.request('conversations.invite', {
+            channel: input.channel,
+            users: input.userId
+        });
+    }
 });
 export const getUserGroupByHandle = defineAction({
     slug: 'getUserGroupByHandle',
@@ -538,18 +617,15 @@ export const getUserGroupByHandle = defineAction({
     input: handleInput,
     output: slackValue,
     idempotent: true,
-    async run({ client, input }) {
+    async run ({ client, input }) {
         return findUserGroup(client, input.handle);
-    },
+    }
 });
 async function findUserGroup(client, value) {
     const handle = value.replace(/^@/, '').toLowerCase();
     const response = await client.request('usergroups.list');
     const groups = Array.isArray(response.usergroups) ? response.usergroups : [];
-    const found = groups.find((group) => group &&
-        typeof group === 'object' &&
-        'handle' in group &&
-        String(group.handle).toLowerCase() === handle);
+    const found = groups.find((group)=>group && typeof group === 'object' && 'handle' in group && String(group.handle).toLowerCase() === handle);
     if (!found || typeof found !== 'object') {
         throw new Error(`User group with handle '@${handle}' not found.`);
     }
@@ -557,7 +633,7 @@ async function findUserGroup(client, value) {
 }
 const updateUserGroupMembersInput = handleInput.extend({
     userIds: z.array(z.string()).optional(),
-    appendUsers: z.boolean().default(true),
+    appendUsers: z.boolean().default(true)
 });
 export const updateUserGroupMembers = defineAction({
     slug: 'updateUserGroupMembers',
@@ -565,23 +641,39 @@ export const updateUserGroupMembers = defineAction({
     input: updateUserGroupMembersInput,
     output: slackResponse,
     idempotent: false,
-    async run({ client, input }) {
+    async run ({ client, input }) {
         const group = await findUserGroup(client, input.handle);
         const id = 'id' in group ? String(group.id) : '';
-        const existing = input.appendUsers && 'users' in group && Array.isArray(group.users)
-            ? group.users.map(String)
-            : [];
-        const users = [...new Set([...existing, ...(input.userIds ?? []).filter(Boolean)])].join(', ');
-        return client.request('usergroups.users.update', { usergroup: id, users }, 'user');
-    },
+        const existing = input.appendUsers && 'users' in group && Array.isArray(group.users) ? group.users.map(String) : [];
+        const users = [
+            ...new Set([
+                ...existing,
+                ...(input.userIds ?? []).filter(Boolean)
+            ])
+        ].join(', ');
+        return client.request('usergroups.users.update', {
+            usergroup: id,
+            users
+        }, 'user');
+    }
 });
 const customApiInput = z.object({
-    method: z.enum(['GET', 'POST', 'PUT', 'PATCH', 'DELETE']),
+    method: z.enum([
+        'GET',
+        'POST',
+        'PUT',
+        'PATCH',
+        'DELETE'
+    ]),
     path: z.string().regex(/^[a-zA-Z][a-zA-Z0-9._-]*$/),
     headers: z.record(z.string(), z.string()).default({}),
-    queryParams: z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])).default({}),
+    queryParams: z.record(z.string(), z.union([
+        z.string(),
+        z.number(),
+        z.boolean()
+    ])).default({}),
     body: z.record(z.string(), z.unknown()).optional(),
-    useUserToken: z.boolean().default(false),
+    useUserToken: z.boolean().default(false)
 });
 export const customApiCall = defineAction({
     slug: 'customApiCall',
@@ -589,10 +681,9 @@ export const customApiCall = defineAction({
     input: customApiInput,
     output: slackApiResult,
     idempotent: false,
-    async run({ client, input }) {
+    async run ({ client, input }) {
         const query = new URLSearchParams();
-        for (const [key, value] of Object.entries(input.queryParams))
-            query.set(key, String(value));
+        for (const [key, value] of Object.entries(input.queryParams))query.set(key, String(value));
         const suffix = query.size ? `?${query}` : '';
         const headers = new Headers(input.headers);
         headers.delete('authorization');
@@ -606,9 +697,9 @@ export const customApiCall = defineAction({
             method: input.method,
             headers,
             body: input.body === undefined ? undefined : JSON.stringify(input.body),
-            token: input.useUserToken ? 'user' : 'bot',
+            token: input.useUserToken ? 'user' : 'bot'
         });
-    },
+    }
 });
 export const slackActions = [
     addReaction,
@@ -634,6 +725,7 @@ export const slackActions = [
     inviteUserToChannel,
     getUserGroupByHandle,
     updateUserGroupMembers,
-    customApiCall,
+    customApiCall
 ];
+
 //# sourceMappingURL=actions.js.map