@rnsk/toolkits 0.0.8 → 0.0.10

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

@@ -0,0 +1,285 @@
+// @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 slackGetTeamInfo = tool({
+    description: 'Get metadata for the current workspace, or a specified accessible team. Omit both filters for the current team.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        team: z.string().optional().describe('Team ID to look up'),
+        domain: z.string().optional().describe('Workspace domain (only when team is omitted, same enterprise)'),
+    }),
+    execute: async ({ slackToken, team, domain }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'team.info', { team, domain });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to get team info');
+        }
+    },
+});
+export const slackGetTeamProfile = tool({
+    description: 'Get workspace profile field definitions (custom fields and sections), optionally filtered by visibility.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        teamId: z.string().optional().describe('Workspace ID (org-level tokens only)'),
+        visibility: z.enum(['all', 'visible', 'hidden']).optional().describe('Which profile fields to include'),
+    }),
+    execute: async ({ slackToken, teamId, visibility }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'team.profile.get', { team_id: teamId, visibility });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to get team profile');
+        }
+    },
+});
+export const slackListAuthTeams = tool({
+    description: 'List workspaces an org-wide app is approved for. Paginate with cursor.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        limit: z.number().min(1).max(1000).optional().describe('Items per page (max 1000, default 100)'),
+        cursor: z.string().optional().describe('Pagination cursor from a previous response'),
+        includeIcon: z.boolean().optional().describe('Include workspace avatar URIs'),
+    }),
+    execute: async ({ slackToken, includeIcon, ...rest }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'auth.teams.list', { ...rest, include_icon: includeIcon });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to list authorized teams');
+        }
+    },
+});
+export const slackListAvailableWorkspaces = tool({
+    description: 'List workspaces where both the connection and a target user have access. Match a workspace name to a team_id here, then pass team_id to user tools. Meaningful for org-level installs.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        user: z.string().describe('User ID whose shared workspace memberships to find'),
+    }),
+    execute: async ({ slackToken, user }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            const data = await slackApi(slackToken, 'auth.teams.list', { limit: 1000 });
+            const teams = data?.teams ?? [];
+            return {
+                ok: true,
+                available_workspaces: teams.map((t) => ({ id: t.id, name: t.name, icon: t.icon })),
+                total_count: teams.length,
+            };
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to list available workspaces');
+        }
+    },
+});
+export const slackCreateEnterpriseTeam = tool({
+    description: 'Create a team (workspace) in an Enterprise Grid org. Confirm with the user first.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        teamName: z.string().describe('Display name for the team'),
+        teamDomain: z.string().describe('Team domain (part of the team URL)'),
+        teamDescription: z.string().optional().describe('Team purpose'),
+        teamDiscoverability: z.enum(['open', 'closed', 'invite_only', 'unlisted']).optional().describe('Discoverability'),
+    }),
+    execute: async ({ slackToken, teamName, teamDomain, teamDescription, teamDiscoverability }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.teams.create', {
+                team_name: teamName,
+                team_domain: teamDomain,
+                team_description: teamDescription,
+                team_discoverability: teamDiscoverability,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to create enterprise team');
+        }
+    },
+});
+export const slackListEnterpriseTeams = tool({
+    description: 'List teams in an Enterprise Grid org with IDs, names, and domains. Paginate with cursor. Enterprise Grid only.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        limit: z.number().min(1).max(100).optional().describe('Teams per page (max 100)'),
+        cursor: z.string().optional().describe('Pagination cursor from a previous response'),
+    }),
+    execute: async ({ slackToken, limit, cursor }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.teams.list', { limit, cursor });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to list enterprise teams');
+        }
+    },
+});
+export const slackListWorkspaceAdmins = tool({
+    description: 'List admin user IDs for a workspace. Enterprise Grid with admin.teams:read. Paginate with cursor.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        teamId: z.string().describe('Workspace ID'),
+        limit: z.number().min(1).max(1000).optional().describe('Admins per page (max 1000)'),
+        cursor: z.string().optional().describe('Pagination cursor from a previous response'),
+    }),
+    execute: async ({ slackToken, teamId, limit, cursor }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.teams.admins.list', {
+                team_id: teamId,
+                limit,
+                cursor,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to list workspace admins');
+        }
+    },
+});
+export const slackListWorkspaceOwners = tool({
+    description: 'List owner user IDs for a workspace. Requires admin.teams:read. Paginate with cursor.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        teamId: z.string().describe('Workspace ID'),
+        limit: z.number().min(1).max(1000).optional().describe('Owners per page (max 1000)'),
+        cursor: z.string().optional().describe('Pagination cursor from a previous response'),
+    }),
+    execute: async ({ slackToken, teamId, limit, cursor }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.teams.owners.list', {
+                team_id: teamId,
+                limit,
+                cursor,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to list workspace owners');
+        }
+    },
+});
+export const slackGetWorkspaceSettings = tool({
+    description: 'Get detailed settings for a workspace (Enterprise Grid admin audit).',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        teamId: z.string().describe('Workspace ID (T-prefixed)'),
+    }),
+    execute: async ({ slackToken, teamId }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.teams.settings.info', { team_id: teamId });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to get workspace settings');
+        }
+    },
+});
+export const slackSetWorkspaceName = tool({
+    description: 'Set the display name of a workspace (Enterprise Grid). Confirm with the user first.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        teamId: z.string().describe('Workspace ID'),
+        name: z.string().describe('New workspace name'),
+    }),
+    execute: async ({ slackToken, teamId, name }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.teams.settings.setName', { team_id: teamId, name });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to set workspace name');
+        }
+    },
+});
+export const slackSetWorkspaceDescription = tool({
+    description: 'Set the description of a workspace. Confirm with the user first.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        teamId: z.string().describe('Workspace ID'),
+        description: z.string().describe('New workspace description'),
+    }),
+    execute: async ({ slackToken, teamId, description }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.teams.settings.setDescription', {
+                team_id: teamId,
+                description,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to set workspace description');
+        }
+    },
+});
+export const slackSetWorkspaceIcon = tool({
+    description: 'Set the workspace icon from a publicly reachable image URL (GIF/PNG/JPG/HEIC, ideally 512x512).',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        teamId: z.string().describe('Workspace ID'),
+        imageUrl: z.string().describe('Public image URL for the icon'),
+    }),
+    execute: async ({ slackToken, teamId, imageUrl }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.teams.settings.setIcon', {
+                team_id: teamId,
+                image_url: imageUrl,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to set workspace icon');
+        }
+    },
+});
+export const slackSetWorkspaceDefaultChannels = tool({
+    description: 'Set the default channels new members auto-join. Pass an array or comma-separated string of channel IDs.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        teamId: z.string().describe('Workspace ID'),
+        channelIds: z.union([z.array(z.string()), z.string()]).describe('Channel IDs to set as defaults'),
+    }),
+    execute: async ({ slackToken, teamId, channelIds }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            const ids = Array.isArray(channelIds) ? channelIds.join(',') : channelIds;
+            return await slackApi(slackToken, 'admin.teams.settings.setDefaultChannels', {
+                team_id: teamId,
+                channel_ids: ids,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to set default channels');
+        }
+    },
+});
+//# sourceMappingURL=teams.js.map

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

