Slack: refine scopes and onboarding

src/agents/tool-display.json

@@ -209,6 +209,24 @@
         "kick": { "label": "kick", "detailKeys": ["guildId", "userId"] },
         "ban": { "label": "ban", "detailKeys": ["guildId", "userId"] }
       }
+    },
+    "slack": {
+      "emoji": "💬",
+      "title": "Slack",
+      "actions": {
+        "react": { "label": "react", "detailKeys": ["channelId", "messageId", "emoji"] },
+        "reactions": { "label": "reactions", "detailKeys": ["channelId", "messageId"] },
+        "sendMessage": { "label": "send", "detailKeys": ["to", "content"] },
+        "editMessage": { "label": "edit", "detailKeys": ["channelId", "messageId"] },
+        "deleteMessage": { "label": "delete", "detailKeys": ["channelId", "messageId"] },
+        "readMessages": { "label": "read messages", "detailKeys": ["channelId", "limit"] },
+        "pinMessage": { "label": "pin", "detailKeys": ["channelId", "messageId"] },
+        "unpinMessage": { "label": "unpin", "detailKeys": ["channelId", "messageId"] },
+        "listPins": { "label": "list pins", "detailKeys": ["channelId"] },
+        "memberInfo": { "label": "member", "detailKeys": ["userId"] },
+        "emojiList": { "label": "emoji list" }
+      }
     }
   }
 }
+

src/commands/onboard-providers.ts

@@ -62,6 +62,90 @@ async function noteDiscordTokenHelp(prompter: WizardPrompter): Promise<void> {
   );
 }
 
