@rnsk/toolkits 0.0.7 → 0.0.9

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/cloudflare/icon.d.ts

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

package/dist/toolkits/cloudflare/icon.js

@@ -0,0 +1,14 @@
+const SVG = `<svg width="800px" height="800px" viewBox="0 -70 256 256" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" preserveAspectRatio="xMidYMid" fill="#000000" data-darkreader-inline-fill="" style="--darkreader-inline-fill: var(--darkreader-background-000000, #000000);">
+
+<g id="SVGRepo_bgCarrier" stroke-width="0"/>
+
+<g id="SVGRepo_tracerCarrier" stroke-linecap="round" stroke-linejoin="round"/>
+
+<g id="SVGRepo_iconCarrier"> <g> <g transform="translate(0.000000, -1.000000)"> <path d="M202.3569,50.394 L197.0459,48.27 C172.0849,104.434 72.7859,70.289 66.8109,86.997 C65.8149,98.283 121.0379,89.143 160.5169,91.056 C172.5559,91.639 178.5929,100.727 173.4809,115.54 L183.5499,115.571 C195.1649,79.362 232.2329,97.841 233.7819,85.891 C231.2369,78.034 191.1809,85.891 202.3569,50.394 Z" fill="#FFFFFF" data-darkreader-inline-fill="" style="--darkreader-inline-fill: var(--darkreader-background-ffffff, #181a1b);"> </path> <path d="M176.332,109.3483 C177.925,104.0373 177.394,98.7263 174.739,95.5393 C172.083,92.3523 168.365,90.2283 163.585,89.6973 L71.17,88.6343 C70.639,88.6343 70.108,88.1033 69.577,88.1033 C69.046,87.5723 69.046,87.0413 69.577,86.5103 C70.108,85.4483 70.639,84.9163 71.701,84.9163 L164.647,83.8543 C175.801,83.3233 187.486,74.2943 191.734,63.6723 L197.046,49.8633 C197.046,49.3313 197.577,48.8003 197.046,48.2693 C191.203,21.1823 166.772,0.9993 138.091,0.9993 C111.535,0.9993 88.697,17.9953 80.73,41.8963 C75.419,38.1783 69.046,36.0533 61.61,36.5853 C48.863,37.6473 38.772,48.2693 37.178,61.0163 C36.647,64.2033 37.178,67.3903 37.71,70.5763 C16.996,71.1073 0,88.1033 0,109.3483 C0,111.4723 0,113.0663 0.531,115.1903 C0.531,116.2533 1.593,116.7843 2.125,116.7843 L172.614,116.7843 C173.676,116.7843 174.739,116.2533 174.739,115.1903 L176.332,109.3483 Z" fill="#F4811F" data-darkreader-inline-fill="" style="--darkreader-inline-fill: var(--darkreader-background-f4811f, #b75909);"> </path> <path d="M205.5436,49.8628 L202.8876,49.8628 C202.3566,49.8628 201.8256,50.3938 201.2946,50.9248 L197.5766,63.6718 C195.9836,68.9828 196.5146,74.2948 199.1706,77.4808 C201.8256,80.6678 205.5436,82.7918 210.3236,83.3238 L229.9756,84.3858 C230.5066,84.3858 231.0376,84.9168 231.5686,84.9168 C232.0996,85.4478 232.0996,85.9788 231.5686,86.5098 C231.0376,87.5728 230.5066,88.1038 229.4436,88.1038 L209.2616,89.1658 C198.1076,89.6968 186.4236,98.7258 182.1746,109.3478 L181.1116,114.1288 C180.5806,114.6598 181.1116,115.7218 182.1746,115.7218 L252.2826,115.7218 C253.3446,115.7218 253.8756,115.1908 253.8756,114.1288 C254.9376,109.8798 255.9996,105.0998 255.9996,100.3188 C255.9996,72.7008 233.1616,49.8628 205.5436,49.8628" fill="#FAAD3F" data-darkreader-inline-fill="" style="--darkreader-inline-fill: var(--darkreader-background-faad3f, #a56304);"> </path> </g> </g> </g>
+
+</svg>`;
+export const CLOUDFLARE_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