@@ -0,0 +1,56 @@
+export declare const slackCreateUserGroup: import("ai").Tool<{
+    name: string;
+    description?: string | undefined;
+    teamId?: string | undefined;
+    handle?: string | undefined;
+    channels?: string | undefined;
+    slackToken?: string | undefined;
+    additionalChannels?: string | undefined;
+    includeCount?: boolean | undefined;
+    enableSection?: boolean | undefined;
+}, any>;
+export declare const slackUpdateUserGroup: import("ai").Tool<{
+    usergroup: string;
+    description?: string | undefined;
+    teamId?: string | undefined;
+    name?: string | undefined;
+    handle?: string | undefined;
+    channels?: string | undefined;
+    slackToken?: string | undefined;
+    additionalChannels?: string | undefined;
+    includeCount?: boolean | undefined;
+    enableSection?: boolean | undefined;
+}, any>;
+export declare const slackUpdateUserGroupMembers: import("ai").Tool<{
+    users: string;
+    usergroup: string;
+    teamId?: string | undefined;
+    slackToken?: string | undefined;
+    includeCount?: boolean | undefined;
+}, any>;
+export declare const slackListUserGroups: import("ai").Tool<{
+    teamId?: string | undefined;
+    slackToken?: string | undefined;
+    includeCount?: boolean | undefined;
+    includeUsers?: boolean | undefined;
+    includeDisabled?: boolean | undefined;
+}, any>;
+export declare const slackListUserGroupMembers: import("ai").Tool<{
+    usergroup: string;
+    teamId?: string | undefined;
+    slackToken?: string | undefined;
+    includeDisabled?: boolean | undefined;
+}, any>;
+export declare const slackEnableUserGroup: import("ai").Tool<{
+    usergroup: string;
+    teamId?: string | undefined;
+    slackToken?: string | undefined;
+    includeCount?: boolean | undefined;
+}, any>;
+export declare const slackDisableUserGroup: import("ai").Tool<{
+    usergroup: string;
+    teamId?: string | undefined;
+    slackToken?: string | undefined;
+    includeCount?: boolean | undefined;
+}, any>;
+//# sourceMappingURL=usergroups.d.ts.map

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

