@rnsk/toolkits 0.0.8 → 0.0.9

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

@@ -0,0 +1,102 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { slackApi, toSlackError, requireToken } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+export const slackCreateCanvas = tool({
+    description: 'Create a Canvas with an optional title, markdown content, and channel tab. Returns the canvas_id.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        title: z.string().optional().describe('Canvas title (Slack defaults when omitted)'),
+        documentContent: z.record(z.any()).optional().describe('Initial content, e.g. {type:"markdown",markdown:"# Hi"}'),
+        channelId: z.string().optional().describe('Channel ID to add the canvas as a tab to'),
+    }),
+    execute: async ({ slackToken, title, documentContent, channelId }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'canvases.create', {
+                title,
+                document_content: documentContent,
+                channel_id: channelId,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to create canvas');
+        }
+    },
+});
+export const slackEditCanvas = tool({
+    description: 'Edit a Canvas: replace whole content or a section, insert before/after/at start/at end, delete a section, or rename. Use slackLookupCanvasSections to find section IDs for targeted edits.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        canvasId: z.string().describe('Canvas ID, e.g. F01234ABCDE'),
+        operation: z
+            .enum(['replace', 'insert_after', 'insert_before', 'insert_at_start', 'insert_at_end', 'delete', 'rename'])
+            .optional()
+            .default('replace')
+            .describe('Edit operation'),
+        sectionId: z.string().optional().describe('Target section (required for insert_after/before and delete)'),
+        documentContent: z.record(z.any()).optional().describe('Content in Slack document format (not for delete/rename)'),
+        titleContent: z.record(z.any()).optional().describe('New title in markdown format (rename only)'),
+    }),
+    execute: async ({ slackToken, canvasId, operation = 'replace', sectionId, documentContent, titleContent }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'canvases.edit', {
+                canvas_id: canvasId,
+                operation,
+                section_id: sectionId,
+                document_content: documentContent,
+                title_content: titleContent,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to edit canvas');
+        }
+    },
+});
+export const slackDeleteCanvas = tool({
+    description: 'Permanently delete a Canvas. Irreversible — confirm with the user first.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        canvasId: z.string().describe('Canvas ID to delete'),
+    }),
+    execute: async ({ slackToken, canvasId }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'canvases.delete', { canvas_id: canvasId });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to delete canvas');
+        }
+    },
+});
+export const slackLookupCanvasSections = tool({
+    description: 'Find section IDs in a Canvas by text criteria. Use the returned IDs with slackEditCanvas targeted operations.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        canvasId: z.string().describe('Canvas ID to search, e.g. F01234ABCDE'),
+        criteria: z.record(z.any()).describe('Search criteria, e.g. {contains_text:"Roadmap"}'),
+    }),
+    execute: async ({ slackToken, canvasId, criteria }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'canvases.sections.lookup', {
+                canvas_id: canvasId,
+                criteria,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to look up canvas sections');
+        }
+    },
+});
+//# sourceMappingURL=canvas.js.map

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

@@ -0,0 +1,22 @@
+export declare class SlackApiError extends Error {
+    status: number;
+    details: unknown;
+    constructor(message: string, status: number, details: unknown);
+}
+/** Call a Slack Web API method. Throws SlackApiError when ok === false. */
+export declare function slackApi(slackToken: string, method: string, params?: Record<string, unknown>): Promise<any>;
+/** GET helper for non-Web-API hosts (Audit Logs, SCIM). */
+export declare function slackGet(slackToken: string, url: string, query?: Record<string, string | number | boolean | undefined>): Promise<any>;
+export declare function toSlackError(error: unknown, label: string): {
+    error: string;
+    details: any;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+};
+export declare function requireToken(slackToken: string | undefined): {
+    error: string;
+} | null;
+//# sourceMappingURL=client.d.ts.map

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

