@rnsk/toolkits 0.0.7 → 0.0.8

package/dist/toolkits/cloudflare/tools/list-pools.d.ts

@@ -0,0 +1,8 @@
+export declare const cloudflareListPools: import("ai").Tool<{
+    accountId: string;
+    perPage?: number | undefined;
+    page?: number | undefined;
+    cloudflareApiKey?: string | undefined;
+    monitor?: string | undefined;
+}, any>;
+//# sourceMappingURL=list-pools.d.ts.map

package/dist/toolkits/cloudflare/tools/list-pools.js

@@ -0,0 +1,28 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { cfRequest, toCfError } from './client.js';
+export const cloudflareListPools = tool({
+    description: 'List load balancer pools in an account to discover pool IDs and origins. Optionally filter by health-check monitor ID. Paginate with page/perPage.',
+    inputSchema: z.object({
+        cloudflareApiKey: z.string().optional().describe('Injected by system; do not provide'),
+        accountId: z.string().describe('Account identifier to list pools for'),
+        monitor: z.string().optional().describe('Filter pools by monitor ID'),
+        page: z.number().min(1).optional().describe('Page number, starting from 1'),
+        perPage: z.number().min(1).max(50).optional().describe('Pools per page (1-50)'),
+    }),
+    execute: async ({ cloudflareApiKey, accountId, perPage, ...filters }) => {
+        try {
+            if (!cloudflareApiKey) {
+                return { error: 'Cloudflare API key is required. Connect Cloudflare first.' };
+            }
+            return await cfRequest(cloudflareApiKey, 'GET', `/accounts/${accountId}/load_balancers/pools`, {
+                query: { ...filters, per_page: perPage },
+            });
+        }
+        catch (error) {
+            return toCfError(error, 'Failed to list pools');
+        }
+    },
+});
+//# sourceMappingURL=list-pools.js.map

package/dist/toolkits/cloudflare/tools/list-tunnels.d.ts

@@ -0,0 +1,9 @@
+export declare const cloudflareListTunnels: import("ai").Tool<{
+    accountId: string;
+    perPage?: number | undefined;
+    page?: number | undefined;
+    name?: string | undefined;
+    cloudflareApiKey?: string | undefined;
+    isDeleted?: boolean | undefined;
+}, any>;
+//# sourceMappingURL=list-tunnels.d.ts.map

package/dist/toolkits/cloudflare/tools/list-tunnels.js

@@ -0,0 +1,29 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { cfRequest, toCfError } from './client.js';
+export const cloudflareListTunnels = tool({
+    description: 'List Cloudflare Tunnel (cloudflared) tunnels in an account to discover tunnel IDs, names, and statuses. Use before tunnel operations like routing or debugging.',
+    inputSchema: z.object({
+        cloudflareApiKey: z.string().optional().describe('Injected by system; do not provide'),
+        accountId: z.string().describe('Account identifier to list tunnels for'),
+        name: z.string().optional().describe('Filter tunnels by name'),
+        isDeleted: z.boolean().optional().describe('True to include deleted tunnels'),
+        page: z.number().min(1).optional().describe('Page number, starting from 1'),
+        perPage: z.number().min(1).optional().describe('Tunnels per page'),
+    }),
+    execute: async ({ cloudflareApiKey, accountId, isDeleted, perPage, ...filters }) => {
+        try {
+            if (!cloudflareApiKey) {
+                return { error: 'Cloudflare API key is required. Connect Cloudflare first.' };
+            }
+            return await cfRequest(cloudflareApiKey, 'GET', `/accounts/${accountId}/cfd_tunnel`, {
+                query: { ...filters, per_page: perPage, is_deleted: isDeleted },
+            });
+        }
+        catch (error) {
+            return toCfError(error, 'Failed to list tunnels');
+        }
+    },
+});
+//# sourceMappingURL=list-tunnels.js.map

package/dist/toolkits/cloudflare/tools/list-waf-lists.d.ts