@@ -0,0 +1,194 @@
+// @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 slackCreateUserGroup = tool({
+    description: 'Create a User Group (subteam) with a unique name, @handle, description, and default channels.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        name: z.string().describe('Unique display name, e.g. Customer Support'),
+        handle: z.string().optional().describe('Mention handle, e.g. support-team (max 21 chars, lowercase)'),
+        description: z.string().optional().describe('Group purpose'),
+        channels: z.string().optional().describe('Comma-separated default channel IDs'),
+        additionalChannels: z.string().optional().describe('Comma-separated extra channel IDs members may join'),
+        includeCount: z.boolean().optional().describe('Include member count in the response'),
+        enableSection: z.boolean().optional().describe('Show the group as a sidebar section for members'),
+        teamId: z.string().optional().describe('Workspace ID (org-level tokens only)'),
+    }),
+    execute: async ({ slackToken, additionalChannels, includeCount, enableSection, teamId, ...rest }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'usergroups.create', {
+                ...rest,
+                additional_channels: additionalChannels,
+                include_count: includeCount,
+                enable_section: enableSection,
+                team_id: teamId,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to create user group');
+        }
+    },
+});
+export const slackUpdateUserGroup = tool({
+    description: 'Update a User Group name, handle, description, or default channels by its ID.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        usergroup: z.string().describe('User Group ID, e.g. S0615G0KT'),
+        name: z.string().optional().describe('New unique display name'),
+        handle: z.string().optional().describe('New unique @handle'),
+        description: z.string().optional().describe('New purpose text'),
+        channels: z.string().optional().describe('Comma-separated default channel IDs'),
+        additionalChannels: z.string().optional().describe('Comma-separated extra channel IDs'),
+        includeCount: z.boolean().optional().describe('Include member count in the response'),
+        enableSection: z.boolean().optional().describe('Show the group as a sidebar section'),
+        teamId: z.string().optional().describe('Workspace ID (org-level tokens only)'),
+    }),
+    execute: async ({ slackToken, usergroup, additionalChannels, includeCount, enableSection, teamId, ...rest }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'usergroups.update', {
+                usergroup,
+                ...rest,
+                additional_channels: additionalChannels,
+                include_count: includeCount,
+                enable_section: enableSection,
+                team_id: teamId,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to update user group');
+        }
+    },
+});
+export const slackUpdateUserGroupMembers = tool({
+    description: 'Replace ALL members of a User Group with a new comma-separated user ID list. This overwrites existing membership — confirm with the user first.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        usergroup: z.string().describe('User Group ID, e.g. S012AB34CD'),
+        users: z.string().describe("Complete new member list, e.g. 'U012AB34CD,W567EF89GH'"),
+        includeCount: z.boolean().optional().describe('Include updated counts in the response'),
+        teamId: z.string().optional().describe('Workspace ID (org-level tokens only)'),
+    }),
+    execute: async ({ slackToken, usergroup, users, includeCount, teamId }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'usergroups.users.update', {
+                usergroup,
+                users,
+                include_count: includeCount,
+                team_id: teamId,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to update user group members');
+        }
+    },
+});
+export const slackListUserGroups = tool({
+    description: 'List workspace User Groups, optionally with member IDs, counts, and disabled groups.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        includeUsers: z.boolean().optional().describe('Include member user IDs per group'),
+        includeCount: z.boolean().optional().describe('Include member counts'),
+        includeDisabled: z.boolean().optional().describe('Include disabled/archived groups'),
+        teamId: z.string().optional().describe('Workspace ID (org-level tokens only)'),
+    }),
+    execute: async ({ slackToken, includeUsers, includeCount, includeDisabled, teamId }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'usergroups.list', {
+                include_users: includeUsers,
+                include_count: includeCount,
+                include_disabled: includeDisabled,
+                team_id: teamId,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to list user groups');
+        }
+    },
+});
+export const slackListUserGroupMembers = tool({
+    description: 'List user IDs in a User Group, optionally including disabled groups.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        usergroup: z.string().describe('User Group ID, e.g. S0604QSJC'),
+        includeDisabled: z.boolean().optional().describe('Include users from disabled groups'),
+        teamId: z.string().optional().describe('Workspace ID (org-level tokens only)'),
+    }),
+    execute: async ({ slackToken, usergroup, includeDisabled, teamId }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'usergroups.users.list', {
+                usergroup,
+                include_disabled: includeDisabled,
+                team_id: teamId,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to list user group members');
+        }
+    },
+});
+export const slackEnableUserGroup = tool({
+    description: 'Re-enable a disabled User Group for mentions and permissions. Status-only change.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        usergroup: z.string().describe('User Group ID to enable, e.g. S0604QSJC'),
+        includeCount: z.boolean().optional().describe('Include member count in the response'),
+        teamId: z.string().optional().describe('Workspace ID (org-level tokens only)'),
+    }),
+    execute: async ({ slackToken, usergroup, includeCount, teamId }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'usergroups.enable', {
+                usergroup,
+                include_count: includeCount,
+                team_id: teamId,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to enable user group');
+        }
+    },
+});
+export const slackDisableUserGroup = tool({
+    description: 'Disable (archive) an enabled User Group by ID. The group is not deleted and can be re-enabled.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        usergroup: z.string().describe('User Group ID to disable'),
+        includeCount: z.boolean().optional().describe('Include member count in the response'),
+        teamId: z.string().optional().describe('Workspace ID (org-level tokens only)'),
+    }),
+    execute: async ({ slackToken, usergroup, includeCount, teamId }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'usergroups.disable', {
+                usergroup,
+                include_count: includeCount,
+                team_id: teamId,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to disable user group');
+        }
+    },
+});
+//# sourceMappingURL=usergroups.js.map

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

