@rnsk/toolkits 0.0.8 → 0.0.10

package/dist/toolkits/bitbucket/tools/snippets.d.ts

@@ -0,0 +1,34 @@
+export declare const bitbucketGetSnippet: import("ai").Tool<{
+    workspace: string;
+    encodedId: string;
+    bitbucketToken?: string | undefined;
+    acceptFormat?: string | undefined;
+}, any>;
+export declare const bitbucketListSnippets: import("ai").Tool<{
+    page?: number | undefined;
+    role?: "owner" | "contributor" | "member" | undefined;
+    bitbucketToken?: string | undefined;
+    pagelen?: number | undefined;
+}, any>;
+export declare const bitbucketCreateSnippetComment: import("ai").Tool<{
+    content: string;
+    workspace: string;
+    encodedId: string;
+    parentId?: number | undefined;
+    bitbucketToken?: string | undefined;
+}, any>;
+export declare const bitbucketGetSnippetWatchStatus: import("ai").Tool<{
+    workspace: string;
+    encodedId: string;
+    bitbucketToken?: string | undefined;
+}, {
+    error: string;
+} | {
+    is_watching: boolean;
+}>;
+export declare const bitbucketDeleteSnippetWatch: import("ai").Tool<{
+    workspace: string;
+    encodedId: string;
+    bitbucketToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=snippets.d.ts.map

package/dist/toolkits/bitbucket/tools/snippets.js

@@ -0,0 +1,122 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { bbRequest, toBbError, requireToken, enc, BitbucketApiError } from './client.js';
+export const bitbucketGetSnippet = tool({
+    description: "Retrieves a specific Bitbucket snippet by its encoded ID from an existing workspace, returning its metadata and file structure.",
+    inputSchema: z.object({
+        bitbucketToken: z.string().optional().describe("Injected by system; do not provide"),
+        workspace: z.string().describe("The workspace ID (slug) or the workspace UUID surrounded by curly braces, identifying the Bitbucket workspace."),
+        encodedId: z.string().describe("The unique identifier (encoded ID) of the snippet to be retrieved."),
+        acceptFormat: z.string().optional().describe("The desired format for the response. Valid options are 'application/json', 'multipart/related', or 'multipart/form-data'. This may affect how snippet content or file data is presented."),
+    }),
+    execute: async ({ bitbucketToken, workspace, encodedId, acceptFormat }) => {
+        const missing = requireToken(bitbucketToken);
+        if (missing)
+            return missing;
+        try {
+            return await bbRequest(bitbucketToken, 'GET', `/snippets/${enc(workspace)}/${enc(encodedId)}`, { accept: acceptFormat ?? 'application/json' });
+        }
+        catch (error) {
+            return toBbError(error, "Failed to get snippet");
+        }
+    },
+});
+export const bitbucketListSnippets = tool({
+    description: "Returns all snippets accessible to the authenticated user. Use when you need to discover or list snippets, optionally filtered by role (owner, contributor, or member).",
+    inputSchema: z.object({
+        bitbucketToken: z.string().optional().describe("Injected by system; do not provide"),
+        page: z.number().int().min(1).optional().describe("Page number of the results to retrieve. Defaults to 1 if not specified."),
+        role: z.enum(["owner", "contributor", "member"]).optional().describe("Enum for snippet role filter values."),
+        pagelen: z.number().int().min(1).max(100).optional().describe("Number of results per page (1-100). Defaults to the Bitbucket API's default page length if not specified."),
+    }),
+    execute: async ({ bitbucketToken, page, role, pagelen }) => {
+        const missing = requireToken(bitbucketToken);
+        if (missing)
+            return missing;
+        try {
+            const query = {};
+            if (role !== undefined)
+                query["role"] = role;
+            if (page !== undefined)
+                query["page"] = page;
+            if (pagelen !== undefined)
+                query["pagelen"] = pagelen;
+            return await bbRequest(bitbucketToken, 'GET', `/snippets`, { query });
+        }
+        catch (error) {
+            return toBbError(error, "Failed to list snippets");
+        }
+    },
+});
+export const bitbucketCreateSnippetComment = tool({
+    description: "Posts a new top-level comment or a threaded reply to an existing comment on a specified Bitbucket snippet.",
+    inputSchema: z.object({
+        bitbucketToken: z.string().optional().describe("Injected by system; do not provide"),
+        content: z.string().describe("Raw text content of the comment; Bitbucket will render any included markup (like Markdown)."),
+        parentId: z.number().int().optional().describe("ID of an existing comment to reply to, creating a threaded comment; if omitted, a top-level comment is created."),
+        workspace: z.string().describe("Workspace ID or slug (e.g., 'my_workspace_slug' or a UUID) for the Bitbucket workspace containing the snippet."),
+        encodedId: z.string().describe("Unique, encoded ID of the Bitbucket snippet to comment on (typically part of the snippet's URL)."),
+    }),
+    execute: async ({ bitbucketToken, workspace, encodedId, content, parentId }) => {
+        const missing = requireToken(bitbucketToken);
+        if (missing)
+            return missing;
+        try {
+            const body = { content: { raw: content } };
+            if (parentId !== undefined)
+                body.parent = { id: parentId };
+            return await bbRequest(bitbucketToken, 'POST', `/snippets/${enc(workspace)}/${enc(encodedId)}/comments`, { body });
+        }
+        catch (error) {
+            return toBbError(error, "Failed to create snippet comment");
+        }
+    },
+});
+export const bitbucketGetSnippetWatchStatus = tool({
+    description: "Checks if the current user is watching a specific snippet. Use when you need to verify watch status for a snippet.",
+    inputSchema: z.object({
+        bitbucketToken: z.string().optional().describe("Injected by system; do not provide"),
+        workspace: z.string().describe("The workspace ID (slug) or the workspace UUID surrounded by curly braces, identifying the Bitbucket workspace."),
+        encodedId: z.string().describe("The unique identifier (encoded ID) of the snippet to check watch status for."),
+    }),
+    execute: async ({ bitbucketToken, workspace, encodedId }) => {
+        const missing = requireToken(bitbucketToken);
+        if (missing)
+            return missing;
+        try {
+            try {
+                await bbRequest(bitbucketToken, 'GET', `/snippets/${enc(workspace)}/${enc(encodedId)}/watch`);
+                return { is_watching: true };
+            }
+            catch (error) {
+                if (error instanceof BitbucketApiError && error.status === 404)
+                    return { is_watching: false };
+                return toBbError(error, 'Failed to get snippet watch status');
+            }
+        }
+        catch (error) {
+            return toBbError(error, "Failed to get snippet watch status");
+        }
+    },
+});
+export const bitbucketDeleteSnippetWatch = tool({
+    description: "Stops watching a specific snippet. Use when you want to unsubscribe from notifications for a snippet.",
+    inputSchema: z.object({
+        bitbucketToken: z.string().optional().describe("Injected by system; do not provide"),
+        workspace: z.string().describe("The workspace ID (slug) or the workspace UUID surrounded by curly braces, identifying the Bitbucket workspace."),
+        encodedId: z.string().describe("The unique identifier (encoded ID) of the snippet to stop watching."),
+    }),
+    execute: async ({ bitbucketToken, workspace, encodedId }) => {
+        const missing = requireToken(bitbucketToken);
+        if (missing)
+            return missing;
+        try {
+            return await bbRequest(bitbucketToken, 'DELETE', `/snippets/${enc(workspace)}/${enc(encodedId)}/watch`);
+        }
+        catch (error) {
+            return toBbError(error, "Failed to delete snippet watch");
+        }
+    },
+});
+//# sourceMappingURL=snippets.js.map

package/dist/toolkits/bitbucket/tools/users-workspaces.d.ts

@@ -0,0 +1,65 @@
+export declare const bitbucketGetCurrentUser: import("ai").Tool<{
+    bitbucketToken?: string | undefined;
+}, any>;
+export declare const bitbucketGetUser: import("ai").Tool<{
+    selectedUser: string;
+    bitbucketToken?: string | undefined;
+}, any>;
+export declare const bitbucketGetUserEmails: import("ai").Tool<{
+    bitbucketToken?: string | undefined;
+}, any>;
+export declare const bitbucketGetUserEmailDetails: import("ai").Tool<{
+    email: string;
+    bitbucketToken?: string | undefined;
+}, any>;
+export declare const bitbucketListUserSshKeys: import("ai").Tool<{
+    username: string;
+    page?: number | undefined;
+    bitbucketToken?: string | undefined;
+    pagelen?: number | undefined;
+}, any>;
+export declare const bitbucketListUserRepositoryPermissions: import("ai").Tool<{
+    page?: number | undefined;
+    bitbucketToken?: string | undefined;
+    pagelen?: number | undefined;
+}, any>;
+export declare const bitbucketListUserWorkspacePermissions: import("ai").Tool<{
+    q?: string | undefined;
+    page?: number | undefined;
+    bitbucketToken?: string | undefined;
+    pagelen?: number | undefined;
+}, any>;
+export declare const bitbucketListUserWorkspaces: import("ai").Tool<{
+    q?: string | undefined;
+    bitbucketToken?: string | undefined;
+}, any>;
+export declare const bitbucketListWorkspaceMembers: import("ai").Tool<{
+    workspace: string;
+    page?: number | undefined;
+    bitbucketToken?: string | undefined;
+    pagelen?: number | undefined;
+}, any>;
+export declare const bitbucketListWorkspaceProjects: import("ai").Tool<{
+    workspace: string;
+    sort?: string | undefined;
+    q?: string | undefined;
+    page?: number | undefined;
+    bitbucketToken?: string | undefined;
+    pagelen?: number | undefined;
+}, any>;
+export declare const bitbucketGetWorkspace: import("ai").Tool<{
+    workspace: string;
+    bitbucketToken?: string | undefined;
+}, any>;
+export declare const bitbucketListWorkspaces: import("ai").Tool<{
+    sort?: string | undefined;
+    q?: string | undefined;
+    page?: number | undefined;
+    bitbucketToken?: string | undefined;
+    pagelen?: number | undefined;
+}, any>;
+export declare const bitbucketListHookEvents: import("ai").Tool<{
+    subjectType: "repository" | "workspace";
+    bitbucketToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=users-workspaces.d.ts.map

package/dist/toolkits/bitbucket/tools/users-workspaces.js

@@ -0,0 +1,294 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { bbRequest, toBbError, requireToken, enc } from './client.js';
+export const bitbucketGetCurrentUser = tool({
+    description: "Tool to retrieve complete profile information for the currently authenticated Bitbucket user. Use when you need comprehensive user details including account_id, username, nickname, and other profile fields.",
+    inputSchema: z.object({
+        bitbucketToken: z.string().optional().describe("Injected by system; do not provide"),
+    }),
+    execute: async ({ bitbucketToken }) => {
+        const missing = requireToken(bitbucketToken);
+        if (missing)
+            return missing;
+        try {
+            return await bbRequest(bitbucketToken, 'GET', `/user`);
+        }
+        catch (error) {
+            return toBbError(error, "Failed to get current user");
+        }
+    },
+});
+export const bitbucketGetUser = tool({
+    description: "Retrieves public profile information for a specific Bitbucket user by username or UUID. Use when you need to get user details like display name, avatar, creation date, and links to related resources.",
+    inputSchema: z.object({
+        bitbucketToken: z.string().optional().describe("Injected by system; do not provide"),
+        selectedUser: z.string().describe("The username or UUID of the user to retrieve. Can be a username (e.g., 'john_doe') or a UUID enclosed in curly braces (e.g., '{4f3ecac3-c951-41d4-8a4c-95f40be978fc}')."),
+    }),
+    execute: async ({ bitbucketToken, selectedUser }) => {
+        const missing = requireToken(bitbucketToken);
+        if (missing)
+            return missing;
+        try {
+            return await bbRequest(bitbucketToken, 'GET', `/users/${enc(selectedUser)}`);
+        }
+        catch (error) {
+            return toBbError(error, "Failed to get user");
+        }
+    },
+});
+export const bitbucketGetUserEmails = tool({
+    description: "Returns all the authenticated user's email addresses, both confirmed and unconfirmed. Use when you need to retrieve all email addresses associated with the current user's account.",
+    inputSchema: z.object({
+        bitbucketToken: z.string().optional().describe("Injected by system; do not provide"),
+    }),
+    execute: async ({ bitbucketToken }) => {
+        const missing = requireToken(bitbucketToken);
+        if (missing)
+            return missing;
+        try {
+            return await bbRequest(bitbucketToken, 'GET', `/user/emails`);
+        }
+        catch (error) {
+            return toBbError(error, "Failed to get user emails");
+        }
+    },
+});
+export const bitbucketGetUserEmailDetails = tool({
+    description: "Retrieves details about a specific email address for the authenticated user. Use when you need to check if an email is primary, confirmed, or verify email ownership.",
+    inputSchema: z.object({
+        bitbucketToken: z.string().optional().describe("Injected by system; do not provide"),
+        email: z.string().describe("The email address to retrieve details for. Must be one of the authenticated user's email addresses."),
+    }),
+    execute: async ({ bitbucketToken, email }) => {
+        const missing = requireToken(bitbucketToken);
+        if (missing)
+            return missing;
+        try {
+            return await bbRequest(bitbucketToken, 'GET', `/user/emails/${enc(email)}`);
+        }
+        catch (error) {
+            return toBbError(error, "Failed to get user email details");
+        }
+    },
+});
+export const bitbucketListUserSshKeys = tool({
+    description: "Retrieves a paginated list of SSH keys for a specified Bitbucket user. Use when you need to view or audit SSH keys configured for a user account.",
+    inputSchema: z.object({
+        bitbucketToken: z.string().optional().describe("Injected by system; do not provide"),
+        page: z.number().int().min(1).optional().describe("The page number for pagination. Starts at 1."),
+        pagelen: z.number().int().min(1).max(100).optional().describe("Number of SSH keys to return per page. Default is typically 10."),
+        username: z.string().describe("The username of the Bitbucket user to retrieve SSH keys for. This is the account username (slug), not the display name or UUID."),
+    }),
+    execute: async ({ bitbucketToken, username, page, pagelen }) => {
+        const missing = requireToken(bitbucketToken);
+        if (missing)
+            return missing;
+        try {
+            const query = {};
+            if (page !== undefined)
+                query["page"] = page;
+            if (pagelen !== undefined)
+                query["pagelen"] = pagelen;
+            return await bbRequest(bitbucketToken, 'GET', `/users/${enc(username)}/ssh-keys`, { query });
+        }
+        catch (error) {
+            return toBbError(error, "Failed to list user ssh keys");
+        }
+    },
+});
+export const bitbucketListUserRepositoryPermissions = tool({
+    description: "Returns an object for each repository the caller has explicit access to, including their permission level. Use when you need to discover which repositories the authenticated user can access and their specific permissions.",
+    inputSchema: z.object({
+        bitbucketToken: z.string().optional().describe("Injected by system; do not provide"),
+        page: z.number().int().min(1).optional().describe("Page number for paginated results. Used to retrieve a specific page in a multi-page result set. Page numbers start at 1."),
+        pagelen: z.number().int().min(1).optional().describe("Number of items to return per page for pagination. Controls the size of the paginated result set. Default is typically 10 if not specified."),
+    }),
+    execute: async ({ bitbucketToken, page, pagelen }) => {
+        const missing = requireToken(bitbucketToken);
+        if (missing)
+            return missing;
+        try {
+            const query = {};
+            if (page !== undefined)
+                query["page"] = page;
+            if (pagelen !== undefined)
+                query["pagelen"] = pagelen;
+            return await bbRequest(bitbucketToken, 'GET', `/user/permissions/repositories`, { query });
+        }
+        catch (error) {
+            return toBbError(error, "Failed to list user repository permissions");
+        }
+    },
+});
+export const bitbucketListUserWorkspacePermissions = tool({
+    description: "Retrieves workspace memberships and permission levels for the authenticated user. Returns an object for each workspace the caller is a member of, along with their effective role (highest privilege level). Use when you need to determine which workspaces a user can access and their permission level in each.",
+    inputSchema: z.object({
+        bitbucketToken: z.string().optional().describe("Injected by system; do not provide"),
+        q: z.string().optional().describe("Query string to filter results by workspace slug or permission level using Bitbucket's filtering syntax. Examples: q=workspace.slug=\"workspace1\" or q=permission=\"owner\". Supported fields: workspace.slug (workspace identifier), permission (permission level). Use exact match with = operator. String values must be enclosed in double quotes."),
+        page: z.number().int().optional().describe("Page number for pagination. Use this to navigate through multiple pages of results."),
+        pagelen: z.number().int().optional().describe("Number of items per page for pagination. Controls how many workspace permission objects are returned in a single response."),
+    }),
+    execute: async ({ bitbucketToken, q, page, pagelen }) => {
+        const missing = requireToken(bitbucketToken);
+        if (missing)
+            return missing;
+        try {
+            const query = {};
+            if (q !== undefined)
+                query["q"] = q;
+            if (page !== undefined)
+                query["page"] = page;
+            if (pagelen !== undefined)
+                query["pagelen"] = pagelen;
+            return await bbRequest(bitbucketToken, 'GET', `/user/permissions/workspaces`, { query });
+        }
+        catch (error) {
+            return toBbError(error, "Failed to list user workspace permissions");
+        }
+    },
+});
+export const bitbucketListUserWorkspaces = tool({
+    description: "Tool to retrieve all workspaces accessible to the authenticated user. Use when you need to list workspaces the current user can access, optionally filtered by workspace slug or permission level.",
+    inputSchema: z.object({
+        bitbucketToken: z.string().optional().describe("Injected by system; do not provide"),
+        q: z.string().optional().describe("Query string to filter workspaces by attributes such as workspace slug or permission level. Examples: 'workspace.slug=\"my-workspace\"' or 'permission=\"owner\"'. Follow Bitbucket's filtering syntax for complex queries."),
+    }),
+    execute: async ({ bitbucketToken, q }) => {
+        const missing = requireToken(bitbucketToken);
+        if (missing)
+            return missing;
+        try {
+            const query = {};
+            if (q !== undefined)
+                query["q"] = q;
+            return await bbRequest(bitbucketToken, 'GET', `/user/permissions/workspaces`, { query });
+        }
+        catch (error) {
+            return toBbError(error, "Failed to list user workspaces");
+        }
+    },
+});
+export const bitbucketListWorkspaceMembers = tool({
+    description: "Lists all members of a specified Bitbucket workspace; the workspace must exist.",
+    inputSchema: z.object({
+        bitbucketToken: z.string().optional().describe("Injected by system; do not provide"),
+        page: z.number().int().min(1).optional().describe("Page number of the results to retrieve. Defaults to 1 if not specified."),
+        pagelen: z.number().int().min(1).max(100).optional().describe("Number of results per page (1-100). Defaults to the Bitbucket API's default page length if not specified."),
+        workspace: z.string().describe("The workspace ID (UUID) or slug from which to list members. The slug is the user-friendly, URL-safe identifier for the workspace."),
+    }),
+    execute: async ({ bitbucketToken, workspace, page, pagelen }) => {
+        const missing = requireToken(bitbucketToken);
+        if (missing)
+            return missing;
+        try {
+            const query = {};
+            if (page !== undefined)
+                query["page"] = page;
+            if (pagelen !== undefined)
+                query["pagelen"] = pagelen;
+            return await bbRequest(bitbucketToken, 'GET', `/workspaces/${enc(workspace)}/members`, { query });
+        }
+        catch (error) {
+            return toBbError(error, "Failed to list workspace members");
+        }
+    },
+});
+export const bitbucketListWorkspaceProjects = tool({
+    description: "Lists projects in a specified Bitbucket workspace. Use when you need to retrieve all projects belonging to a workspace.",
+    inputSchema: z.object({
+        bitbucketToken: z.string().optional().describe("Injected by system; do not provide"),
+        q: z.string().optional().describe("Query string to filter projects by attributes, following Bitbucket's filtering syntax. Syntax: 'field operator value'. Operators: '=' (exact match), '~' (contains substring), '!=' (not equal). String values MUST be enclosed in double quotes. Valid project fields: 'name', 'key', 'is_private'. Combine multiple conditions with AND/OR (e.g., 'name~\"api\" AND is_private=true')."),
+        page: z.number().int().optional().describe("Specifies which page of results to return. Page numbering starts at 1."),
+        sort: z.string().optional().describe("Field to sort returned projects by; prefix with a hyphen (-) for descending order. Common sortable fields: 'name', 'key', 'created_on', 'updated_on'."),
+        pagelen: z.number().int().min(1).max(100).optional().describe("Controls the number of items per page. Must be between 1 and 100."),
+        workspace: z.string().describe("The identifier of the Bitbucket workspace. This can be the workspace slug (e.g., 'my-workspace') or its UUID enclosed in curly braces (e.g., '{workspace-uuid}')."),
+    }),
+    execute: async ({ bitbucketToken, workspace, q, page, sort, pagelen }) => {
+        const missing = requireToken(bitbucketToken);
+        if (missing)
+            return missing;
+        try {
+            const query = {};
+            if (q !== undefined)
+                query["q"] = q;
+            if (page !== undefined)
+                query["page"] = page;
+            if (sort !== undefined)
+                query["sort"] = sort;
+            if (pagelen !== undefined)
+                query["pagelen"] = pagelen;
+            return await bbRequest(bitbucketToken, 'GET', `/workspaces/${enc(workspace)}/projects`, { query });
+        }
+        catch (error) {
+            return toBbError(error, "Failed to list workspace projects");
+        }
+    },
+});
+export const bitbucketGetWorkspace = tool({
+    description: "Retrieves detailed information about a specific Bitbucket workspace. Use when you need to get workspace metadata, settings, or details.",
+    inputSchema: z.object({
+        bitbucketToken: z.string().optional().describe("Injected by system; do not provide"),
+        workspace: z.string().describe("The workspace ID (slug) or workspace UUID surrounded by curly-braces. Example: 'my-workspace' or '{workspace-uuid}'."),
+    }),
+    execute: async ({ bitbucketToken, workspace }) => {
+        const missing = requireToken(bitbucketToken);
+        if (missing)
+            return missing;
+        try {
+            return await bbRequest(bitbucketToken, 'GET', `/workspaces/${enc(workspace)}`);
+        }
+        catch (error) {
+            return toBbError(error, "Failed to get workspace");
+        }
+    },
+});
+export const bitbucketListWorkspaces = tool({
+    description: "Lists Bitbucket workspaces accessible to the authenticated user, optionally filtered and sorted. Results are paginated; follow the `next` field in each response to retrieve subsequent pages until `next` is absent. When multiple workspaces are returned, verify the correct `slug` or UUID before passing to downstream tools.",
+    inputSchema: z.object({
+        bitbucketToken: z.string().optional().describe("Injected by system; do not provide"),
+        q: z.string().optional().describe("Query string to filter workspaces by attributes, following Bitbucket's filtering syntax."),
+        page: z.number().int().min(1).optional().describe("Page number of the results to retrieve. Defaults to 1 if not specified."),
+        sort: z.string().optional().describe("Field to sort returned workspaces by; prefix with a hyphen (-) for descending order."),
+        pagelen: z.number().int().min(1).max(100).optional().describe("Number of results per page (1-100). Defaults to 10 if not specified."),
+    }),
+    execute: async ({ bitbucketToken, q, page, sort, pagelen }) => {
+        const missing = requireToken(bitbucketToken);
+        if (missing)
+            return missing;
+        try {
+            const query = {};
+            if (q !== undefined)
+                query["q"] = q;
+            if (page !== undefined)
+                query["page"] = page;
+            if (sort !== undefined)
+                query["sort"] = sort;
+            if (pagelen !== undefined)
+                query["pagelen"] = pagelen;
+            return await bbRequest(bitbucketToken, 'GET', `/workspaces`, { query });
+        }
+        catch (error) {
+            return toBbError(error, "Failed to list workspaces");
+        }
+    },
+});
+export const bitbucketListHookEvents = tool({
+    description: "Retrieves a paginated list of all valid webhook events for a specified entity type (repository or workspace). Use when you need to discover available webhook event types for subscription or webhook configuration.",
+    inputSchema: z.object({
+        bitbucketToken: z.string().optional().describe("Injected by system; do not provide"),
+        subjectType: z.enum(["repository", "workspace"]).describe("The type of entity for which to retrieve available webhook events. Use 'repository' for repository-level events or 'workspace' for workspace-level events. Note: team and user webhooks are deprecated; use workspace instead."),
+    }),
+    execute: async ({ bitbucketToken, subjectType }) => {
+        const missing = requireToken(bitbucketToken);
+        if (missing)
+            return missing;
+        try {
+            return await bbRequest(bitbucketToken, 'GET', `/hook_events/${enc(subjectType)}`);
+        }
+        catch (error) {
+            return toBbError(error, "Failed to list hook events");
+        }
+    },
+});
+//# sourceMappingURL=users-workspaces.js.map

package/dist/toolkits/discord/icon.d.ts

@@ -0,0 +1,5 @@
+export declare const DISCORD_ICON: {
+    kind: "svg";
+    dataUri: string;
+};
+//# sourceMappingURL=icon.d.ts.map

package/dist/toolkits/discord/icon.js

@@ -0,0 +1,12 @@
+const SVG = `<svg width="800px" height="800px" viewBox="0 -28.5 256 256" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" preserveAspectRatio="xMidYMid">
+    <g>
+        <path d="M216.856339,16.5966031 C200.285002,8.84328665 182.566144,3.2084988 164.041564,0 C161.766523,4.11318106 159.108624,9.64549908 157.276099,14.0464379 C137.583995,11.0849896 118.072967,11.0849896 98.7430163,14.0464379 C96.9108417,9.64549908 94.1925838,4.11318106 91.8971895,0 C73.3526068,3.2084988 55.6133949,8.86399117 39.0420583,16.6376612 C5.61752293,67.146514 -3.4433191,116.400813 1.08711069,164.955721 C23.2560196,181.510915 44.7403634,191.567697 65.8621325,198.148576 C71.0772151,190.971126 75.7283628,183.341335 79.7352139,175.300261 C72.104019,172.400575 64.7949724,168.822202 57.8887866,164.667963 C59.7209612,163.310589 61.5131304,161.891452 63.2445898,160.431257 C105.36741,180.133187 151.134928,180.133187 192.754523,160.431257 C194.506336,161.891452 196.298154,163.310589 198.110326,164.667963 C191.183787,168.842556 183.854737,172.420929 176.223542,175.320965 C180.230393,183.341335 184.861538,190.991831 190.096624,198.16893 C211.238746,191.588051 232.743023,181.531619 254.911949,164.955721 C260.227747,108.668201 245.831087,59.8662432 216.856339,16.5966031 Z M85.4738752,135.09489 C72.8290281,135.09489 62.4592217,123.290155 62.4592217,108.914901 C62.4592217,94.5396472 72.607595,82.7145587 85.4738752,82.7145587 C98.3405064,82.7145587 108.709962,94.5189427 108.488529,108.914901 C108.508531,123.290155 98.3405064,135.09489 85.4738752,135.09489 Z M170.525237,135.09489 C157.88039,135.09489 147.510584,123.290155 147.510584,108.914901 C147.510584,94.5396472 157.658606,82.7145587 170.525237,82.7145587 C183.391518,82.7145587 193.761324,94.5189427 193.539891,108.914901 C193.539891,123.290155 183.391518,135.09489 170.525237,135.09489 Z" fill="#5865F2" fill-rule="nonzero">
+
+</path>
+    </g>
+</svg>`;
+export const DISCORD_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

package/dist/toolkits/discord/manifest.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("../../index.js").ToolkitManifest;
+export default _default;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/toolkits/discord/manifest.js

@@ -0,0 +1,52 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { inferToolScope } from '../../core/scope.js';
+import { DISCORD_ICON } from './icon.js';
+import { discordTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'discord',
+    displayName: 'Discord',
+    shortDescription: 'User identity, guilds, invites, apps, and entitlements.',
+    category: 'Collaboration & Communication',
+    icon: DISCORD_ICON,
+    auth: {
+        type: 'oauth2',
+        tokenField: 'discordToken',
+        provider: {
+            slug: 'discord',
+            env: { clientId: 'DISCORD_CLIENT_ID', clientSecret: 'DISCORD_CLIENT_SECRET' },
+            authorizeUrl: 'https://discord.com/oauth2/authorize',
+            tokenUrl: 'https://discord.com/api/oauth2/token',
+            scopes: [
+                'identify',
+                'email',
+                'openid',
+                'connections',
+                'guilds',
+                'guilds.members.read',
+                'applications.commands.permissions.update',
+                'role_connections.write',
+                'applications.entitlements',
+            ],
+            scopeSeparator: ' ',
+            exchangeStyle: 'basic',
+            connectDescription: 'Connect Discord to read user identity, guilds, invites, and entitlements, and to manage application command permissions and role connections.',
+            callbackPath: '/api/auth/discord/callback',
+            stateCookie: 'discord_oauth_state',
+        },
+    },
+    allowedHosts: ['discord.com', 'cdn.discord.com'],
+    tools: discordTools.map((entry) => defineTool({
+        name: entry.name,
+        description: entry.description,
+        tool: entry.tool,
+        requiredAuth: entry.requiredAuth,
+        scope: entry.scope ?? inferToolScope(entry.name),
+    })),
+    meta: {
+        since: '0.0.9',
+        homepage: 'https://discord.com',
+        docsUrl: 'https://docs.discord.com/developers/',
+        apiDocsUrl: 'https://docs.discord.com/developers/api-reference',
+    },
+});
+//# sourceMappingURL=manifest.js.map