@@ -0,0 +1,5 @@
+export declare const cloudflareListWafLists: import("ai").Tool<{
+    accountId: string;
+    cloudflareApiKey?: string | undefined;
+}, any>;
+//# sourceMappingURL=list-waf-lists.d.ts.map

package/dist/toolkits/cloudflare/tools/list-waf-lists.js

@@ -0,0 +1,23 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { cfRequest, toCfError } from './client.js';
+export const cloudflareListWafLists = tool({
+    description: 'List WAF custom lists for an account (metadata only, no items). Iterate with page/perPage until result_info.total_pages is reached to retrieve all lists.',
+    inputSchema: z.object({
+        cloudflareApiKey: z.string().optional().describe('Injected by system; do not provide'),
+        accountId: z.string().describe('Account identifier owning the lists'),
+    }),
+    execute: async ({ cloudflareApiKey, accountId }) => {
+        try {
+            if (!cloudflareApiKey) {
+                return { error: 'Cloudflare API key is required. Connect Cloudflare first.' };
+            }
+            return await cfRequest(cloudflareApiKey, 'GET', `/accounts/${accountId}/rules/lists`);
+        }
+        catch (error) {
+            return toCfError(error, 'Failed to list WAF lists');
+        }
+    },
+});
+//# sourceMappingURL=list-waf-lists.js.map

package/dist/toolkits/cloudflare/tools/list-zones.d.ts

@@ -0,0 +1,13 @@
+export declare const cloudflareListZones: import("ai").Tool<{
+    status?: "active" | "pending" | "initializing" | "moved" | undefined;
+    perPage?: number | undefined;
+    page?: number | undefined;
+    direction?: "asc" | "desc" | undefined;
+    name?: string | undefined;
+    order?: "status" | "name" | "account.id" | "account.name" | "plan.id" | undefined;
+    match?: "all" | "any" | undefined;
+    cloudflareApiKey?: string | undefined;
+    accountId?: string | undefined;
+    accountName?: string | undefined;
+}, any>;
+//# sourceMappingURL=list-zones.d.ts.map

package/dist/toolkits/cloudflare/tools/list-zones.js

@@ -0,0 +1,38 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { cfRequest, toCfError } from './client.js';
+export const cloudflareListZones = tool({
+    description: 'List, search, and filter zones in the account. Paginate with page/perPage and check result_info.total_pages for all pages. Extract zone_id from results before calling zone-scoped tools. Only zones delegated to Cloudflare nameservers appear.',
+    inputSchema: z.object({
+        cloudflareApiKey: z.string().optional().describe('Injected by system; do not provide'),
+        name: z.string().optional().describe('Filter by domain name'),
+        status: z.enum(['initializing', 'pending', 'active', 'moved']).optional().describe('Filter by zone status'),
+        match: z.enum(['all', 'any']).optional().describe('Match all filters or any filter'),
+        order: z.enum(['name', 'status', 'account.id', 'account.name', 'plan.id']).optional().describe('Field to order by'),
+        direction: z.enum(['asc', 'desc']).optional().describe('Sort direction'),
+        accountId: z.string().optional().describe('Filter by account ID'),
+        accountName: z.string().optional().describe('Filter by account name'),
+        page: z.number().min(1).optional().describe('Page number, starting from 1'),
+        perPage: z.number().min(5).max(50).optional().describe('Zones per page (5-50)'),
+    }),
+    execute: async ({ cloudflareApiKey, accountId, accountName, perPage, ...filters }) => {
+        try {
+            if (!cloudflareApiKey) {
+                return { error: 'Cloudflare API key is required. Connect Cloudflare first.' };
+            }
+            return await cfRequest(cloudflareApiKey, 'GET', '/zones', {
+                query: {
+                    ...filters,
+                    per_page: perPage,
+                    'account.id': accountId,
+                    'account.name': accountName,
+                },
+            });
+        }
+        catch (error) {
+            return toCfError(error, 'Failed to list zones');
+        }
+    },
+});
+//# sourceMappingURL=list-zones.js.map

package/dist/toolkits/cloudflare/tools/update-dns-record.d.ts

