feat(slack-advanced): add create_channel and create_group_dm tools (#74)

* feat(slack-advanced): add create_channel tool

Add a create_channel tool that creates public or private Slack channels and
optionally invites users by ID, email, or display name. Supports setting a
topic and purpose, and reports per-user invite errors without failing the
whole operation.

* feat(slack-advanced): add create_group_dm tool

Add a create_group_dm tool that opens a multi-person DM (MPDM) with multiple
users referenced by ID, email, or display name, and optionally posts a message.
Unresolved users are reported without aborting. Requires the mpim:write scope.

* chore(slack-advanced): bump version to 1.11.0

Author: Joao208

packages/slack-advanced/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arvoretech/slack-advanced-mcp",
-  "version": "1.10.0",
+  "version": "1.11.0",
   "description": "Advanced Slack MCP Server with semantic user search, smart DMs, style analysis, thread extraction, audio transcription, and image analysis",
   "main": "dist/index.js",
   "type": "module",

packages/slack-advanced/src/server.ts

@@ -30,6 +30,8 @@ import {
   DeleteMessageParamsSchema,
   AddReactionParamsSchema,
   RemoveReactionParamsSchema,
+  CreateChannelParamsSchema,
+  CreateGroupDmParamsSchema,
 } from "./types.js";
 
 export class SlackAdvancedMCPServer {
@@ -258,6 +260,24 @@ export class SlackAdvancedMCPServer {
     }, async (params) => {
       return this.messagingTools.removeReaction(RemoveReactionParamsSchema.parse(params));
     });
+
+    this.server.registerTool("create_channel", {
+      title: "Create Channel",
+      description:
+        "Create a new Slack channel (public or private) and optionally invite users to it. Users can be referenced by ID, email, or display name. Optionally sets a topic and purpose. Returns the new channel ID, invited users, and any invite errors. Requires channels:manage and/or groups:write scopes, plus channels:write.invites for inviting members.",
+      inputSchema: CreateChannelParamsSchema.shape,
+    }, async (params) => {
+      return this.messagingTools.createChannel(CreateChannelParamsSchema.parse(params));
+    });
+
+    this.server.registerTool("create_group_dm", {
+      title: "Create Group DM",
+      description:
+        "Open a multi-person direct message (MPDM / group DM) with multiple users and optionally post a message in it. Users can be referenced by ID, email, or display name (the authenticated user is added automatically, up to 8 other members). Users that cannot be resolved are reported in resolve_errors without aborting the operation. Requires the mpim:write scope.",
+      inputSchema: CreateGroupDmParamsSchema.shape,
+    }, async (params) => {
+      return this.messagingTools.createGroupDm(CreateGroupDmParamsSchema.parse(params));
+    });
   }
 
   async start(): Promise<void> {

packages/slack-advanced/src/tools/messaging.ts

@@ -9,6 +9,8 @@ import type {
   DeleteMessageParams,
   AddReactionParams,
   RemoveReactionParams,
+  CreateChannelParams,
+  CreateGroupDmParams,
   McpToolResult,
   SlackMessage,
 } from "../types.js";
@@ -309,6 +311,137 @@ export class MessagingTools {
     }
   }
 
