@agenticmail/enterprise 0.3.2 → 0.4.0

package/src/mcp/adapters/discord.adapter.ts

@@ -0,0 +1,248 @@
+/**
+ * MCP Skill Adapter — Discord
+ *
+ * Maps Discord API v10 endpoints to MCP tool handlers.
+ * Handles Discord-specific error patterns where error responses include
+ * `{ code, message }` with standard HTTP error codes.
+ *
+ * Discord API docs: https://discord.com/developers/docs
+ */
+
+import type { SkillAdapter, ToolHandler, ToolResult, ToolExecutionContext } from '../framework/types.js';
+
+// ─── Helpers ────────────────────────────────────────────
+
+/** Map Discord channel type integers to human-readable names */
+const CHANNEL_TYPE_NAMES: Record<number, string> = {
+  0: 'text',
+  2: 'voice',
+  4: 'category',
+  5: 'announcement',
+  13: 'stage',
+  15: 'forum',
+};
+
+function channelTypeName(type: number): string {
+  return CHANNEL_TYPE_NAMES[type] ?? `unknown(${type})`;
+}
+
+function discordError(err: unknown): ToolResult {
+  const message = err instanceof Error ? err.message : String(err);
+  return { content: message, isError: true };
+}
+
+// ─── Tool: discord_send_message ─────────────────────────
+
+const sendMessage: ToolHandler = {
+  description:
+    'Send a message to a Discord channel. Provide the channel ID and message content.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      channel_id: {
+        type: 'string',
+        description: 'The ID of the channel to send the message to',
+      },
+      content: {
+        type: 'string',
+        description: 'Message content (supports Discord markdown)',
+      },
+      tts: {
+        type: 'boolean',
+        description: 'Whether the message should be sent as text-to-speech (optional)',
+      },
+    },
+    required: ['channel_id', 'content'],
+  },
+
+  async execute(params: Record<string, any>, ctx: ToolExecutionContext): Promise<ToolResult> {
+    try {
+      const body: Record<string, any> = {
+        content: params.content,
+      };
+      if (params.tts !== undefined) body.tts = params.tts;
+
+      const result = await ctx.apiExecutor.post(
+        `/channels/${params.channel_id}/messages`,
+        body,
+      );
+
+      return {
+        content: `Message sent (ID: ${result.id}) in channel ${params.channel_id}`,
+        metadata: { messageId: result.id, channelId: params.channel_id },
+      };
+    } catch (err) {
+      return discordError(err);
+    }
+  },
+};
+
+// ─── Tool: discord_list_channels ────────────────────────
+
+const listChannels: ToolHandler = {
+  description:
+    'List all channels in a Discord server (guild). Returns channel names, types, and IDs.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      guild_id: {
+        type: 'string',
+        description: 'The ID of the guild (server) to list channels for',
+      },
+    },
+    required: ['guild_id'],
+  },
+
+  async execute(params: Record<string, any>, ctx: ToolExecutionContext): Promise<ToolResult> {
+    try {
+      const channels: any[] = await ctx.apiExecutor.get(
+        `/guilds/${params.guild_id}/channels`,
+      );
+
+      if (!channels || channels.length === 0) {
+        return { content: 'No channels found in this server.' };
+      }
+
+      const lines = channels.map((ch: any) => {
+        const typeName = channelTypeName(ch.type);
+        return `#${ch.name} (${typeName}) — ${ch.id}`;
+      });
+
+      return {
+        content: `Found ${channels.length} channels:\n${lines.join('\n')}`,
+        metadata: { count: channels.length, guildId: params.guild_id },
+      };
+    } catch (err) {
+      return discordError(err);
+    }
+  },
+};
+
+// ─── Tool: discord_create_channel ───────────────────────
+
+const createChannel: ToolHandler = {
+  description:
+    'Create a new channel in a Discord server (guild). Specify name and optional type, topic, and parent category.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      guild_id: {
+        type: 'string',
+        description: 'The ID of the guild (server) to create the channel in',
+      },
+      name: {
+        type: 'string',
+        description: 'Channel name (lowercase, hyphens for spaces)',
+      },
+      type: {
+        type: 'number',
+        description: 'Channel type: 0=text (default), 2=voice, 4=category, 5=announcement, 13=stage, 15=forum',
+      },
+      topic: {
+        type: 'string',
+        description: 'Channel topic / description (optional)',
+      },
+      parent_id: {
+        type: 'string',
+        description: 'ID of the parent category channel (optional)',
+      },
+    },
+    required: ['guild_id', 'name'],
+  },
+
+  async execute(params: Record<string, any>, ctx: ToolExecutionContext): Promise<ToolResult> {
+    try {
+      const body: Record<string, any> = {
+        name: params.name,
+        type: params.type ?? 0,
+      };
+      if (params.topic) body.topic = params.topic;
+      if (params.parent_id) body.parent_id = params.parent_id;
+
+      const result = await ctx.apiExecutor.post(
+        `/guilds/${params.guild_id}/channels`,
+        body,
+      );
+
+      return {
+        content: `Channel #${result.name} created (ID: ${result.id})`,
+        metadata: { channelId: result.id, name: result.name, guildId: params.guild_id },
+      };
+    } catch (err) {
+      return discordError(err);
+    }
+  },
+};
+
+// ─── Tool: discord_get_guild ────────────────────────────
+
+const getGuild: ToolHandler = {
+  description:
+    'Get information about a Discord server (guild), including member count, owner, and features.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      guild_id: {
+        type: 'string',
+        description: 'The ID of the guild (server) to retrieve info for',
+      },
+    },
+    required: ['guild_id'],
+  },
+
+  async execute(params: Record<string, any>, ctx: ToolExecutionContext): Promise<ToolResult> {
+    try {
+      const guild = await ctx.apiExecutor.get(
+        `/guilds/${params.guild_id}`,
+        { with_counts: 'true' },
+      );
+
+      const createdDate = guild.id
+        ? new Date(Number(BigInt(guild.id) >> 22n) + 1420070400000).toISOString().slice(0, 10)
+        : 'unknown';
+
+      const features = guild.features?.length > 0
+        ? guild.features.join(', ')
+        : 'none';
+
+      return {
+        content: [
+          `Server: ${guild.name}`,
+          `Members: ${guild.approximate_member_count ?? 'unknown'}`,
+          `Owner: ${guild.owner_id}`,
+          `Created: ${createdDate}`,
+          `Features: ${features}`,
+        ].join('\n'),
+        metadata: {
+          guildId: guild.id,
+          name: guild.name,
+          memberCount: guild.approximate_member_count,
+        },
+      };
+    } catch (err) {
+      return discordError(err);
+    }
+  },
+};
+
+// ─── Adapter Export ─────────────────────────────────────
+
+export const discordAdapter: SkillAdapter = {
+  skillId: 'discord',
+  name: 'Discord',
+  baseUrl: 'https://discord.com/api/v10',
+  auth: {
+    type: 'token',
+    headerPrefix: 'Bot',
+  },
+  tools: {
+    discord_send_message: sendMessage,
+    discord_list_channels: listChannels,
+    discord_create_channel: createChannel,
+    discord_get_guild: getGuild,
+  },
+  rateLimits: {
+    requestsPerSecond: 5,
+    burstLimit: 10,
+  },
+};

