@rnsk/toolkits 0.0.7 → 0.0.9

package/dist/toolkits/slack/tools/admin-conversations.js

@@ -0,0 +1,246 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { slackApi, toSlackError, requireToken } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+export const slackAdminSearchConversations = tool({
+    description: 'Search public or private channels across an Enterprise Grid org by name and type. Enterprise Grid only.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        query: z.string().optional().describe('Channel name to search for'),
+        teamIds: z.string().optional().describe('Comma-separated workspace IDs to search'),
+        connectedTeamIds: z.string().optional().describe('Comma-separated external org team IDs to search'),
+        searchChannelTypes: z
+            .enum(['public', 'private', 'private_exclude', 'im', 'mpim', 'ext_shared', 'org_shared', 'archived', 'exclude_archived', 'multi_workspace', 'org_wide', 'external_shared'])
+            .optional()
+            .describe('Channel type to include or exclude'),
+        sort: z.enum(['relevant', 'name', 'member_count', 'created']).optional().describe('Sort method'),
+        sortDir: z.enum(['asc', 'desc']).optional().describe('Sort direction'),
+        limit: z.number().min(1).max(20).optional().describe('Max results (1-20, default 10)'),
+        cursor: z.string().optional().describe('Pagination cursor from a previous response'),
+        totalCountOnly: z.boolean().optional().describe('Return only the total count, no channel data'),
+    }),
+    execute: async ({ slackToken, teamIds, connectedTeamIds, searchChannelTypes, sortDir, totalCountOnly, ...rest }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.conversations.search', {
+                ...rest,
+                team_ids: teamIds,
+                connected_team_ids: connectedTeamIds,
+                search_channel_types: searchChannelTypes,
+                sort_dir: sortDir,
+                total_count_only: totalCountOnly,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to search conversations');
+        }
+    },
+});
+export const slackAdminCreateConversation = tool({
+    description: 'Create a channel via the Admin API (Enterprise Grid). Set orgWide=true for an org-wide channel, otherwise teamId is required. Confirm with the user first.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        name: z.string().describe('Channel name: unique, lowercase, max 80 chars, no spaces'),
+        isPrivate: z.boolean().describe('True for private, false for public'),
+        teamId: z.string().optional().describe('Workspace ID (required unless orgWide is true)'),
+        orgWide: z.boolean().optional().describe('Make the channel available org-wide'),
+        description: z.string().optional().describe('Channel description'),
+    }),
+    execute: async ({ slackToken, name, isPrivate, teamId, orgWide, description }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.conversations.create', {
+                name,
+                is_private: isPrivate,
+                team_id: teamId,
+                org_wide: orgWide,
+                description,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to create conversation');
+        }
+    },
+});
+export const slackDeleteChannel = tool({
+    description: 'Permanently delete a public or private channel and all its messages and files (Enterprise Grid admin). Irreversible — confirm with the user first.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        channelId: z.string().describe('Channel ID to delete'),
+    }),
+    execute: async ({ slackToken, channelId }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.conversations.delete', { channel_id: channelId });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to delete channel');
+        }
+    },
+});
+export const slackConvertChannelToPrivate = tool({
+    description: 'Convert a public channel to private via the Admin API. Enterprise Grid only, irreversible via API. Confirm with the user first.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        channelId: z.string().describe('Public channel ID to convert'),
+        name: z.string().optional().describe('Only used when converting an MPIM'),
+    }),
+    execute: async ({ slackToken, channelId, name }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.conversations.convertToPrivate', {
+                channel_id: channelId,
+                name,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to convert channel to private');
+        }
+    },
+});
+export const slackInviteUserToChannelAdmin = tool({
+    description: 'Invite users to a channel via the Admin API (Enterprise Grid). The caller must be a channel member. For regular workspaces use slackInviteUsersToChannel.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        channelId: z.string().describe('Channel ID to invite users to'),
+        userIds: z.string().describe("Comma-separated user IDs, e.g. 'U123,U456' (max 1000)"),
+    }),
+    execute: async ({ slackToken, channelId, userIds }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.conversations.invite', {
+                channel_id: channelId,
+                user_ids: userIds,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to invite users to channel');
+        }
+    },
+});
+export const slackGetConversationPrefs = tool({
+    description: 'Get posting/thread/mention/huddle preferences for a channel. Enterprise Grid oriented.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        channelId: z.string().describe('Channel ID to get preferences for'),
+    }),
+    execute: async ({ slackToken, channelId }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.conversations.getConversationPrefs', {
+                channel_id: channelId,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to get conversation preferences');
+        }
+    },
+});
+export const slackSetConversationPrefs = tool({
+    description: 'Set posting permissions for a channel (who can post/thread, @channel/@here, huddles). Pass prefs as a JSON string, e.g. {"who_can_post":"type:admin"}. Enterprise Grid oriented.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        channelId: z.string().describe('Channel ID to set preferences for'),
+        prefs: z.record(z.any()).describe('Preferences object (who_can_post, can_thread, can_huddle, enable_at_channel, enable_at_here)'),
+    }),
+    execute: async ({ slackToken, channelId, prefs }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.conversations.setConversationPrefs', {
+                channel_id: channelId,
+                prefs: JSON.stringify(prefs),
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to set conversation preferences');
+        }
+    },
+});
+export const slackGetChannelWorkspaces = tool({
+    description: 'List workspaces a channel is connected to within an Enterprise Grid org. Paginate with cursor.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        channelId: z.string().describe('Channel ID to inspect'),
+        limit: z.number().min(1).max(1000).optional().describe('Items per page (max 1000)'),
+        cursor: z.string().optional().describe('Pagination cursor from a previous response'),
+    }),
+    execute: async ({ slackToken, channelId, limit, cursor }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.conversations.getTeams', {
+                channel_id: channelId,
+                limit,
+                cursor,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to get channel workspaces');
+        }
+    },
+});
+export const slackSetChannelWorkspaces = tool({
+    description: 'Set which Enterprise Grid workspaces connect to a channel (share a channel with workspaces, or convert to an org channel). Confirm with the user first.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        channelId: z.string().describe('Channel ID to share'),
+        teamId: z.string().optional().describe('Owning workspace; omit for cross-workspace shared channels'),
+        targetTeamIds: z.string().optional().describe('Comma-separated workspace IDs to share with'),
+        orgChannel: z.boolean().optional().describe('Convert the channel to an org channel'),
+    }),
+    execute: async ({ slackToken, channelId, teamId, targetTeamIds, orgChannel }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.conversations.setTeams', {
+                channel_id: channelId,
+                team_id: teamId,
+                target_team_ids: targetTeamIds,
+                org_channel: orgChannel,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to set channel workspaces');
+        }
+    },
+});
+export const slackListChannelIdpGroups = tool({
+    description: 'List IDP groups allowlisted on a private channel (only members of these groups may access it). Enterprise Grid with IDP groups enabled.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        channelId: z.string().describe('Private channel ID'),
+        teamId: z.string().optional().describe('Workspace ID for workspace-specific channels'),
+    }),
+    execute: async ({ slackToken, channelId, teamId }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.conversations.restrictAccess.listGroups', {
+                channel_id: channelId,
+                team_id: teamId,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to list channel IDP groups');
+        }
+    },
+});
+//# sourceMappingURL=admin-conversations.js.map

