agent-messenger 1.14.0 → 2.0.0

package/dist/src/platforms/slack/client.js

@@ -10,21 +10,39 @@ export class SlackError extends Error {
 const MAX_RETRIES = 3;
 const RATE_LIMIT_ERROR_CODE = 'slack_webapi_rate_limited_error';
 export class SlackClient {
-    client;
-    token;
-    cookie;
-    constructor(token, cookie) {
-        if (!token) {
-            throw new SlackError('Token is required', 'missing_token');
+    client = null;
+    token = null;
+    cookie = null;
+    async login(credentials) {
+        if (credentials) {
+            if (!credentials.token) {
+                throw new SlackError('Token is required', 'missing_token');
+            }
+            if (!credentials.cookie) {
+                throw new SlackError('Cookie is required', 'missing_cookie');
+            }
+            this.token = credentials.token;
+            this.cookie = credentials.cookie;
+            this.client = new WebClient(credentials.token, {
+                headers: { Cookie: `d=${credentials.cookie}` },
+            });
+            return this;
         }
-        if (!cookie) {
-            throw new SlackError('Cookie is required', 'missing_cookie');
+        const { ensureSlackAuth } = await import('./ensure-auth.js');
+        await ensureSlackAuth();
+        const { SlackCredentialManager } = await import('./credential-manager.js');
+        const credManager = new SlackCredentialManager();
+        const workspace = await credManager.getWorkspace();
+        if (!workspace) {
+            throw new SlackError('No workspace credentials found. Make sure Slack desktop app is installed and logged in.', 'no_credentials');
         }
-        this.token = token;
-        this.cookie = cookie;
-        this.client = new WebClient(token, {
-            headers: { Cookie: `d=${cookie}` },
-        });
+        return this.login({ token: workspace.token, cookie: workspace.cookie });
+    }
+    ensureAuth() {
+        if (!this.client) {
+            throw new SlackError('Not authenticated. Call .login() first.', 'not_authenticated');
+        }
+        return this.client;
     }
     async withRetry(operation) {
         let lastError;
@@ -54,7 +72,7 @@ export class SlackClient {
     }
     async testAuth() {
         return this.withRetry(async () => {
-            const response = await this.client.auth.test();
+            const response = await this.ensureAuth().auth.test();
             this.checkResponse(response);
             return {
                 user_id: response.user_id,
@@ -69,7 +87,7 @@ export class SlackClient {
             const channels = [];
             let cursor;
             do {
-                const response = await this.client.conversations.list({
+                const response = await this.ensureAuth().conversations.list({
                     cursor,
                     limit: 200,
                     types: 'public_channel,private_channel',
@@ -111,7 +129,7 @@ export class SlackClient {
             const dms = [];
             let cursor;
             do {
-                const response = await this.client.conversations.list({
+                const response = await this.ensureAuth().conversations.list({
                     cursor,
                     limit: 200,
                     types: 'im,mpim',
@@ -134,7 +152,7 @@ export class SlackClient {
     }
     async getChannel(id) {
         return this.withRetry(async () => {
-            const response = await this.client.conversations.info({ channel: id });
+            const response = await this.ensureAuth().conversations.info({ channel: id });
             this.checkResponse(response);
             const ch = response.channel;
             return {
@@ -176,7 +194,7 @@ export class SlackClient {
     }
     async sendMessage(channel, text, threadTs) {
         return this.withRetry(async () => {
-            const response = await this.client.chat.postMessage({
+            const response = await this.ensureAuth().chat.postMessage({
                 channel,
                 text,
                 thread_ts: threadTs,
@@ -192,11 +210,15 @@ export class SlackClient {
             };
         });
     }
-    async getMessages(channel, limit = 20) {
+    async getMessages(channel, limitOrOptions) {
+        const options = typeof limitOrOptions === 'number' ? { limit: limitOrOptions } : (limitOrOptions ?? {});
+        const { limit = 20, oldest, latest } = options;
         return this.withRetry(async () => {
-            const response = await this.client.conversations.history({
+            const response = await this.ensureAuth().conversations.history({
                 channel,
                 limit,
+                oldest,
+                latest,
             });
             this.checkResponse(response);
             return (response.messages || []).map((msg) => ({
@@ -231,7 +253,7 @@ export class SlackClient {
     }
     async getMessage(channel, ts) {
         return this.withRetry(async () => {
-            const response = await this.client.conversations.history({
+            const response = await this.ensureAuth().conversations.history({
                 channel,
                 oldest: ts,
                 inclusive: true,
@@ -274,7 +296,7 @@ export class SlackClient {
     }
     async updateMessage(channel, ts, text) {
         return this.withRetry(async () => {
-            const response = await this.client.chat.update({
+            const response = await this.ensureAuth().chat.update({
                 channel,
                 ts,
                 text,
@@ -291,7 +313,7 @@ export class SlackClient {
     }
     async deleteMessage(channel, ts) {
         return this.withRetry(async () => {
-            const response = await this.client.chat.delete({
+            const response = await this.ensureAuth().chat.delete({
                 channel,
                 ts,
             });
@@ -300,7 +322,7 @@ export class SlackClient {
     }
     async addReaction(channel, ts, emoji) {
         return this.withRetry(async () => {
-            const response = await this.client.reactions.add({
+            const response = await this.ensureAuth().reactions.add({
                 channel,
                 timestamp: ts,
                 name: emoji,
@@ -310,7 +332,7 @@ export class SlackClient {
     }
     async removeReaction(channel, ts, emoji) {
         return this.withRetry(async () => {
-            const response = await this.client.reactions.remove({
+            const response = await this.ensureAuth().reactions.remove({
                 channel,
                 timestamp: ts,
                 name: emoji,
@@ -323,7 +345,7 @@ export class SlackClient {
             const users = [];
             let cursor;
             do {
-                const response = await this.client.users.list({
+                const response = await this.ensureAuth().users.list({
                     cursor,
                     limit: 200,
                 });
@@ -359,7 +381,7 @@ export class SlackClient {
             const members = [];
             let cursor;
             do {
-                const response = await this.client.conversations.members({
+                const response = await this.ensureAuth().conversations.members({
                     channel,
                     cursor,
                     limit: 200,
@@ -375,7 +397,7 @@ export class SlackClient {
     }
     async getUser(id) {
         return this.withRetry(async () => {
-            const response = await this.client.users.info({ user: id });
+            const response = await this.ensureAuth().users.info({ user: id });
             this.checkResponse(response);
             const member = response.user;
             return {
@@ -399,7 +421,7 @@ export class SlackClient {
     }
     async uploadFile(channels, file, filename) {
         return this.withRetry(async () => {
-            const response = await this.client.files.uploadV2({
+            const response = await this.ensureAuth().files.uploadV2({
                 channel_id: channels[0],
                 file,
                 filename,
@@ -425,7 +447,7 @@ export class SlackClient {
     }
     async listFiles(channel) {
         return this.withRetry(async () => {
-            const response = await this.client.files.list({
+            const response = await this.ensureAuth().files.list({
                 channel,
             });
             this.checkResponse(response);
@@ -444,7 +466,7 @@ export class SlackClient {
     }
     async getFileInfo(fileId) {
         return this.withRetry(async () => {
-            const response = await this.client.files.info({ file: fileId });
+            const response = await this.ensureAuth().files.info({ file: fileId });
             this.checkResponse(response);
             const f = response.file;
             return {
@@ -465,6 +487,7 @@ export class SlackClient {
         if (!file.url_private) {
             throw new SlackError('File has no download URL', 'no_download_url');
         }
+        this.ensureAuth();
         const response = await fetch(file.url_private, {
             headers: {
                 Authorization: `Bearer ${this.token}`,
@@ -482,7 +505,7 @@ export class SlackClient {
     }
     async searchMessages(query, options = {}) {
         return this.withRetry(async () => {
-            const response = await this.client.search.messages({
+            const response = await this.ensureAuth().search.messages({
                 query,
                 sort: options.sort || 'timestamp',
                 sort_dir: options.sortDir || 'desc',
@@ -505,7 +528,7 @@ export class SlackClient {
     }
     async getThreadReplies(channel, threadTs, options = {}) {
         return this.withRetry(async () => {
-            const response = await this.client.conversations.replies({
+            const response = await this.ensureAuth().conversations.replies({
                 channel,
                 ts: threadTs,
                 limit: options.limit || 100,
@@ -550,7 +573,7 @@ export class SlackClient {
     }
     async getUnreadCounts() {
         return this.withRetry(async () => {
-            const response = await this.client.apiCall('client.counts');
+            const response = await this.ensureAuth().apiCall('client.counts');
             this.checkResponse(response);
             const channels = (response.channels || []).map((ch) => ({
                 id: ch.id || '',
@@ -567,7 +590,7 @@ export class SlackClient {
     }
     async getThreadView(channelId, ts) {
         return this.withRetry(async () => {
-            const response = await this.client.subscriptions.thread.getView({
+            const response = await this.ensureAuth().subscriptions.thread.getView({
                 channel: channelId,
                 thread_ts: ts,
             });
@@ -584,7 +607,7 @@ export class SlackClient {
     }
     async markRead(channelId, ts) {
         return this.withRetry(async () => {
-            const response = await this.client.conversations.mark({
+            const response = await this.ensureAuth().conversations.mark({
                 channel: channelId,
                 ts,
             });
@@ -593,7 +616,7 @@ export class SlackClient {
     }
     async getActivityFeed(options) {
         return this.withRetry(async () => {
-            const response = await this.client.apiCall('activity.feed', {
+            const response = await this.ensureAuth().apiCall('activity.feed', {
                 types: options?.types || 'thread_reply,message_reaction,at_user,at_channel,keyword',
                 mode: options?.mode || 'chrono_reads_and_unreads',
                 limit: options?.limit || 20,
@@ -613,7 +636,7 @@ export class SlackClient {
     }
     async getSavedItems(cursor) {
         return this.withRetry(async () => {
-            const response = await this.client.apiCall('saved.list', {
+            const response = await this.ensureAuth().apiCall('saved.list', {
                 cursor,
                 limit: 50,
             });
@@ -651,7 +674,7 @@ export class SlackClient {
     }
     async getChannelSections() {
         return this.withRetry(async () => {
-            const response = await this.client.apiCall('users.channelSections.list');
+            const response = await this.ensureAuth().apiCall('users.channelSections.list');
             this.checkResponse(response);
             const sections = response.channel_sections || [];
             return sections.map((section) => ({
@@ -663,9 +686,19 @@ export class SlackClient {
             }));
         });
     }
+    async openConversation(users) {
+        return this.withRetry(async () => {
+            const response = await this.ensureAuth().conversations.open({ users });
+            this.checkResponse(response);
+            return {
+                channel_id: response.channel.id,
+                already_open: response.already_open || false,
+            };
+        });
+    }
     async getDrafts(cursor) {
         return this.withRetry(async () => {
-            const response = await this.client.apiCall('drafts.list', {
+            const response = await this.ensureAuth().apiCall('drafts.list', {
                 cursor,
             });
             this.checkResponse(response);
@@ -682,5 +715,509 @@ export class SlackClient {
             };
         });
     }
+    async rtmConnect() {
+        return this.withRetry(async () => {
+            const response = await this.ensureAuth().apiCall('rtm.connect');
+            this.checkResponse(response);
+            return {
+                url: response.url,
+                cookie: this.cookie,
+                self: { id: response.self.id },
+                team: { id: response.team.id },
+            };
+        });
+    }
+    async pinMessage(channel, ts) {
+        return this.withRetry(async () => {
+            const response = await this.ensureAuth().pins.add({ channel, timestamp: ts });
+            this.checkResponse(response);
+        });
+    }
+    async unpinMessage(channel, ts) {
+        return this.withRetry(async () => {
+            const response = await this.ensureAuth().pins.remove({ channel, timestamp: ts });
+            this.checkResponse(response);
+        });
+    }
+    async listPins(channel) {
+        return this.withRetry(async () => {
+            const response = await this.ensureAuth().pins.list({ channel });
+            this.checkResponse(response);
+            return (response.items || [])
+                .filter((item) => item.message)
+                .map((item) => ({
+                channel,
+                message: {
+                    ts: item.message.ts || '',
+                    text: item.message.text || '',
+                    user: item.message.user,
+                    username: item.message.username,
+                    type: item.message.type || 'message',
+                    thread_ts: item.message.thread_ts,
+                    reply_count: item.message.reply_count,
+                },
+                date_created: item.created || 0,
+                created_by: item.created_by || '',
+            }));
+        });
+    }
+    async addBookmark(channel, title, link, options) {
+        return this.withRetry(async () => {
+            const response = await this.ensureAuth().apiCall('bookmarks.add', {
+                channel_id: channel,
+                title,
+                link,
+                type: options?.type || 'link',
+                emoji: options?.emoji,
+            });
+            this.checkResponse(response);
+            const b = response.bookmark;
+            return {
+                id: b.id || '',
+                channel_id: b.channel_id || channel,
+                title: b.title || title,
+                link: b.link || link,
+                emoji: b.emoji,
+                icon_url: b.icon_url,
+                type: b.type || 'link',
+                date_created: b.date_created || 0,
+                date_updated: b.date_updated || 0,
+                created_by: b.created_by || '',
+            };
+        });
+    }
+    async editBookmark(channel, bookmarkId, options) {
+        return this.withRetry(async () => {
+            const response = await this.ensureAuth().apiCall('bookmarks.edit', {
+                channel_id: channel,
+                bookmark_id: bookmarkId,
+                ...options,
+            });
+            this.checkResponse(response);
+            const b = response.bookmark;
+            return {
+                id: b.id || bookmarkId,
+                channel_id: b.channel_id || channel,
+                title: b.title || '',
+                link: b.link || '',
+                emoji: b.emoji,
+                icon_url: b.icon_url,
+                type: b.type || 'link',
+                date_created: b.date_created || 0,
+                date_updated: b.date_updated || 0,
+                created_by: b.created_by || '',
+            };
+        });
+    }
+    async removeBookmark(channel, bookmarkId) {
+        return this.withRetry(async () => {
+            const response = await this.ensureAuth().apiCall('bookmarks.remove', {
+                channel_id: channel,
+                bookmark_id: bookmarkId,
+            });
+            this.checkResponse(response);
+        });
+    }
+    async listBookmarks(channel) {
+        return this.withRetry(async () => {
+            const response = await this.ensureAuth().apiCall('bookmarks.list', { channel_id: channel });
+            this.checkResponse(response);
+            return (response.bookmarks || []).map((b) => ({
+                id: b.id || '',
+                channel_id: b.channel_id || channel,
+                title: b.title || '',
+                link: b.link || '',
+                emoji: b.emoji,
+                icon_url: b.icon_url,
+                type: b.type || 'link',
+                date_created: b.date_created || 0,
+                date_updated: b.date_updated || 0,
+                created_by: b.created_by || '',
+            }));
+        });
+    }
+    async scheduleMessage(channel, text, postAt, threadTs) {
+        return this.withRetry(async () => {
+            const response = await this.ensureAuth().chat.scheduleMessage({
+                channel,
+                text,
+                post_at: postAt,
+                thread_ts: threadTs,
+            });
+            this.checkResponse(response);
+            return {
+                id: response.scheduled_message_id || '',
+                channel_id: channel,
+                post_at: postAt,
+                date_created: Math.floor(Date.now() / 1000),
+                text,
+            };
+        });
+    }
+    async listScheduledMessages(channel) {
+        return this.withRetry(async () => {
+            const allMessages = [];
+            let cursor;
+            do {
+                const response = await this.ensureAuth().chat.scheduledMessages.list({
+                    ...(channel ? { channel } : {}),
+                    ...(cursor ? { cursor } : {}),
+                });
+                this.checkResponse(response);
+                const messages = (response.scheduled_messages || []).map((msg) => ({
+                    id: msg.id || msg.scheduled_message_id || '',
+                    channel_id: msg.channel_id || '',
+                    post_at: msg.post_at || 0,
+                    date_created: msg.date_created || 0,
+                    text: msg.text || '',
+                }));
+                allMessages.push(...messages);
+                cursor = response.response_metadata?.next_cursor;
+            } while (cursor);
+            return allMessages;
+        });
+    }
+    async deleteScheduledMessage(channel, scheduledMessageId) {
+        return this.withRetry(async () => {
+            const response = await this.ensureAuth().chat.deleteScheduledMessage({
+                channel,
+                scheduled_message_id: scheduledMessageId,
+            });
+            this.checkResponse(response);
+        });
+    }
+    async createChannel(name, isPrivate) {
+        return this.withRetry(async () => {
+            const response = await this.ensureAuth().conversations.create({ name, is_private: isPrivate });
+            this.checkResponse(response);
+            const ch = response.channel;
+            return {
+                id: ch.id,
+                name: ch.name,
+                is_private: ch.is_private || false,
+                is_archived: ch.is_archived || false,
+                created: ch.created || 0,
+                creator: ch.creator || '',
+                topic: ch.topic
+                    ? {
+                        value: ch.topic.value || '',
+                        creator: ch.topic.creator || '',
+                        last_set: ch.topic.last_set || 0,
+                    }
+                    : undefined,
+                purpose: ch.purpose
+                    ? {
+                        value: ch.purpose.value || '',
+                        creator: ch.purpose.creator || '',
+                        last_set: ch.purpose.last_set || 0,
+                    }
+                    : undefined,
+            };
+        });
+    }
+    async archiveChannel(channel) {
+        return this.withRetry(async () => {
+            const response = await this.ensureAuth().conversations.archive({ channel });
+            this.checkResponse(response);
+        });
+    }
+    async setChannelTopic(channel, topic) {
+        return this.withRetry(async () => {
+            const response = await this.ensureAuth().conversations.setTopic({ channel, topic });
+            this.checkResponse(response);
+            return { topic: response.topic || topic };
+        });
+    }
+    async setChannelPurpose(channel, purpose) {
+        return this.withRetry(async () => {
+            const response = await this.ensureAuth().conversations.setPurpose({ channel, purpose });
+            this.checkResponse(response);
+            return { purpose: response.purpose || purpose };
+        });
+    }
+    async inviteToChannel(channel, users) {
+        return this.withRetry(async () => {
+            const response = await this.ensureAuth().conversations.invite({ channel, users });
+            this.checkResponse(response);
+            const ch = response.channel;
+            return {
+                id: ch.id,
+                name: ch.name,
+                is_private: ch.is_private || false,
+                is_archived: ch.is_archived || false,
+                created: ch.created || 0,
+                creator: ch.creator || '',
+            };
+        });
+    }
+    async joinChannel(channel) {
+        return this.withRetry(async () => {
+            const response = await this.ensureAuth().conversations.join({ channel });
+            this.checkResponse(response);
+            const ch = response.channel;
+            return {
+                id: ch.id,
+                name: ch.name,
+                is_private: ch.is_private || false,
+                is_archived: ch.is_archived || false,
+                created: ch.created || 0,
+                creator: ch.creator || '',
+            };
+        });
+    }
+    async leaveChannel(channel) {
+        return this.withRetry(async () => {
+            const response = await this.ensureAuth().conversations.leave({ channel });
+            this.checkResponse(response);
+        });
+    }
+    async lookupUserByEmail(email) {
+        return this.withRetry(async () => {
+            const response = await this.ensureAuth().users.lookupByEmail({ email });
+            this.checkResponse(response);
+            const member = response.user;
+            return {
+                id: member.id,
+                name: member.name,
+                real_name: member.real_name || member.name || '',
+                is_admin: member.is_admin || false,
+                is_owner: member.is_owner || false,
+                is_bot: member.is_bot || false,
+                is_app_user: member.is_app_user || false,
+                profile: member.profile
+                    ? {
+                        email: member.profile.email,
+                        phone: member.profile.phone,
+                        title: member.profile.title,
+                        status_text: member.profile.status_text,
+                    }
+                    : undefined,
+            };
+        });
+    }
+    async getUserProfile(userId) {
+        return this.withRetry(async () => {
+            const response = await this.ensureAuth().users.profile.get({ user: userId });
+            this.checkResponse(response);
+            const p = response.profile || {};
+            return {
+                title: p.title,
+                phone: p.phone,
+                skype: p.skype,
+                real_name: p.real_name,
+                real_name_normalized: p.real_name_normalized,
+                display_name: p.display_name,
+                display_name_normalized: p.display_name_normalized,
+                status_text: p.status_text,
+                status_emoji: p.status_emoji,
+                status_expiration: p.status_expiration,
+                email: p.email,
+                first_name: p.first_name,
+                last_name: p.last_name,
+                image_24: p.image_24,
+                image_32: p.image_32,
+                image_48: p.image_48,
+                image_72: p.image_72,
+                image_192: p.image_192,
+                image_512: p.image_512,
+            };
+        });
+    }
+    async setUserProfile(profile) {
+        return this.withRetry(async () => {
+            const response = await this.ensureAuth().users.profile.set({ profile: profile });
+            this.checkResponse(response);
+            const p = response.profile || {};
+            return {
+                title: p.title,
+                phone: p.phone,
+                skype: p.skype,
+                real_name: p.real_name,
+                real_name_normalized: p.real_name_normalized,
+                display_name: p.display_name,
+                display_name_normalized: p.display_name_normalized,
+                status_text: p.status_text,
+                status_emoji: p.status_emoji,
+                status_expiration: p.status_expiration,
+                email: p.email,
+                first_name: p.first_name,
+                last_name: p.last_name,
+                image_24: p.image_24,
+                image_32: p.image_32,
+                image_48: p.image_48,
+                image_72: p.image_72,
+                image_192: p.image_192,
+                image_512: p.image_512,
+            };
+        });
+    }
+    async postEphemeral(channel, user, text) {
+        return this.withRetry(async () => {
+            const response = await this.ensureAuth().chat.postEphemeral({ channel, user, text });
+            this.checkResponse(response);
+            return response.message_ts || '';
+        });
+    }
+    async getPermalink(channel, ts) {
+        return this.withRetry(async () => {
+            const response = await this.ensureAuth().chat.getPermalink({ channel, message_ts: ts });
+            this.checkResponse(response);
+            return response.permalink || '';
+        });
+    }
+    async addReminder(text, time, options) {
+        return this.withRetry(async () => {
+            const response = await this.ensureAuth().reminders.add({ text, time: time, user: options?.user });
+            this.checkResponse(response);
+            const r = response.reminder || {};
+            return {
+                id: r.id || '',
+                creator: r.creator || '',
+                text: r.text || text,
+                user: r.user || '',
+                recurring: r.recurring || false,
+                time: r.time || time,
+                complete_ts: r.complete_ts || 0,
+            };
+        });
+    }
+    async listReminders() {
+        return this.withRetry(async () => {
+            const response = await this.ensureAuth().reminders.list({});
+            this.checkResponse(response);
+            return (response.reminders || []).map((r) => ({
+                id: r.id || '',
+                creator: r.creator || '',
+                text: r.text || '',
+                user: r.user || '',
+                recurring: r.recurring || false,
+                time: r.time || 0,
+                complete_ts: r.complete_ts || 0,
+            }));
+        });
+    }
+    async completeReminder(reminderId) {
+        return this.withRetry(async () => {
+            const response = await this.ensureAuth().reminders.complete({ reminder: reminderId });
+            this.checkResponse(response);
+        });
+    }
+    async deleteReminder(reminderId) {
+        return this.withRetry(async () => {
+            const response = await this.ensureAuth().reminders.delete({ reminder: reminderId });
+            this.checkResponse(response);
+        });
+    }
+    async deleteFile(fileId) {
+        return this.withRetry(async () => {
+            const response = await this.ensureAuth().files.delete({ file: fileId });
+            this.checkResponse(response);
+        });
+    }
+    async listEmoji() {
+        return this.withRetry(async () => {
+            const response = await this.ensureAuth().emoji.list({});
+            this.checkResponse(response);
+            return (response.emoji || {});
+        });
+    }
+    mapUsergroup(ug) {
+        return {
+            id: ug.id || '',
+            team_id: ug.team_id || '',
+            name: ug.name || '',
+            handle: ug.handle || '',
+            description: ug.description || '',
+            is_external: ug.is_external ?? false,
+            is_usergroup: ug.is_usergroup ?? true,
+            date_create: ug.date_create ?? 0,
+            date_update: ug.date_update ?? 0,
+            date_delete: ug.date_delete ?? 0,
+            auto_type: ug.auto_type ?? null,
+            created_by: ug.created_by || '',
+            updated_by: ug.updated_by || '',
+            deleted_by: ug.deleted_by ?? null,
+            prefs: {
+                channels: ug.prefs?.channels || [],
+                groups: ug.prefs?.groups || [],
+            },
+            users: ug.users || [],
+            user_count: ug.user_count ?? 0,
+        };
+    }
+    async listUsergroups(options) {
+        return this.withRetry(async () => {
+            const response = await this.ensureAuth().apiCall('usergroups.list', {
+                include_disabled: options?.includeDisabled,
+                include_users: options?.includeUsers,
+                include_count: options?.includeCount,
+            });
+            this.checkResponse(response);
+            return (response.usergroups || []).map((ug) => this.mapUsergroup(ug));
+        });
+    }
+    async createUsergroup(name, options) {
+        return this.withRetry(async () => {
+            const response = await this.ensureAuth().apiCall('usergroups.create', {
+                name,
+                handle: options?.handle,
+                description: options?.description,
+                channels: options?.channels?.join(','),
+            });
+            this.checkResponse(response);
+            return this.mapUsergroup(response.usergroup);
+        });
+    }
+    async updateUsergroup(usergroupId, options) {
+        return this.withRetry(async () => {
+            const response = await this.ensureAuth().apiCall('usergroups.update', {
+                usergroup: usergroupId,
+                name: options.name,
+                handle: options.handle,
+                description: options.description,
+                channels: options.channels?.join(','),
+            });
+            this.checkResponse(response);
+            return this.mapUsergroup(response.usergroup);
+        });
+    }
+    async disableUsergroup(usergroupId) {
+        return this.withRetry(async () => {
+            const response = await this.ensureAuth().apiCall('usergroups.disable', {
+                usergroup: usergroupId,
+            });
+            this.checkResponse(response);
+            return this.mapUsergroup(response.usergroup);
+        });
+    }
+    async enableUsergroup(usergroupId) {
+        return this.withRetry(async () => {
+            const response = await this.ensureAuth().apiCall('usergroups.enable', {
+                usergroup: usergroupId,
+            });
+            this.checkResponse(response);
+            return this.mapUsergroup(response.usergroup);
+        });
+    }
+    async listUsergroupMembers(usergroupId, options) {
+        return this.withRetry(async () => {
+            const response = await this.ensureAuth().apiCall('usergroups.users.list', {
+                usergroup: usergroupId,
+                include_disabled: options?.includeDisabled,
+            });
+            this.checkResponse(response);
+            return response.users || [];
+        });
+    }
+    async updateUsergroupMembers(usergroupId, users) {
+        return this.withRetry(async () => {
+            const response = await this.ensureAuth().apiCall('usergroups.users.update', {
+                usergroup: usergroupId,
+                users: users.join(','),
+            });
+            this.checkResponse(response);
+            return this.mapUsergroup(response.usergroup);
+        });
+    }
 }
 //# sourceMappingURL=client.js.map