package/dist/toolkits/cloudflare/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/cloudflare/manifest.js

@@ -0,0 +1,36 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { inferToolScope } from '../../core/scope.js';
+import { CLOUDFLARE_ICON } from './icon.js';
+import { cloudflareTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'cloudflare',
+    displayName: 'Cloudflare',
+    shortDescription: 'DNS records, zones, WAF lists, firewall, tunnels, and load balancing.',
+    category: 'Developer Tools & DevOps',
+    icon: CLOUDFLARE_ICON,
+    auth: {
+        type: 'api_key',
+        tokenField: 'cloudflareApiKey',
+        provider: {
+            in: 'header',
+            name: 'Authorization',
+            prefix: 'Bearer',
+            connectDescription: 'Connect Cloudflare with an API token. Create one from My Profile > API Tokens using a template such as Edit zone DNS, with access to the zones and accounts you want to manage.',
+        },
+    },
+    allowedHosts: ['api.cloudflare.com'],
+    tools: cloudflareTools.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.8',
+        homepage: 'https://www.cloudflare.com',
+        docsUrl: 'https://developers.cloudflare.com/api/',
+        apiDocsUrl: 'https://developers.cloudflare.com/api/',
+    },
+});
+//# sourceMappingURL=manifest.js.map

package/dist/toolkits/cloudflare/tools/client.d.ts

@@ -0,0 +1,19 @@
+export declare class CloudflareApiError extends Error {
+    status: number;
+    details: unknown;
+    constructor(message: string, status: number, details: unknown);
+}
+export declare function cfRequest(cloudflareApiKey: string, method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE', path: string, options?: {
+    query?: Record<string, string | number | boolean | undefined>;
+    body?: unknown;
+}): Promise<any>;
+export declare function toCfError(error: unknown, label: string): {
+    error: string;
+    details: any;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+};
+//# sourceMappingURL=client.d.ts.map

package/dist/toolkits/cloudflare/tools/client.js

@@ -0,0 +1,57 @@
+// @ts-nocheck
+const BASE_URL = 'https://api.cloudflare.com/client/v4';
+export class CloudflareApiError extends Error {
+    status;
+    details;
+    constructor(message, status, details) {
+        super(message);
+        this.status = status;
+        this.details = details;
+    }
+}
+function authHeaders(cloudflareApiKey) {
+    return {
+        Authorization: `Bearer ${cloudflareApiKey}`,
+        'Content-Type': 'application/json',
+    };
+}
+function appendQuery(url, query) {
+    if (!query)
+        return;
+    for (const [key, value] of Object.entries(query)) {
+        if (value === undefined)
+            continue;
+        url.searchParams.set(key, String(value));
+    }
+}
+export async function cfRequest(cloudflareApiKey, method, path, options) {
+    const url = new URL(`${BASE_URL}${path}`);
+    appendQuery(url, options?.query);
+    const response = await fetch(url.toString(), {
+        method,
+        headers: authHeaders(cloudflareApiKey),
+        body: options?.body !== undefined ? JSON.stringify(options.body) : undefined,
+    });
+    const text = await response.text();
+    let data = {};
+    try {
+        data = text ? JSON.parse(text) : {};
+    }
+    catch {
+        data = { raw: text };
+    }
+    if (!response.ok || data?.success === false) {
+        throw new CloudflareApiError('Cloudflare API request failed', response.status, data?.errors ?? data);
+    }
+    return data;
+}
+export function toCfError(error, label) {
+    if (error?.details !== undefined) {
+        return { error: label, details: error.details };
+    }
+    return {
+        error: label.replace('Failed', 'Error').replace('failed', 'error'),
+        message: error instanceof Error ? error.message : 'Unknown error',
+    };
+}
+//# sourceMappingURL=client.js.map