package/dist/toolkits/slack/tools/admin-invites.d.ts

@@ -0,0 +1,19 @@
+export declare const slackListApprovedInvites: import("ai").Tool<{
+    teamId?: string | undefined;
+    limit?: number | undefined;
+    cursor?: string | undefined;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackListDeniedInvites: import("ai").Tool<{
+    teamId?: string | undefined;
+    limit?: number | undefined;
+    cursor?: string | undefined;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackListPendingInvites: import("ai").Tool<{
+    teamId?: string | undefined;
+    limit?: number | undefined;
+    cursor?: string | undefined;
+    slackToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=admin-invites.d.ts.map

package/dist/toolkits/slack/tools/admin-invites.js

@@ -0,0 +1,75 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { slackApi, toSlackError, requireToken } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+export const slackListApprovedInvites = tool({
+    description: 'List approved workspace invite requests with approver details. Enterprise Grid with admin.invites:read. Paginate with cursor.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        teamId: z.string().optional().describe('Workspace ID filter (omit for all org workspaces)'),
+        limit: z.number().min(1).max(1000).optional().describe('Invites per page (max 1000, default 100)'),
+        cursor: z.string().optional().describe('Pagination cursor from a previous response'),
+    }),
+    execute: async ({ slackToken, teamId, ...rest }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.inviteRequests.approved.list', {
+                ...rest,
+                team_id: teamId,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to list approved invites');
+        }
+    },
+});
+export const slackListDeniedInvites = tool({
+    description: 'List denied workspace invite requests with who denied them and when. Enterprise Grid with admin.invites:read. Paginate with cursor.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        teamId: z.string().optional().describe('Workspace ID (required for Enterprise Grid orgs)'),
+        limit: z.number().min(1).max(1000).optional().describe('Invites per page (max 1000)'),
+        cursor: z.string().optional().describe('Pagination cursor from a previous response'),
+    }),
+    execute: async ({ slackToken, teamId, ...rest }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.inviteRequests.denied.list', {
+                ...rest,
+                team_id: teamId,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to list denied invites');
+        }
+    },
+});
+export const slackListPendingInvites = tool({
+    description: 'List pending workspace invite requests (invited but not yet joined). Requires admin.invites:read. Paginate with cursor.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        teamId: z.string().optional().describe('Workspace ID filter (omit for all accessible workspaces)'),
+        limit: z.number().min(1).max(1000).optional().describe('Invites per page (max 1000)'),
+        cursor: z.string().optional().describe('Pagination cursor from a previous response'),
+    }),
+    execute: async ({ slackToken, teamId, ...rest }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.inviteRequests.list', {
+                ...rest,
+                team_id: teamId,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to list pending invites');
+        }
+    },
+});
+//# sourceMappingURL=admin-invites.js.map