@@ -0,0 +1,13 @@
+export declare const cloudflareUpdateDnsRecord: import("ai").Tool<{
+    zoneId: string;
+    recordId: string;
+    type?: "A" | "AAAA" | "CNAME" | "MX" | "TXT" | "SRV" | "LOC" | "CERT" | "DNSKEY" | "DS" | "NS" | "PTR" | "SSHFP" | "TLSA" | "URI" | "SPF" | undefined;
+    priority?: number | undefined;
+    data?: Record<string, any> | undefined;
+    content?: string | undefined;
+    name?: string | undefined;
+    cloudflareApiKey?: string | undefined;
+    ttl?: number | undefined;
+    proxied?: boolean | undefined;
+}, any>;
+//# sourceMappingURL=update-dns-record.d.ts.map

package/dist/toolkits/cloudflare/tools/update-dns-record.js

@@ -0,0 +1,39 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { cfRequest, toCfError } from './client.js';
+export const cloudflareUpdateDnsRecord = tool({
+    description: 'Update an existing DNS record. Only provided fields are modified. Confirm zone and record IDs first via cloudflareListZones and cloudflareListDnsRecords. Changes to records used by active tunnels take effect immediately.',
+    inputSchema: z.object({
+        cloudflareApiKey: z.string().optional().describe('Injected by system; do not provide'),
+        zoneId: z.string().describe('Zone identifier of the record'),
+        recordId: z.string().describe('DNS record identifier to update'),
+        type: z
+            .enum([
+            'A', 'AAAA', 'CNAME', 'CERT', 'DNSKEY', 'DS', 'LOC', 'MX', 'NS', 'PTR',
+            'SPF', 'SRV', 'SSHFP', 'TLSA', 'TXT', 'URI',
+        ])
+            .optional()
+            .describe('DNS record type'),
+        name: z.string().optional().describe('DNS record name'),
+        content: z.string().optional().describe('DNS record content'),
+        ttl: z.number().min(1).optional().describe('TTL in seconds; 1 for automatic'),
+        proxied: z.boolean().optional().describe('Route through Cloudflare proxy'),
+        priority: z.number().min(0).optional().describe('Priority for MX, SRV, and URI records'),
+        data: z.record(z.any()).optional().describe('Extra data for LOC, SRV, and CAA records'),
+    }),
+    execute: async ({ cloudflareApiKey, zoneId, recordId, ...patch }) => {
+        try {
+            if (!cloudflareApiKey) {
+                return { error: 'Cloudflare API key is required. Connect Cloudflare first.' };
+            }
+            return await cfRequest(cloudflareApiKey, 'PATCH', `/zones/${zoneId}/dns_records/${recordId}`, {
+                body: patch,
+            });
+        }
+        catch (error) {
+            return toCfError(error, 'Failed to update DNS record');
+        }
+    },
+});
+//# sourceMappingURL=update-dns-record.js.map

package/dist/toolkits/cloudflare/tools/update-list.d.ts

@@ -0,0 +1,7 @@
+export declare const cloudflareUpdateList: import("ai").Tool<{
+    description: string;
+    accountId: string;
+    listId: string;
+    cloudflareApiKey?: string | undefined;
+}, any>;
+//# sourceMappingURL=update-list.d.ts.map

package/dist/toolkits/cloudflare/tools/update-list.js

@@ -0,0 +1,27 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { cfRequest, toCfError } from './client.js';
+export const cloudflareUpdateList = tool({
+    description: 'Update the description of a WAF list. Only the description can be changed — list items cannot be updated with this tool.',
+    inputSchema: z.object({
+        cloudflareApiKey: z.string().optional().describe('Injected by system; do not provide'),
+        accountId: z.string().describe('Account identifier owning the list'),
+        listId: z.string().describe('WAF list identifier to update'),
+        description: z.string().max(500).describe('New description for the list (max 500 chars)'),
+    }),
+    execute: async ({ cloudflareApiKey, accountId, listId, description }) => {
+        try {
+            if (!cloudflareApiKey) {
+                return { error: 'Cloudflare API key is required. Connect Cloudflare first.' };
+            }
+            return await cfRequest(cloudflareApiKey, 'PUT', `/accounts/${accountId}/rules/lists/${listId}`, {
+                body: { description },
+            });
+        }
+        catch (error) {
+            return toCfError(error, 'Failed to update WAF list');
+        }
+    },
+});
+//# sourceMappingURL=update-list.js.map