@@ -0,0 +1,87 @@
+export declare const slackListUsers: import("ai").Tool<{
+    teamId?: string | undefined;
+    limit?: number | undefined;
+    cursor?: string | undefined;
+    slackToken?: string | undefined;
+    includeLocale?: boolean | undefined;
+}, any>;
+export declare const slackFindUsers: import("ai").Tool<{
+    limit: number;
+    includeRestricted: boolean;
+    teamId?: string | undefined;
+    email?: string | undefined;
+    searchQuery?: string | undefined;
+    slackToken?: string | undefined;
+    exactMatch?: boolean | undefined;
+    includeLocale?: boolean | undefined;
+    includeBots?: boolean | undefined;
+    includeDeleted?: boolean | undefined;
+}, any>;
+export declare const slackFindUserByEmail: import("ai").Tool<{
+    email: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackGetUserInfo: import("ai").Tool<{
+    user: string;
+    slackToken?: string | undefined;
+    includeLocale?: boolean | undefined;
+}, any>;
+export declare const slackGetUserProfile: import("ai").Tool<{
+    user?: string | undefined;
+    slackToken?: string | undefined;
+    includeLabels?: boolean | undefined;
+}, any>;
+export declare const slackSetUserProfile: import("ai").Tool<{
+    value?: string | undefined;
+    user?: string | undefined;
+    name?: string | undefined;
+    profile?: string | undefined;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackGetUserPresence: import("ai").Tool<{
+    user?: string | undefined;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackSetUserPresence: import("ai").Tool<{
+    presence: "auto" | "away";
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackEndDnd: import("ai").Tool<{
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackEndSnooze: import("ai").Tool<{
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackSetDndDuration: import("ai").Tool<{
+    numMinutes: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackGetDndStatus: import("ai").Tool<{
+    teamId?: string | undefined;
+    user?: string | undefined;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackGetTeamDndStatus: import("ai").Tool<{
+    users: string;
+    teamId?: string | undefined;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackDeleteUserPhoto: import("ai").Tool<{
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackSetUserPhoto: import("ai").Tool<{
+    imageUrl: string;
+    slackToken?: string | undefined;
+    cropX?: number | undefined;
+    cropY?: number | undefined;
+    cropW?: number | undefined;
+}, any>;
+export declare const slackGetUserIdentity: import("ai").Tool<{
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackGetBotInfo: import("ai").Tool<{
+    teamId?: string | undefined;
+    slackToken?: string | undefined;
+    bot?: string | undefined;
+}, any>;
+//# sourceMappingURL=users.d.ts.map