package/dist/toolkits/slack/tools/admin-users.d.ts

@@ -0,0 +1,52 @@
+export declare const slackAddEnterpriseUserToWorkspace: import("ai").Tool<{
+    teamId: string;
+    userId: string;
+    slackToken?: string | undefined;
+    channelIds?: string | undefined;
+    isRestricted?: boolean | undefined;
+    isUltraRestricted?: boolean | undefined;
+}, any>;
+export declare const slackInviteUserToWorkspace: import("ai").Tool<{
+    teamId: string;
+    email: string;
+    channelIds: string;
+    slackToken?: string | undefined;
+    isRestricted?: boolean | undefined;
+    isUltraRestricted?: boolean | undefined;
+    realName?: string | undefined;
+    customMessage?: string | undefined;
+    resend?: boolean | undefined;
+    guestExpirationTs?: string | undefined;
+    emailPasswordPolicyEnabled?: boolean | undefined;
+}, any>;
+export declare const slackRemoveUserFromWorkspace: import("ai").Tool<{
+    teamId: string;
+    userId: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackSetAdminUser: import("ai").Tool<{
+    teamId: string;
+    userId: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackSetWorkspaceOwner: import("ai").Tool<{
+    teamId: string;
+    userId: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackResetUserSessions: import("ai").Tool<{
+    userId: string;
+    slackToken?: string | undefined;
+    webOnly?: boolean | undefined;
+    mobileOnly?: boolean | undefined;
+}, any>;
+export declare const slackListWorkspaceUsers: import("ai").Tool<{
+    teamId?: string | undefined;
+    limit?: number | undefined;
+    cursor?: string | undefined;
+    slackToken?: string | undefined;
+    isActive?: boolean | undefined;
+    onlyGuests?: boolean | undefined;
+    includeDeactivatedUserWorkspaces?: boolean | undefined;
+}, any>;
+//# sourceMappingURL=admin-users.d.ts.map

package/dist/toolkits/slack/tools/admin-users.js

@@ -0,0 +1,182 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { slackApi, toSlackError, requireToken } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+export const slackAddEnterpriseUserToWorkspace = tool({
+    description: 'Add an existing Enterprise Grid user to a workspace, with optional channels and guest restrictions. Enterprise Grid only.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        teamId: z.string().describe('Workspace ID to add the user to'),
+        userId: z.string().describe('Enterprise user ID to add'),
+        channelIds: z.string().optional().describe('Comma-separated channel IDs for the user to join'),
+        isRestricted: z.boolean().optional().describe('Add as a multi-channel guest'),
+        isUltraRestricted: z.boolean().optional().describe('Add as a single-channel guest'),
+    }),
+    execute: async ({ slackToken, teamId, userId, channelIds, isRestricted, isUltraRestricted }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.users.assign', {
+                team_id: teamId,
+                user_id: userId,
+                channel_ids: channelIds,
+                is_restricted: isRestricted,
+                is_ultra_restricted: isUltraRestricted,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to add user to workspace');
+        }
+    },
+});
+export const slackInviteUserToWorkspace = tool({
+    description: 'Invite a person to a workspace by email with channels, a welcome message, and guest options (Enterprise Grid admin). Use resend=true to re-process a pending invite.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        teamId: z.string().describe('Workspace ID to invite to'),
+        email: z.string().describe('Email address of the invitee'),
+        channelIds: z.string().describe('Comma-separated channel IDs (IDs only, names fail)'),
+        realName: z.string().optional().describe('Full name of the invitee'),
+        customMessage: z.string().optional().describe('Welcome note in the invite email'),
+        resend: z.boolean().optional().describe('Resend a pending invite'),
+        isRestricted: z.boolean().optional().describe('Invite as a multi-channel guest'),
+        isUltraRestricted: z.boolean().optional().describe('Invite as a single-channel guest'),
+        guestExpirationTs: z.string().optional().describe("Guest expiry as 'XXXXXXXXXX.XXXXXX'"),
+        emailPasswordPolicyEnabled: z.boolean().optional().describe('Allow email+password sign-in (Enterprise Grid)'),
+    }),
+    execute: async ({ slackToken, teamId, email, channelIds, realName, customMessage, resend, isRestricted, isUltraRestricted, guestExpirationTs, emailPasswordPolicyEnabled }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.users.invite', {
+                team_id: teamId,
+                email,
+                channel_ids: channelIds,
+                real_name: realName,
+                custom_message: customMessage,
+                resend,
+                is_restricted: isRestricted,
+                is_ultra_restricted: isUltraRestricted,
+                guest_expiration_ts: guestExpirationTs,
+                email_password_policy_enabled: emailPasswordPolicyEnabled,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to invite user to workspace');
+        }
+    },
+});
+export const slackRemoveUserFromWorkspace = tool({
+    description: 'Remove a user from a workspace, revoking access. Confirm with the user first.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        teamId: z.string().describe('Workspace ID to remove the user from'),
+        userId: z.string().describe('User ID to remove'),
+    }),
+    execute: async ({ slackToken, teamId, userId }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.users.remove', { team_id: teamId, user_id: userId });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to remove user from workspace');
+        }
+    },
+});
+export const slackSetAdminUser = tool({
+    description: 'Promote an existing workspace member (guest, user, or owner) to admin. Confirm with the user first.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        teamId: z.string().describe('Workspace ID'),
+        userId: z.string().describe('Member ID to promote'),
+    }),
+    execute: async ({ slackToken, teamId, userId }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.users.setAdmin', { team_id: teamId, user_id: userId });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to set admin user');
+        }
+    },
+});
+export const slackSetWorkspaceOwner = tool({
+    description: 'Promote a member, guest, or admin to workspace owner. Enterprise Grid only. Confirm with the user first.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        teamId: z.string().describe('Workspace ID'),
+        userId: z.string().describe('Member ID to promote'),
+    }),
+    execute: async ({ slackToken, teamId, userId }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.users.setOwner', { team_id: teamId, user_id: userId });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to set workspace owner');
+        }
+    },
+});
+export const slackResetUserSessions = tool({
+    description: 'Wipe all sessions on all devices for a user, forcing re-authentication. Use for security concerns. Confirm with the user first.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        userId: z.string().describe('User ID to wipe sessions for'),
+        webOnly: z.boolean().optional().describe('Expire web sessions only'),
+        mobileOnly: z.boolean().optional().describe('Expire mobile sessions only'),
+    }),
+    execute: async ({ slackToken, userId, webOnly, mobileOnly }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.users.session.reset', {
+                user_id: userId,
+                web_only: webOnly,
+                mobile_only: mobileOnly,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to reset user sessions');
+        }
+    },
+});
+export const slackListWorkspaceUsers = tool({
+    description: 'List admin users of a workspace (admin.users.list), paginated. Omit teamId with org-level tokens for org-wide results.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        teamId: z.string().optional().describe('Workspace ID to list users for'),
+        limit: z.number().min(1).optional().describe('Users per page (default 100)'),
+        cursor: z.string().optional().describe('Pagination cursor from a previous response'),
+        isActive: z.boolean().optional().describe('True for active users, false for deactivated'),
+        onlyGuests: z.boolean().optional().describe('Return guest accounts with expirations only'),
+        includeDeactivatedUserWorkspaces: z.boolean().optional().describe('Include deactivated workspaces (org-level tokens)'),
+    }),
+    execute: async ({ slackToken, teamId, isActive, onlyGuests, includeDeactivatedUserWorkspaces, ...rest }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.users.list', {
+                ...rest,
+                team_id: teamId,
+                is_active: isActive,
+                only_guests: onlyGuests,
+                include_deactivated_user_workspaces: includeDeactivatedUserWorkspaces,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to list workspace users');
+        }
+    },
+});
+//# sourceMappingURL=admin-users.js.map