+  async createChannel(params: CreateChannelParams): Promise<McpToolResult> {
+    try {
+      const createRes = await this.slack.request<{
+        ok: boolean;
+        channel: { id: string; name: string; is_private: boolean };
+      }>("conversations.create", {
+        name: params.name,
+        is_private: params.is_private,
+      });
+
+      const channelId = createRes.channel.id;
+      const invited: Array<{ user: string; user_id: string }> = [];
+      const inviteErrors: Array<{ user: string; error: string }> = [];
+
+      if (params.invite_users && params.invite_users.length > 0) {
+        const userIds: string[] = [];
+        for (const identifier of params.invite_users) {
+          try {
+            const userId = await this.slack.resolveUserId(identifier);
+            userIds.push(userId);
+            invited.push({ user: identifier, user_id: userId });
+          } catch (error) {
+            inviteErrors.push({
+              user: identifier,
+              error: error instanceof Error ? error.message : "Could not resolve user",
+            });
+          }
+        }
+
+        if (userIds.length > 0) {
+          try {
+            await this.slack.request<{ ok: boolean }>("conversations.invite", {
+              channel: channelId,
+              users: userIds.join(","),
+            });
+          } catch (error) {
+            inviteErrors.push({
+              user: userIds.join(","),
+              error: error instanceof Error ? error.message : "Failed to invite users",
+            });
+          }
+        }
+      }
+
+      if (params.topic) {
+        await this.slack.request<{ ok: boolean }>("conversations.setTopic", {
+          channel: channelId,
+          topic: params.topic,
+        });
+      }
+
+      if (params.purpose) {
+        await this.slack.request<{ ok: boolean }>("conversations.setPurpose", {
+          channel: channelId,
+          purpose: params.purpose,
+        });
+      }
+
+      return this.ok({
+        created: true,
+        channel_id: channelId,
+        name: createRes.channel.name,
+        is_private: createRes.channel.is_private,
+        invited,
+        ...(inviteErrors.length > 0 && { invite_errors: inviteErrors }),
+      });
+    } catch (error) {
+      return this.formatError(error);
+    }
+  }
+
+  async createGroupDm(params: CreateGroupDmParams): Promise<McpToolResult> {
+    try {
+      const resolved: Array<{ user: string; user_id: string }> = [];
+      const resolveErrors: Array<{ user: string; error: string }> = [];
+
+      for (const identifier of params.users) {
+        try {
+          const userId = await this.slack.resolveUserId(identifier);
+          resolved.push({ user: identifier, user_id: userId });
+        } catch (error) {
+          resolveErrors.push({
+            user: identifier,
+            error: error instanceof Error ? error.message : "Could not resolve user",
+          });
+        }
+      }
+
+      if (resolved.length === 0) {
+        return this.ok({
+          created: false,
+          error: "No users could be resolved",
+          resolve_errors: resolveErrors,
+        });
+      }
+
+      const openRes = await this.slack.request<{
+        ok: boolean;
+        channel: { id: string };
+      }>("conversations.open", {
+        users: resolved.map((r) => r.user_id).join(","),
+      });
+
+      const channelId = openRes.channel.id;
+      let messageTs: string | null = null;
+
+      if (params.message) {
+        const mrkdwn = this.toMrkdwn(params.message);
+        const blocks = this.buildBlocks(mrkdwn);
+        const res = await this.slack.request<{ ok: boolean; ts: string }>("chat.postMessage", {
+          channel: channelId,
+          text: mrkdwn,
+          blocks: JSON.stringify(blocks),
+          unfurl_links: false,
+          unfurl_media: false,
+        });
+        messageTs = res.ts;
+      }
+
+      return this.ok({
+        created: true,
+        channel_id: channelId,
+        members: resolved,
+        ...(messageTs && { message_ts: messageTs }),
+        ...(resolveErrors.length > 0 && { resolve_errors: resolveErrors }),
+      });
+    } catch (error) {
+      return this.formatError(error);
+    }
+  }
+
   private ok(data: unknown): McpToolResult {
     return {
       content: [{ type: "text", text: JSON.stringify(data, null, 2) }],

packages/slack-advanced/src/types.ts

@@ -387,9 +387,46 @@ export const GetUserInfoParamsSchema = z.object({
     .describe("User ID, email, display name, or real name to look up"),
 });
 
+export const CreateChannelParamsSchema = z.object({
+  name: z
+    .string()
+    .min(1, "Channel name is required")
+    .describe("Channel name. Slack normalizes it to lowercase, replaces spaces with hyphens, and strips invalid characters (max 80 chars)"),
+  is_private: z
+    .boolean()
+    .optional()
+    .default(false)
+    .describe("Create a private channel instead of a public one"),
+  invite_users: z
+    .array(z.string().min(1))
+    .optional()
+    .describe("List of users to invite after creation. Each entry can be a user ID, email, or display name"),
+  topic: z
+    .string()
+    .optional()
+    .describe("Optional channel topic to set after creation"),
+  purpose: z
+    .string()
+    .optional()
+    .describe("Optional channel purpose/description to set after creation"),
+});
+
+export const CreateGroupDmParamsSchema = z.object({
+  users: z
+    .array(z.string().min(1))
+    .min(1, "At least one user is required")
+    .describe("Users to include in the multi-person DM (MPDM). Each entry can be a user ID, email, or display name. The authenticated user is added automatically by Slack. Slack supports up to 8 other members"),
+  message: z
+    .string()
+    .optional()
+    .describe("Optional message to post in the group DM right after opening it (supports Slack mrkdwn)"),
+});
+
 export type SearchUsersParams = z.infer<typeof SearchUsersParamsSchema>;
 export type GetUserProfileParams = z.infer<typeof GetUserProfileParamsSchema>;
 export type GetUserInfoParams = z.infer<typeof GetUserInfoParamsSchema>;
+export type CreateChannelParams = z.infer<typeof CreateChannelParamsSchema>;
+export type CreateGroupDmParams = z.infer<typeof CreateGroupDmParamsSchema>;
 export type MessageMetadata = z.infer<typeof MessageMetadataSchema>;
 export type SendDmParams = z.infer<typeof SendDmParamsSchema>;
 export type GetDmHistoryParams = z.infer<typeof GetDmHistoryParamsSchema>;