package/dist/toolkits/cloudflare/tools/update-tunnel-configuration.d.ts

@@ -0,0 +1,7 @@
+export declare const cloudflareUpdateTunnelConfiguration: import("ai").Tool<{
+    config: Record<string, any>;
+    accountId: string;
+    tunnelId: string;
+    cloudflareApiKey?: string | undefined;
+}, any>;
+//# sourceMappingURL=update-tunnel-configuration.d.ts.map

package/dist/toolkits/cloudflare/tools/update-tunnel-configuration.js

@@ -0,0 +1,28 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { cfRequest, toCfError } from './client.js';
+export const cloudflareUpdateTunnelConfiguration = tool({
+    description: 'Replace the remotely-managed configuration (ingress rules and routing) of a Cloudflare Tunnel. This REPLACES the entire config — include all existing rules you want to keep plus a catch-all (service http_status:404) last. Incorrect config can break routing; confirm with the user first.',
+    inputSchema: z.object({
+        cloudflareApiKey: z.string().optional().describe('Injected by system; do not provide'),
+        accountId: z.string().describe('Account identifier where the tunnel resides'),
+        tunnelId: z.string().describe('Tunnel UUID to configure'),
+        config: z.record(z.any()).describe('Full tunnel config object with an ingress array mapping hostnames to origin services'),
+    }),
+    execute: async ({ cloudflareApiKey, accountId, tunnelId, config }) => {
+        try {
+            if (!cloudflareApiKey) {
+                return { error: 'Cloudflare API key is required. Connect Cloudflare first.' };
+            }
+            if (!Array.isArray(config?.ingress) || config.ingress.length === 0) {
+                return { error: 'Config must include a non-empty ingress array of hostname-to-service rules.' };
+            }
+            return await cfRequest(cloudflareApiKey, 'PUT', `/accounts/${accountId}/cfd_tunnel/${tunnelId}/configurations`, { body: { config } });
+        }
+        catch (error) {
+            return toCfError(error, 'Failed to update tunnel configuration');
+        }
+    },
+});
+//# sourceMappingURL=update-tunnel-configuration.js.map

package/dist/toolkits/cloudflare/tools/update-zone.d.ts

@@ -0,0 +1,8 @@
+export declare const cloudflareUpdateZone: import("ai").Tool<{
+    zoneId: string;
+    type?: "partial" | "full" | "secondary" | undefined;
+    cloudflareApiKey?: string | undefined;
+    paused?: boolean | undefined;
+    vanityNameServers?: string[] | undefined;
+}, any>;
+//# sourceMappingURL=update-zone.d.ts.map

package/dist/toolkits/cloudflare/tools/update-zone.js

@@ -0,0 +1,32 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { cfRequest, toCfError } from './client.js';
+export const cloudflareUpdateZone = tool({
+    description: 'Update one property of an existing zone (pause/unpause, type, or vanity nameservers). Changes apply immediately — confirm the zone ID and change with the user first. Exactly one of paused, type, or vanityNameServers must be provided per call.',
+    inputSchema: z.object({
+        cloudflareApiKey: z.string().optional().describe('Injected by system; do not provide'),
+        zoneId: z.string().describe('Zone identifier to update'),
+        paused: z.boolean().optional().describe('True to pause the zone, false to unpause'),
+        type: z.enum(['full', 'partial', 'secondary']).optional().describe('Zone setup type'),
+        vanityNameServers: z.array(z.string()).optional().describe('Custom vanity nameservers'),
+    }),
+    execute: async ({ cloudflareApiKey, zoneId, paused, type, vanityNameServers }) => {
+        try {
+            if (!cloudflareApiKey) {
+                return { error: 'Cloudflare API key is required. Connect Cloudflare first.' };
+            }
+            const provided = [paused, type, vanityNameServers].filter((v) => v !== undefined);
+            if (provided.length !== 1) {
+                return { error: 'Provide exactly one of paused, type, or vanityNameServers per call.' };
+            }
+            return await cfRequest(cloudflareApiKey, 'PATCH', `/zones/${zoneId}`, {
+                body: { paused, type, vanity_name_servers: vanityNameServers },
+            });
+        }
+        catch (error) {
+            return toCfError(error, 'Failed to update zone');
+        }
+    },
+});
+//# sourceMappingURL=update-zone.js.map

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

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