package/dist/toolkits/slack/tools/audit.d.ts

@@ -0,0 +1,20 @@
+export declare const slackReadAuditLogs: import("ai").Tool<{
+    action?: string | undefined;
+    limit?: number | undefined;
+    actor?: string | undefined;
+    latest?: number | undefined;
+    cursor?: string | undefined;
+    slackToken?: string | undefined;
+    oldest?: number | undefined;
+    entity?: string | undefined;
+}, any>;
+export declare const slackGetAuditActions: import("ai").Tool<{
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackGetAuditSchemas: import("ai").Tool<{
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackGetScimConfig: import("ai").Tool<{
+    slackToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=audit.d.ts.map

package/dist/toolkits/slack/tools/audit.js

@@ -0,0 +1,81 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { slackGet, toSlackError, requireToken } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+export const slackReadAuditLogs = tool({
+    description: 'Read Enterprise Grid audit logs (logins, admin changes, app installs, channel changes) with filters and pagination. Requires an owner/admin user token with auditlogs:read.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        action: z.string().optional().describe("Comma-separated actions (max 30), e.g. 'user_login,channel_created'"),
+        actor: z.string().optional().describe('Filter to actions by this user ID'),
+        entity: z.string().optional().describe('Filter to actions affecting this entity ID'),
+        oldest: z.number().optional().describe('Oldest entry Unix timestamp (inclusive)'),
+        latest: z.number().optional().describe('Latest entry Unix timestamp (inclusive)'),
+        limit: z.number().max(9999).optional().describe('Max entries to return (max 9999)'),
+        cursor: z.string().optional().describe('Pagination cursor from a previous response'),
+    }),
+    execute: async ({ slackToken, ...rest }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackGet(slackToken, 'https://api.slack.com/audit/v1/logs', rest);
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to read audit logs');
+        }
+    },
+});
+export const slackGetAuditActions = tool({
+    description: 'List action types available in the Audit Logs API by category. Use to build action filters for slackReadAuditLogs.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+    }),
+    execute: async ({ slackToken }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackGet(slackToken, 'https://api.slack.com/audit/v1/actions');
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to get audit actions');
+        }
+    },
+});
+export const slackGetAuditSchemas = tool({
+    description: 'List object schemas returned by the Audit Logs API (workspaces, users, channels, etc.).',
+    inputSchema: z.object({
+        slackToken: tokenField,
+    }),
+    execute: async ({ slackToken }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackGet(slackToken, 'https://api.slack.com/audit/v1/schemas');
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to get audit schemas');
+        }
+    },
+});
+export const slackGetScimConfig = tool({
+    description: "Get the SCIM service provider configuration (auth schemes, filtering, sorting, bulk support). No parameters. Needs a token with admin scope; SCIM-provisioned tokens may be required.",
+    inputSchema: z.object({
+        slackToken: tokenField,
+    }),
+    execute: async ({ slackToken }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackGet(slackToken, 'https://api.slack.com/scim/v1/ServiceProviderConfig');
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to get SCIM config');
+        }
+    },
+});
+//# sourceMappingURL=audit.js.map