package/src/mcp/adapters/docker.adapter.ts

@@ -0,0 +1,238 @@
+/**
+ * MCP Skill Adapter — Docker Hub
+ *
+ * Maps Docker Hub REST API v2 endpoints to MCP tool handlers.
+ * Provides access to image search, repository listing, and tag listing.
+ *
+ * Docker Hub API docs: https://docs.docker.com/docker-hub/api/latest/
+ */
+
+import type { SkillAdapter, ToolHandler, ToolResult, ToolExecutionContext } from '../framework/types.js';
+
+// ─── Helpers ────────────────────────────────────────────
+
+function dockerError(err: unknown): ToolResult {
+  if (err instanceof Error) {
+    const data = (err as any).data;
+    if (data && typeof data === 'object') {
+      const msg = data.message || data.detail || data.errinfo?.message || err.message;
+      return { content: `Docker Hub API error: ${msg}`, isError: true };
+    }
+    return { content: `Docker Hub API error: ${err.message}`, isError: true };
+  }
+  return { content: `Docker Hub API error: ${String(err)}`, isError: true };
+}
+
+// ─── Tool: docker_search_images ─────────────────────────
+
+const searchImages: ToolHandler = {
+  description:
+    'Search for Docker images on Docker Hub by keyword. Returns image names, descriptions, and star counts.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      query: {
+        type: 'string',
+        description: 'Search term (e.g. "nginx", "node", "postgres")',
+      },
+      page_size: {
+        type: 'number',
+        description: 'Number of results per page (default 25, max 100)',
+      },
+      page: {
+        type: 'number',
+        description: 'Page number for pagination (default 1)',
+      },
+    },
+    required: ['query'],
+  },
+
+  async execute(params: Record<string, any>, ctx: ToolExecutionContext): Promise<ToolResult> {
+    try {
+      const query: Record<string, string> = {
+        query: params.query,
+        page_size: String(params.page_size ?? 25),
+        page: String(params.page ?? 1),
+      };
+
+      const result = await ctx.apiExecutor.get('/search/repositories', query);
+
+      const images: any[] = Array.isArray(result.results) ? result.results : [];
+      if (images.length === 0) {
+        return { content: `No images found for query: "${params.query}"` };
+      }
+
+      const lines = images.map((img: any) => {
+        const desc = img.short_description ? ` -- ${img.short_description}` : '';
+        const stars = img.star_count ?? 0;
+        const official = img.is_official ? ' [official]' : '';
+        return `${img.repo_name || img.name}${official}${desc} (${stars} stars)`;
+      });
+
+      return {
+        content: `Found ${result.count || images.length} images for "${params.query}" (showing ${images.length}):\n${lines.join('\n')}`,
+        metadata: {
+          total: result.count,
+          shown: images.length,
+          query: params.query,
+        },
+      };
+    } catch (err) {
+      return dockerError(err);
+    }
+  },
+};
+
+// ─── Tool: docker_list_repos ────────────────────────────
+
+const listRepos: ToolHandler = {
+  description:
+    'List Docker Hub repositories for a specific user or organization namespace.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      namespace: {
+        type: 'string',
+        description: 'Docker Hub username or organization name',
+      },
+      page_size: {
+        type: 'number',
+        description: 'Number of results per page (default 25, max 100)',
+      },
+      page: {
+        type: 'number',
+        description: 'Page number for pagination (default 1)',
+      },
+    },
+    required: ['namespace'],
+  },
+
+  async execute(params: Record<string, any>, ctx: ToolExecutionContext): Promise<ToolResult> {
+    try {
+      const query: Record<string, string> = {
+        page_size: String(params.page_size ?? 25),
+        page: String(params.page ?? 1),
+      };
+
+      const result = await ctx.apiExecutor.get(
+        `/repositories/${params.namespace}`,
+        query,
+      );
+
+      const repos: any[] = Array.isArray(result.results) ? result.results : [];
+      if (repos.length === 0) {
+        return { content: `No repositories found for namespace "${params.namespace}".` };
+      }
+
+      const lines = repos.map((r: any) => {
+        const desc = r.description ? ` -- ${r.description}` : '';
+        const stars = r.star_count ?? 0;
+        const pulls = r.pull_count ?? 0;
+        const visibility = r.is_private ? 'private' : 'public';
+        return `${r.namespace}/${r.name}${desc} (${visibility}, ${stars} stars, ${pulls} pulls)`;
+      });
+
+      return {
+        content: `Found ${result.count || repos.length} repositories for "${params.namespace}" (showing ${repos.length}):\n${lines.join('\n')}`,
+        metadata: {
+          total: result.count,
+          shown: repos.length,
+          namespace: params.namespace,
+        },
+      };
+    } catch (err) {
+      return dockerError(err);
+    }
+  },
+};
+
+// ─── Tool: docker_list_tags ─────────────────────────────
+
+const listTags: ToolHandler = {
+  description:
+    'List available tags for a Docker Hub repository. Returns tag names, image sizes, and last-updated timestamps.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      namespace: {
+        type: 'string',
+        description: 'Docker Hub username or organization (use "library" for official images)',
+      },
+      repository: {
+        type: 'string',
+        description: 'Repository name (e.g. "nginx", "node")',
+      },
+      page_size: {
+        type: 'number',
+        description: 'Number of results per page (default 25, max 100)',
+      },
+      page: {
+        type: 'number',
+        description: 'Page number for pagination (default 1)',
+      },
+    },
+    required: ['namespace', 'repository'],
+  },
+
+  async execute(params: Record<string, any>, ctx: ToolExecutionContext): Promise<ToolResult> {
+    try {
+      const query: Record<string, string> = {
+        page_size: String(params.page_size ?? 25),
+        page: String(params.page ?? 1),
+      };
+
+      const result = await ctx.apiExecutor.get(
+        `/repositories/${params.namespace}/${params.repository}/tags`,
+        query,
+      );
+
+      const tags: any[] = Array.isArray(result.results) ? result.results : [];
+      if (tags.length === 0) {
+        return {
+          content: `No tags found for ${params.namespace}/${params.repository}.`,
+        };
+      }
+
+      const lines = tags.map((t: any) => {
+        const updated = t.last_updated ? new Date(t.last_updated).toISOString().slice(0, 10) : '';
+        const size = t.full_size
+          ? `${(t.full_size / (1024 * 1024)).toFixed(1)} MB`
+          : 'unknown size';
+        return `${t.name} (${size}) -- updated: ${updated}`;
+      });
+
+      return {
+        content: `Found ${result.count || tags.length} tags for ${params.namespace}/${params.repository} (showing ${tags.length}):\n${lines.join('\n')}`,
+        metadata: {
+          total: result.count,
+          shown: tags.length,
+          namespace: params.namespace,
+          repository: params.repository,
+        },
+      };
+    } catch (err) {
+      return dockerError(err);
+    }
+  },
+};
+
+// ─── Adapter Export ─────────────────────────────────────
+
+export const dockerAdapter: SkillAdapter = {
+  skillId: 'docker-containers',
+  name: 'Docker Hub',
+  baseUrl: 'https://hub.docker.com/v2',
+  auth: {
+    type: 'token',
+    headerPrefix: 'Bearer',
+  },
+  tools: {
+    docker_search_images: searchImages,
+    docker_list_repos: listRepos,
+    docker_list_tags: listTags,
+  },
+  rateLimits: {
+    requestsPerSecond: 10,
+    burstLimit: 25,
+  },
+};