package/dist/toolkits/figma/icon.js

@@ -0,0 +1,6 @@
+const SVG = `<svg id="Layer_1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 200 300" width="1667" height="2500"><style>.st0{fill:#0acf83}.st1{fill:#a259ff}.st2{fill:#f24e1e}.st3{fill:#ff7262}.st4{fill:#1abcfe}</style><title>Figma.logo</title><desc>Created using Figma</desc><path id="path0_fill" class="st0" d="M50 300c27.6 0 50-22.4 50-50v-50H50c-27.6 0-50 22.4-50 50s22.4 50 50 50z"/><path id="path1_fill" class="st1" d="M0 150c0-27.6 22.4-50 50-50h50v100H50c-27.6 0-50-22.4-50-50z"/><path id="path1_fill_1_" class="st2" d="M0 50C0 22.4 22.4 0 50 0h50v100H50C22.4 100 0 77.6 0 50z"/><path id="path2_fill" class="st3" d="M100 0h50c27.6 0 50 22.4 50 50s-22.4 50-50 50h-50V0z"/><path id="path3_fill" class="st4" d="M200 150c0 27.6-22.4 50-50 50s-50-22.4-50-50 22.4-50 50-50 50 22.4 50 50z"/></svg>`;
+export const FIGMA_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

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

@@ -0,0 +1,58 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { inferToolScope } from '../../core/scope.js';
+import { FIGMA_ICON } from './icon.js';
+import { figmaTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'figma',
+    displayName: 'Figma',
+    shortDescription: 'Read files, export assets, manage comments, variables, webhooks, and libraries in Figma.',
+    category: 'Design & Creative Tools',
+    icon: FIGMA_ICON,
+    auth: {
+        type: 'oauth2',
+        tokenField: 'figmaToken',
+        provider: {
+            slug: 'figma',
+            env: { clientId: 'FIGMA_CLIENT_ID', clientSecret: 'FIGMA_CLIENT_SECRET' },
+            authorizeUrl: 'https://www.figma.com/oauth',
+            tokenUrl: 'https://api.figma.com/v1/oauth/token',
+            scopes: [
+                'file_content:read',
+                'file_metadata:read',
+                'file_comments:write',
+                'file_variables:read',
+                'file_variables:write',
+                'file_dev_resources:read',
+                'file_dev_resources:write',
+                'file_versions:read',
+                'files:read',
+                'library_content:read',
+                'library_analytics:read',
+                'projects:read',
+                'webhooks:read',
+                'webhooks:write',
+                'team_library_content:read',
+                'org:activity_log_read',
+            ],
+            exchangeStyle: 'form',
+            extraAuthParams: {},
+            connectDescription: 'Connect Figma to read designs, export assets, and manage libraries.',
+            callbackPath: '/api/auth/figma/callback',
+            stateCookie: 'figma_oauth_state',
+        },
+    },
+    allowedHosts: ['api.figma.com', 'www.figma.com'],
+    tools: figmaTools.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.figma.com',
+        docsUrl: 'https://developers.figma.com/docs/rest-api',
+    },
+});
+//# sourceMappingURL=manifest.js.map

package/dist/toolkits/figma/tools/add-comment-to-a-file.d.ts

@@ -0,0 +1,8 @@
+export declare const addCommentToAFile: import("ai").Tool<{
+    message: string;
+    figmaToken: string;
+    fileKey: string;
+    commentId?: string | undefined;
+    clientMeta?: Record<string, any> | undefined;
+}, any>;
+//# sourceMappingURL=add-comment-to-a-file.d.ts.map