+function buildSlackManifest(botName: string) {
+  const safeName = botName.trim() || "Clawdis";
+  const manifest = {
+    display_information: {
+      name: safeName,
+      description: `${safeName} connector for Clawdis`,
+    },
+    features: {
+      bot_user: {
+        display_name: safeName,
+        always_online: false,
+      },
+      slash_commands: [
+        {
+          command: "/clawd",
+          description: "Send a message to Clawdis",
+          should_escape: false,
+        },
+      ],
+    },
+    oauth_config: {
+      scopes: {
+        bot: [
+          "chat:write",
+          "channels:history",
+          "channels:read",
+          "groups:history",
+          "im:history",
+          "mpim:history",
+          "users:read",
+          "app_mentions:read",
+          "reactions:read",
+          "pins:read",
+          "pins:write",
+          "emoji:read",
+          "commands",
+          "files:read",
+          "files:write",
+        ],
+      },
+    },
+    settings: {
+      socket_mode_enabled: true,
+      event_subscriptions: {
+        bot_events: [
+          "app_mention",
+          "message.channels",
+          "message.groups",
+          "message.im",
+          "message.mpim",
+          "reaction_added",
+          "reaction_removed",
+          "member_joined_channel",
+          "member_left_channel",
+          "channel_rename",
+          "pin_added",
+          "pin_removed",
+        ],
+      },
+    },
+  };
+  return JSON.stringify(manifest, null, 2);
+}
+
+async function noteSlackTokenHelp(
+  prompter: WizardPrompter,
+  botName: string,
+): Promise<void> {
+  const manifest = buildSlackManifest(botName);
+  await prompter.note(
+    [
+      "1) Slack API → Create App → From scratch",
+      "2) Add Socket Mode + enable it to get the app-level token (xapp-...)",
+      "3) OAuth & Permissions → install app to workspace (xoxb- bot token)",
+      "4) Enable Event Subscriptions (socket) for message events",
+      "Tip: set SLACK_BOT_TOKEN + SLACK_APP_TOKEN in your env.",
+      "",
+      "Manifest (JSON):",
+      manifest,
+    ].join("\n"),
+    "Slack socket mode tokens",
+  );
+}
+
 function setWhatsAppAllowFrom(cfg: ClawdisConfig, allowFrom?: string[]) {
   return {
     ...cfg,
@@ -374,6 +458,96 @@ export async function setupProviders(
     }
   }
 
+  if (selection.includes("slack")) {
+    let botToken: string | null = null;
+    let appToken: string | null = null;
+    const slackBotName = String(
+      await prompter.text({
+        message: "Slack bot display name (used for manifest)",
+        initialValue: "Clawdis",
+      }),
+    ).trim();
+    if (!slackConfigured) {
+      await noteSlackTokenHelp(prompter, slackBotName);
+    }
+    if (
+      slackBotEnv &&
+      slackAppEnv &&
+      (!cfg.slack?.botToken || !cfg.slack?.appToken)
+    ) {
+      const keepEnv = await prompter.confirm({
+        message: "SLACK_BOT_TOKEN + SLACK_APP_TOKEN detected. Use env vars?",
+        initialValue: true,
+      });
+      if (keepEnv) {
+        next = {
+          ...next,
+          slack: {
+            ...next.slack,
+            enabled: true,
+          },
+        };
+      } else {
+        botToken = String(
+          await prompter.text({
+            message: "Enter Slack bot token (xoxb-...)",
+            validate: (value) => (value?.trim() ? undefined : "Required"),
+          }),
+        ).trim();
+        appToken = String(
+          await prompter.text({
+            message: "Enter Slack app token (xapp-...)",
+            validate: (value) => (value?.trim() ? undefined : "Required"),
+          }),
+        ).trim();
+      }
+    } else if (cfg.slack?.botToken && cfg.slack?.appToken) {
+      const keep = await prompter.confirm({
+        message: "Slack tokens already configured. Keep them?",
+        initialValue: true,
+      });
+      if (!keep) {
+        botToken = String(
+          await prompter.text({
+            message: "Enter Slack bot token (xoxb-...)",
+            validate: (value) => (value?.trim() ? undefined : "Required"),
+          }),
+        ).trim();
+        appToken = String(
+          await prompter.text({
+            message: "Enter Slack app token (xapp-...)",
+            validate: (value) => (value?.trim() ? undefined : "Required"),
+          }),
+        ).trim();
+      }
+    } else {
+      botToken = String(
+        await prompter.text({
+          message: "Enter Slack bot token (xoxb-...)",
+          validate: (value) => (value?.trim() ? undefined : "Required"),
+        }),
+      ).trim();
+      appToken = String(
+        await prompter.text({
+          message: "Enter Slack app token (xapp-...)",
+          validate: (value) => (value?.trim() ? undefined : "Required"),
+        }),
+      ).trim();
+    }
+
+    if (botToken && appToken) {
+      next = {
+        ...next,
+        slack: {
+          ...next.slack,
+          enabled: true,
+          botToken,
+          appToken,
+        },
+      };
+    }
+  }
+
   if (selection.includes("signal")) {
     let resolvedCliPath = signalCliPath;
     let cliDetected = signalCliDetected;
@@ -550,3 +724,4 @@ export async function setupProviders(
 
   return next;
 }
+

src/config/schema.ts

@@ -40,6 +40,7 @@ const GROUP_LABELS: Record<string, string> = {
   talk: "Talk",
   telegram: "Telegram",
   discord: "Discord",
+  slack: "Slack",
   signal: "Signal",
   imessage: "iMessage",
   whatsapp: "WhatsApp",
@@ -65,6 +66,7 @@ const GROUP_ORDER: Record<string, number> = {
   talk: 130,
   telegram: 140,
   discord: 150,
+  slack: 155,
   signal: 160,
   imessage: 170,
   whatsapp: 180,
@@ -92,6 +94,8 @@ const FIELD_LABELS: Record<string, string> = {
   "talk.apiKey": "Talk API Key",
   "telegram.botToken": "Telegram Bot Token",
   "discord.token": "Discord Bot Token",
+  "slack.botToken": "Slack Bot Token",
+  "slack.appToken": "Slack App Token",
   "signal.account": "Signal Account",
   "imessage.cliPath": "iMessage CLI Path",
 };

src/config/types.ts

@@ -144,6 +144,7 @@ export type HookMappingConfig = {
     | "whatsapp"
     | "telegram"
     | "discord"
+    | "slack"
     | "signal"
     | "imessage";
   to?: string;
@@ -290,6 +291,64 @@ export type DiscordConfig = {
   guilds?: Record<string, DiscordGuildEntry>;
 };
 
+export type SlackDmConfig = {
+  /** If false, ignore all incoming Slack DMs. Default: true. */
+  enabled?: boolean;
+  /** Allowlist for DM senders (ids). */
+  allowFrom?: Array<string | number>;
+  /** If true, allow group DMs (default: false). */
+  groupEnabled?: boolean;
+  /** Optional allowlist for group DM channels (ids or slugs). */
+  groupChannels?: Array<string | number>;
+};
+
+export type SlackChannelConfig = {
+  allow?: boolean;
+  requireMention?: boolean;
+};
+
+export type SlackReactionNotificationMode = "off" | "own" | "all" | "allowlist";
+
+export type SlackActionConfig = {
+  reactions?: boolean;
+  messages?: boolean;
+  pins?: boolean;
+  search?: boolean;
+  permissions?: boolean;
+  memberInfo?: boolean;
+  channelInfo?: boolean;
+  emojiList?: boolean;
+};
+
+export type SlackSlashCommandConfig = {
+  /** Enable handling for the configured slash command (default: false). */
+  enabled?: boolean;
+  /** Slash command name (default: "clawd"). */
+  name?: string;
+  /** Session key prefix for slash commands (default: "slack:slash"). */
+  sessionPrefix?: string;
+  /** Reply ephemerally (default: true). */
+  ephemeral?: boolean;
+};
+
+export type SlackConfig = {
+  /** If false, do not start the Slack provider. Default: true. */
+  enabled?: boolean;
+  botToken?: string;
+  appToken?: string;
+  textChunkLimit?: number;
+  replyToMode?: ReplyToMode;
+  mediaMaxMb?: number;
+  /** Reaction notification mode (off|own|all|allowlist). Default: own. */
+  reactionNotifications?: SlackReactionNotificationMode;
+  /** Allowlist for reaction notifications when mode is allowlist. */
+  reactionAllowlist?: Array<string | number>;
+  actions?: SlackActionConfig;
+  slashCommand?: SlackSlashCommandConfig;
+  dm?: SlackDmConfig;
+  channels?: Record<string, SlackChannelConfig>;
+};
+
 export type SignalConfig = {
   /** If false, do not start the Signal provider. Default: true. */
   enabled?: boolean;
@@ -356,6 +415,7 @@ export type QueueModeBySurface = {
   whatsapp?: QueueMode;
   telegram?: QueueMode;
   discord?: QueueMode;
+  slack?: QueueMode;
   signal?: QueueMode;
   imessage?: QueueMode;
   webchat?: QueueMode;
@@ -642,6 +702,7 @@ export type ClawdisConfig = {
         | "whatsapp"
         | "telegram"
         | "discord"
+        | "slack"
         | "signal"
         | "imessage"
         | "none";
@@ -731,6 +792,7 @@ export type ClawdisConfig = {
   whatsapp?: WhatsAppConfig;
   telegram?: TelegramConfig;
   discord?: DiscordConfig;
+  slack?: SlackConfig;
   signal?: SignalConfig;
   imessage?: IMessageConfig;
   cron?: CronConfig;

src/config/zod-schema.ts

@@ -86,6 +86,7 @@ const QueueModeBySurfaceSchema = z
     whatsapp: QueueModeSchema.optional(),
     telegram: QueueModeSchema.optional(),
     discord: QueueModeSchema.optional(),
+    slack: QueueModeSchema.optional(),
     signal: QueueModeSchema.optional(),
     imessage: QueueModeSchema.optional(),
     webchat: QueueModeSchema.optional(),
@@ -163,6 +164,7 @@ const HeartbeatSchema = z
         z.literal("whatsapp"),
         z.literal("telegram"),
         z.literal("discord"),
+        z.literal("slack"),
         z.literal("signal"),
         z.literal("imessage"),
         z.literal("none"),
@@ -225,6 +227,7 @@ const HookMappingSchema = z
         z.literal("whatsapp"),
         z.literal("telegram"),
         z.literal("discord"),
+        z.literal("slack"),
         z.literal("signal"),
         z.literal("imessage"),
       ])
@@ -619,6 +622,59 @@ export const ClawdisSchema = z.object({
         .optional(),
     })
     .optional(),
+  slack: z
+    .object({
+      enabled: z.boolean().optional(),
+      botToken: z.string().optional(),
+      appToken: z.string().optional(),
+      textChunkLimit: z.number().int().positive().optional(),
+      replyToMode: ReplyToModeSchema.optional(),
+      mediaMaxMb: z.number().positive().optional(),
+      reactionNotifications: z
+        .enum(["off", "own", "all", "allowlist"])
+        .optional(),
+      reactionAllowlist: z.array(z.union([z.string(), z.number()])).optional(),
+      actions: z
+        .object({
+          reactions: z.boolean().optional(),
+          messages: z.boolean().optional(),
+          pins: z.boolean().optional(),
+          search: z.boolean().optional(),
+          permissions: z.boolean().optional(),
+          memberInfo: z.boolean().optional(),
+          channelInfo: z.boolean().optional(),
+          emojiList: z.boolean().optional(),
+        })
+        .optional(),
+      slashCommand: z
+        .object({
+          enabled: z.boolean().optional(),
+          name: z.string().optional(),
+          sessionPrefix: z.string().optional(),
+          ephemeral: z.boolean().optional(),
+        })
+        .optional(),
+      dm: z
+        .object({
+          enabled: z.boolean().optional(),
+          allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+          groupEnabled: z.boolean().optional(),
+          groupChannels: z.array(z.union([z.string(), z.number()])).optional(),
+        })
+        .optional(),
+      channels: z
+        .record(
+          z.string(),
+          z
+            .object({
+              allow: z.boolean().optional(),
+              requireMention: z.boolean().optional(),
+            })
+            .optional(),
+        )
+        .optional(),
+    })
+    .optional(),
   signal: z
     .object({
       enabled: z.boolean().optional(),

src/slack/actions.ts

@@ -0,0 +1,184 @@
+import { WebClient } from "@slack/web-api";
+
+import { loadConfig } from "../config/config.js";
+import { sendMessageSlack } from "./send.js";
+import { resolveSlackBotToken } from "./token.js";
+
+export type SlackActionClientOpts = {
+  token?: string;
+  client?: WebClient;
+};
+
+export type SlackMessageSummary = {
+  ts?: string;
+  text?: string;
+  user?: string;
+  thread_ts?: string;
+  reply_count?: number;
+  reactions?: Array<{
+    name?: string;
+    count?: number;
+    users?: string[];
+  }>;
+};
+
+export type SlackPin = {
+  type?: string;
+  message?: { ts?: string; text?: string };
+  file?: { id?: string; name?: string };
+};
+
+function resolveToken(explicit?: string) {
+  const cfgToken = loadConfig().slack?.botToken;
+  const token = resolveSlackBotToken(
+    explicit ?? process.env.SLACK_BOT_TOKEN ?? cfgToken ?? undefined,
+  );
+  if (!token) {
+    throw new Error(
+      "SLACK_BOT_TOKEN or slack.botToken is required for Slack actions",
+    );
+  }
+  return token;
+}
+
+function normalizeEmoji(raw: string) {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    throw new Error("Emoji is required for Slack reactions");
+  }
+  return trimmed.replace(/^:+|:+$/g, "");
+}
+
+async function getClient(opts: SlackActionClientOpts = {}) {
+  const token = resolveToken(opts.token);
+  return opts.client ?? new WebClient(token);
+}
+
+export async function reactSlackMessage(
+  channelId: string,
+  messageId: string,
+  emoji: string,
+  opts: SlackActionClientOpts = {},
+) {
+  const client = await getClient(opts);
+  await client.reactions.add({
+    channel: channelId,
+    timestamp: messageId,
+    name: normalizeEmoji(emoji),
+  });
+}
+
+export async function listSlackReactions(
+  channelId: string,
+  messageId: string,
+  opts: SlackActionClientOpts = {},
+): Promise<SlackMessageSummary["reactions"]> {
+  const client = await getClient(opts);
+  const result = await client.reactions.get({
+    channel: channelId,
+    timestamp: messageId,
+    full: true,
+  });
+  const message = result.message as SlackMessageSummary | undefined;
+  return message?.reactions ?? [];
+}
+
+export async function sendSlackMessage(
+  to: string,
+  content: string,
+  opts: SlackActionClientOpts & { mediaUrl?: string; replyTo?: string } = {},
+) {
+  return await sendMessageSlack(to, content, {
+    token: opts.token,
+    mediaUrl: opts.mediaUrl,
+    threadTs: opts.replyTo,
+    client: opts.client,
+  });
+}
+
+export async function editSlackMessage(
+  channelId: string,
+  messageId: string,
+  content: string,
+  opts: SlackActionClientOpts = {},
+) {
+  const client = await getClient(opts);
+  await client.chat.update({
+    channel: channelId,
+    ts: messageId,
+    text: content,
+  });
+}
+
+export async function deleteSlackMessage(
+  channelId: string,
+  messageId: string,
+  opts: SlackActionClientOpts = {},
+) {
+  const client = await getClient(opts);
+  await client.chat.delete({
+    channel: channelId,
+    ts: messageId,
+  });
+}
+
+export async function readSlackMessages(
+  channelId: string,
+  opts: SlackActionClientOpts & {
+    limit?: number;
+    before?: string;
+    after?: string;
+  } = {},
+): Promise<{ messages: SlackMessageSummary[]; hasMore: boolean }> {
+  const client = await getClient(opts);
+  const result = await client.conversations.history({
+    channel: channelId,
+    limit: opts.limit,
+    latest: opts.before,
+    oldest: opts.after,
+  });
+  return {
+    messages: (result.messages ?? []) as SlackMessageSummary[],
+    hasMore: Boolean(result.has_more),
+  };
+}
+
+export async function getSlackMemberInfo(
+  userId: string,
+  opts: SlackActionClientOpts = {},
+) {
+  const client = await getClient(opts);
+  return await client.users.info({ user: userId });
+}
+
+export async function listSlackEmojis(opts: SlackActionClientOpts = {}) {
+  const client = await getClient(opts);
+  return await client.emoji.list();
+}
+
+export async function pinSlackMessage(
+  channelId: string,
+  messageId: string,
+  opts: SlackActionClientOpts = {},
+) {
+  const client = await getClient(opts);
+  await client.pins.add({ channel: channelId, timestamp: messageId });
+}
+
+export async function unpinSlackMessage(
+  channelId: string,
+  messageId: string,
+  opts: SlackActionClientOpts = {},
+) {
+  const client = await getClient(opts);
+  await client.pins.remove({ channel: channelId, timestamp: messageId });
+}
+
+export async function listSlackPins(
+  channelId: string,
+  opts: SlackActionClientOpts = {},
+): Promise<SlackPin[]> {
+  const client = await getClient(opts);
+  const result = await client.pins.list({ channel: channelId });
+  return (result.items ?? []) as SlackPin[];
+}

src/slack/index.ts

@@ -0,0 +1,15 @@
+export {
+  deleteSlackMessage,
+  editSlackMessage,
+  getSlackMemberInfo,
+  listSlackEmojis,
+  listSlackPins,
+  listSlackReactions,
+  pinSlackMessage,
+  reactSlackMessage,
+  readSlackMessages,
+  sendSlackMessage,
+  unpinSlackMessage,
+} from "./actions.js";
+export { monitorSlackProvider } from "./monitor.js";
+export { sendMessageSlack } from "./send.js";