@@ -0,0 +1,73 @@
+// @ts-nocheck
+const API_BASE = 'https://slack.com/api';
+export class SlackApiError extends Error {
+    status;
+    details;
+    constructor(message, status, details) {
+        super(message);
+        this.status = status;
+        this.details = details;
+    }
+}
+function toForm(params) {
+    const form = new URLSearchParams();
+    if (!params)
+        return form;
+    for (const [key, value] of Object.entries(params)) {
+        if (value === undefined)
+            continue;
+        form.set(key, typeof value === 'string' ? value : JSON.stringify(value));
+    }
+    return form;
+}
+/** Call a Slack Web API method. Throws SlackApiError when ok === false. */
+export async function slackApi(slackToken, method, params) {
+    const response = await fetch(`${API_BASE}/${method}`, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${slackToken}`,
+            'Content-Type': 'application/x-www-form-urlencoded;charset=utf-8',
+        },
+        body: toForm(params).toString(),
+    });
+    const data = await response.json().catch(() => ({}));
+    if (!response.ok || data?.ok === false) {
+        throw new SlackApiError(`Slack ${method} failed${data?.error ? `: ${data.error}` : ''}`, response.status, data);
+    }
+    return data;
+}
+/** GET helper for non-Web-API hosts (Audit Logs, SCIM). */
+export async function slackGet(slackToken, url, query) {
+    const u = new URL(url);
+    if (query) {
+        for (const [key, value] of Object.entries(query)) {
+            if (value === undefined)
+                continue;
+            u.searchParams.set(key, String(value));
+        }
+    }
+    const response = await fetch(u.toString(), {
+        headers: { Authorization: `Bearer ${slackToken}` },
+    });
+    const data = await response.json().catch(() => ({}));
+    if (!response.ok || data?.ok === false) {
+        throw new SlackApiError(`Slack request failed${data?.error ? `: ${data.error}` : ''}`, response.status, data);
+    }
+    return data;
+}
+export function toSlackError(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',
+    };
+}
+export function requireToken(slackToken) {
+    if (!slackToken) {
+        return { error: 'Slack token is required. Connect Slack first.' };
+    }
+    return null;
+}
+//# sourceMappingURL=client.js.map

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

@@ -0,0 +1,131 @@
+export declare const slackListAllChannels: import("ai").Tool<{
+    types?: string | undefined;
+    teamId?: string | undefined;
+    limit?: number | undefined;
+    cursor?: string | undefined;
+    slackToken?: string | undefined;
+    excludeArchived?: boolean | undefined;
+}, any>;
+export declare const slackFindChannels: import("ai").Tool<{
+    query: string;
+    types: string;
+    limit: number;
+    excludeArchived: boolean;
+    teamId?: string | undefined;
+    slackToken?: string | undefined;
+    exactMatch?: boolean | undefined;
+    memberOnly?: boolean | undefined;
+}, {
+    error: string;
+} | {
+    ok: boolean;
+    channels: any;
+    total_channels_searched: any;
+}>;
+export declare const slackListConversations: import("ai").Tool<{
+    types?: string | undefined;
+    teamId?: string | undefined;
+    user?: string | undefined;
+    limit?: number | undefined;
+    cursor?: string | undefined;
+    slackToken?: string | undefined;
+    excludeArchived?: boolean | undefined;
+}, any>;
+export declare const slackGetConversationInfo: import("ai").Tool<{
+    channel: string;
+    slackToken?: string | undefined;
+    includeNumMembers?: boolean | undefined;
+    includeLocale?: boolean | undefined;
+}, any>;
+export declare const slackGetConversationMembers: import("ai").Tool<{
+    channel: string;
+    limit?: number | undefined;
+    cursor?: string | undefined;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackGetConversationHistory: import("ai").Tool<{
+    limit: number;
+    channel: string;
+    inclusive?: boolean | undefined;
+    latest?: string | undefined;
+    cursor?: string | undefined;
+    slackToken?: string | undefined;
+    oldest?: string | undefined;
+    includeAllMetadata?: boolean | undefined;
+}, any>;
+export declare const slackGetConversationReplies: import("ai").Tool<{
+    channel: string;
+    ts: string;
+    inclusive?: boolean | undefined;
+    limit?: number | undefined;
+    latest?: string | undefined;
+    cursor?: string | undefined;
+    slackToken?: string | undefined;
+    oldest?: string | undefined;
+    includeAllMetadata?: boolean | undefined;
+}, any>;
+export declare const slackCreateChannel: import("ai").Tool<{
+    name: string;
+    teamId?: string | undefined;
+    slackToken?: string | undefined;
+    isPrivate?: boolean | undefined;
+}, any>;
+export declare const slackArchiveChannel: import("ai").Tool<{
+    channel: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackUnarchiveChannel: import("ai").Tool<{
+    channel: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackCloseDm: import("ai").Tool<{
+    channel: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackJoinConversation: import("ai").Tool<{
+    channel: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackLeaveConversation: import("ai").Tool<{
+    channel: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackRenameConversation: import("ai").Tool<{
+    name: string;
+    channel: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackSetConversationTopic: import("ai").Tool<{
+    channel: string;
+    topic: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackSetConversationPurpose: import("ai").Tool<{
+    channel: string;
+    purpose: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackMarkConversationRead: import("ai").Tool<{
+    channel: string;
+    ts: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackInviteUsersToChannel: import("ai").Tool<{
+    users: string;
+    channel: string;
+    force?: boolean | undefined;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackRemoveUserFromConversation: import("ai").Tool<{
+    user: string;
+    channel: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackOpenDm: import("ai").Tool<{
+    users?: string | undefined;
+    channel?: string | undefined;
+    slackToken?: string | undefined;
+    returnIm?: boolean | undefined;
+    preventCreation?: boolean | undefined;
+}, any>;
+//# sourceMappingURL=conversations.d.ts.map