package/dist/toolkits/figma/tools/add-comment-to-a-file.js

@@ -0,0 +1,43 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { figmaRequest, figmaTokenField } from './client.js';
+export const addCommentToAFile = tool({
+    description: 'Posts a comment to a file or branch, optionally as a reply to a root comment (no nested replies). Provide clientMeta to position the pin.',
+    inputSchema: z.object({
+        figmaToken: figmaTokenField,
+        fileKey: z.string().describe('File or branch key from the file URL'),
+        message: z.string().describe('Comment text'),
+        commentId: z.string().optional().describe('Root comment ID to reply to'),
+        clientMeta: z.record(z.any()).optional().describe('Position: {x,y}, {node_id,node_offset}, or region with positive region_height/region_width'),
+    }),
+    execute: async ({ figmaToken, fileKey, message, commentId, clientMeta }) => {
+        try {
+            if (clientMeta && ('region_height' in clientMeta || 'region_width' in clientMeta)) {
+                const h = Number(clientMeta.region_height);
+                const w = Number(clientMeta.region_width);
+                if (!(h > 0) || !(w > 0))
+                    return { error: 'region_height and region_width must be positive' };
+            }
+            const body = { message };
+            if (commentId)
+                body.comment_id = commentId;
+            if (clientMeta)
+                body.client_meta = clientMeta;
+            const result = await figmaRequest(figmaToken, `/v1/files/${fileKey}/comments`, {
+                method: 'POST',
+                body,
+            });
+            if (!result.ok)
+                return { error: 'Failed to post comment', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error posting comment',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=add-comment-to-a-file.js.map

package/dist/toolkits/figma/tools/add-reaction-to-a-comment.d.ts

@@ -0,0 +1,7 @@
+export declare const addReactionToAComment: import("ai").Tool<{
+    emoji: string;
+    commentId: string;
+    figmaToken: string;
+    fileKey: string;
+}, any>;
+//# sourceMappingURL=add-reaction-to-a-comment.d.ts.map

package/dist/toolkits/figma/tools/add-reaction-to-a-comment.js

@@ -0,0 +1,31 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { figmaRequest, figmaTokenField } from './client.js';
+export const addReactionToAComment = tool({
+    description: 'Posts an emoji reaction (shortcode like :heart:) to a comment in a file or branch.',
+    inputSchema: z.object({
+        figmaToken: figmaTokenField,
+        fileKey: z.string().describe('File or branch key from the file URL'),
+        commentId: z.string().describe('Comment ID to react to'),
+        emoji: z.string().describe('Emoji shortcode, e.g. :heart: or :+1::skin-tone-2:'),
+    }),
+    execute: async ({ figmaToken, fileKey, commentId, emoji }) => {
+        try {
+            const result = await figmaRequest(figmaToken, `/v1/files/${fileKey}/comments/${commentId}/reactions`, {
+                method: 'POST',
+                body: { emoji },
+            });
+            if (!result.ok)
+                return { error: 'Failed to add reaction', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error adding reaction',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=add-reaction-to-a-comment.js.map

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

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+export declare const FIGMA_API_BASE = "https://api.figma.com";
+export declare const FIGMA_SCIM_BASE = "https://www.figma.com/scim/v2";
+export declare const figmaTokenField: z.ZodString;
+export declare function buildQuery(params: Record<string, string | number | boolean | undefined>): string;
+export declare function figmaRequest(figmaToken: string, path: string, options?: {
+    method?: string;
+    query?: Record<string, string | number | boolean | undefined>;
+    body?: unknown;
+    base?: string;
+}): Promise<{
+    ok: false;
+    error: any;
+    data?: undefined;
+} | {
+    ok: true;
+    data: any;
+    error?: undefined;
+}>;
+//# sourceMappingURL=client.d.ts.map

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

@@ -0,0 +1,36 @@
+// @ts-nocheck
+import { z } from 'zod';
+export const FIGMA_API_BASE = 'https://api.figma.com';
+export const FIGMA_SCIM_BASE = 'https://www.figma.com/scim/v2';
+export const figmaTokenField = z.string().describe('Figma OAuth access token (sent as Bearer)');
+export function buildQuery(params) {
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined)
+            search.set(key, String(value));
+    }
+    const qs = search.toString();
+    return qs ? `?${qs}` : '';
+}
+export async function figmaRequest(figmaToken, path, options) {
+    const base = options?.base ?? FIGMA_API_BASE;
+    const url = `${base}${path}${buildQuery(options?.query ?? {})}`;
+    const response = await fetch(url, {
+        method: options?.method ?? 'GET',
+        headers: {
+            Authorization: `Bearer ${figmaToken}`,
+            ...(options?.body !== undefined ? { 'Content-Type': 'application/json' } : {}),
+        },
+        body: options?.body !== undefined ? JSON.stringify(options.body) : undefined,
+    });
+    if (!response.ok) {
+        const details = await response.json().catch(() => ({}));
+        return { ok: false, error: details };
+    }
+    if (response.status === 204) {
+        return { ok: true, data: { success: true } };
+    }
+    const data = await response.json().catch(() => ({}));
+    return { ok: true, data };
+}
+//# sourceMappingURL=client.js.map

package/dist/toolkits/figma/tools/create-a-webhook.d.ts

@@ -0,0 +1,12 @@
+export declare const createAWebhook: import("ai").Tool<{
+    eventType: "FILE_COMMENT" | "FILE_DELETE" | "FILE_UPDATE" | "FILE_VERSION_UPDATE" | "LIBRARY_PUBLISH";
+    endpoint: string;
+    figmaToken: string;
+    passcode: string;
+    status?: "ACTIVE" | "PAUSED" | undefined;
+    description?: string | undefined;
+    teamId?: string | undefined;
+    context?: "team" | "file" | "project" | undefined;
+    contextId?: string | undefined;
+}, any>;
+//# sourceMappingURL=create-a-webhook.d.ts.map

package/dist/toolkits/figma/tools/create-a-webhook.js

@@ -0,0 +1,45 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { figmaRequest, figmaTokenField } from './client.js';
+const eventType = z.enum(['FILE_COMMENT', 'FILE_DELETE', 'FILE_UPDATE', 'FILE_VERSION_UPDATE', 'LIBRARY_PUBLISH']);
+export const createAWebhook = tool({
+    description: 'Creates a team/project/file webhook. Figma PINGs the endpoint on creation unless PAUSED. Extract team/project/file IDs from Figma URLs or discoverFigmaResources.',
+    inputSchema: z.object({
+        figmaToken: figmaTokenField,
+        eventType: eventType.describe('Event that triggers the webhook'),
+        endpoint: z.string().describe('Public HTTPS URL receiving Figma POSTs (max 2048 chars)'),
+        passcode: z.string().describe('Secret for verifying Figma requests (max 100 chars)'),
+        context: z.enum(['team', 'project', 'file']).optional().describe('Scope; use with contextId'),
+        contextId: z.string().optional().describe('Team, project, or file ID to monitor'),
+        teamId: z.string().optional().describe('DEPRECATED: use context=team with contextId'),
+        status: z.enum(['ACTIVE', 'PAUSED']).optional().describe('Initial status (default ACTIVE)'),
+        description: z.string().optional().describe('Human-readable purpose (max 150 chars)'),
+    }),
+    execute: async ({ figmaToken, eventType, endpoint, passcode, context, contextId, teamId, status, description }) => {
+        try {
+            const body = { event_type: eventType, endpoint, passcode };
+            if (context)
+                body.context = context;
+            if (contextId)
+                body.context_id = contextId;
+            if (teamId)
+                body.team_id = teamId;
+            if (status)
+                body.status = status;
+            if (description)
+                body.description = description;
+            const result = await figmaRequest(figmaToken, '/v2/webhooks', { method: 'POST', body });
+            if (!result.ok)
+                return { error: 'Failed to create webhook', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error creating webhook',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=create-a-webhook.js.map