bashmkdir claude-slack-bot && cd claude-slack-bot
npm init -y
npm install @slack/bolt @anthropic-ai/sdk dotenv

envSLACK_BOT_TOKEN=xoxb-your-token-here
SLACK_SIGNING_SECRET=your-signing-secret-here
ANTHROPIC_API_KEY=sk-ant-your-key-here
PORT=3000

javascriptrequire('dotenv').config();
const { App } = require('@slack/bolt');
const Anthropic = require('@anthropic-ai/sdk');

const app = new App({
  token: process.env.SLACK_BOT_TOKEN,
  signingSecret: process.env.SLACK_SIGNING_SECRET,
});

const claude = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });

// In-memory thread context store
// Key: thread_ts, Value: array of {role, content} messages
const threadContext = new Map();
const MAX_CONTEXT_TURNS = 20;
const CONTEXT_TTL_MS = 4 * 60 * 60 * 1000; // 4 hours

// Clean up stale context entries every hour
setInterval(() => {
  const cutoff = Date.now() - CONTEXT_TTL_MS;
  for (const [key, value] of threadContext.entries()) {
    if (value.lastUpdated < cutoff) threadContext.delete(key);
  }
}, 60 * 60 * 1000);

javascriptapp.event('app_mention', async ({ event, say, client }) => {
  const threadTs = event.thread_ts || event.ts;
  const userMessage = event.text.replace(/<@[A-Z0-9]+>/g, '').trim();

  if (!userMessage) {
    await say({ text: 'What can I help you with?', thread_ts: threadTs });
    return;
  }

  // Load or initialize thread context
  let context = threadContext.get(threadTs) || { messages: [], lastUpdated: 0 };
  
  // Add current message
  context.messages.push({ role: 'user', content: userMessage });
  
  // Trim to max turns (keep most recent)
  if (context.messages.length > MAX_CONTEXT_TURNS * 2) {
    context.messages = context.messages.slice(-MAX_CONTEXT_TURNS * 2);
  }

  // Show typing indicator
  await client.reactions.add({
    channel: event.channel,
    timestamp: event.ts,
    name: 'thinking_face',
  }).catch(() => {}); // ignore if reaction fails

  try {
    const response = await callClaudeWithRetry(context.messages);
    const assistantMessage = response.content[0].text;

    // Save updated context
    context.messages.push({ role: 'assistant', content: assistantMessage });
    context.lastUpdated = Date.now();
    threadContext.set(threadTs, context);

    await say({ text: assistantMessage, thread_ts: threadTs });
  } catch (error) {
    console.error('Claude API error:', error);
    await say({
      text: '⚠️ I hit an error. Please try again in a moment.',
      thread_ts: threadTs,
    });
  } finally {
    // Remove thinking reaction
    await client.reactions.remove({
      channel: event.channel,
      timestamp: event.ts,
      name: 'thinking_face',
    }).catch(() => {});
  }
});

javascriptasync function callClaudeWithRetry(messages, maxRetries = 3) {
  let lastError;

  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      const response = await claude.messages.create({
        model: 'claude-sonnet-4-6',
        max_tokens: 1024,
        system: `You are a helpful AI assistant integrated into a Slack workspace. 
Keep responses concise and well-formatted for Slack (avoid markdown headers, 
use plain text or minimal formatting). Be direct and practical.`,
        messages,
      });
      return response;
    } catch (error) {
      lastError = error;
      
      // Retry on overload (529) or rate limit (429)
      if (error.status === 529 || error.status === 429) {
        const delay = Math.pow(2, attempt) * 1000 + Math.random() * 500;
        console.warn(`Claude API ${error.status}, retrying in ${delay}ms...`);
        await new Promise(r => setTimeout(r, delay));
        continue;
      }
      
      // Don't retry on other errors
      throw error;
    }
  }

  throw lastError;
}

javascriptapp.command('/ask', async ({ command, ack, respond }) => {
  await ack(); // Acknowledge within 3 seconds (Slack requirement)

  const question = command.text.trim();
  if (!question) {
    await respond({ text: 'Usage: `/ask your question here`', response_type: 'ephemeral' });
    return;
  }

  // Immediate response to avoid Slack timeout
  await respond({
    text: '🤔 Thinking...',
    response_type: 'in_channel',
  });

  try {
    const response = await callClaudeWithRetry([
      { role: 'user', content: question }
    ]);

    await respond({
      text: response.content[0].text,
      response_type: 'in_channel',
      replace_original: true,
    });
  } catch (error) {
    await respond({
      text: '⚠️ Error reaching Claude. Try again.',
      response_type: 'ephemeral',
      replace_original: true,
    });
  }
});

javascript(async () => {
  await app.start(process.env.PORT || 3000);
  console.log(`⚡ Claude Slack Bot running on port ${process.env.PORT || 3000}`);
})();

bashnode index.js

bashngrok http 3000

javascriptconst { createClient } = require('redis');
const redis = createClient({ url: process.env.REDIS_URL });

async function getContext(threadTs) {
  const raw = await redis.get(`thread:${threadTs}`);
  return raw ? JSON.parse(raw) : { messages: [] };
}

async function saveContext(threadTs, context) {
  await redis.setEx(`thread:${threadTs}`, 14400, JSON.stringify(context)); // 4hr TTL
}