How to Integrate Replit with Slack

1// slack.js — Reusable Slack notification module for Node.js
2const webhookUrl = process.env.SLACK_WEBHOOK_URL;
3
4if (!webhookUrl) {
5  throw new Error('SLACK_WEBHOOK_URL not set in Replit Secrets (lock icon 🔒)');
6}
7
8// Send a simple text message
9async function notify(text) {
10  const response = await fetch(webhookUrl, {
11    method: 'POST',
12    headers: { 'Content-Type': 'application/json' },
13    body: JSON.stringify({ text })
14  });
15  if (!response.ok) {
16    const error = await response.text();
17    throw new Error(`Slack webhook failed: ${error}`);
18  }
19  return true;
20}
21
22// Send a rich Block Kit message (error alert example)
23async function notifyError(errorMessage, location, details = '') {
24  const blocks = [
25    {
26      type: 'header',
27      text: { type: 'plain_text', text: ':red_circle: Error Alert', emoji: true }
28    },
29    {
30      type: 'section',
31      fields: [
32        { type: 'mrkdwn', text: `*Error:*\n${errorMessage}` },
33        { type: 'mrkdwn', text: `*Location:*\n${location}` }
34      ]
35    },
36    {
37      type: 'section',
38      text: { type: 'mrkdwn', text: `*Time:* ${new Date().toISOString()}` }
39    }
40  ];
41
42  if (details) {
43    blocks.push({
44      type: 'section',
45      text: { type: 'mrkdwn', text: `*Details:*\n\`\`\`${details}\`\`\`` }
46    });
47  }
48
49  const response = await fetch(webhookUrl, {
50    method: 'POST',
51    headers: { 'Content-Type': 'application/json' },
52    body: JSON.stringify({ blocks })
53  });
54
55  if (!response.ok) throw new Error(`Slack webhook failed: ${await response.text()}`);
56  return true;
57}
58
59module.exports = { notify, notifyError };
60
61// Usage example:
62// const { notify, notifyError } = require('./slack');
63// await notify('Deployment completed successfully!');
64// await notifyError('Database connection failed', 'db.js:42', err.stack);

1# slack_utils.py — Reusable Slack notification module for Python
2import os
3import requests
4from datetime import datetime
5
6WEBHOOK_URL = os.environ.get('SLACK_WEBHOOK_URL')
7
8if not WEBHOOK_URL:
9    raise ValueError('SLACK_WEBHOOK_URL not set in Replit Secrets (lock icon 🔒)')
10
11def notify(text: str) -> bool:
12    """Send a simple text notification to Slack."""
13    response = requests.post(
14        WEBHOOK_URL,
15        json={'text': text},
16        timeout=5
17    )
18    response.raise_for_status()
19    return True
20
21def notify_error(error_message: str, location: str, details: str = '') -> bool:
22    """Send a formatted error alert to Slack using Block Kit."""
23    blocks = [
24        {
25            'type': 'header',
26            'text': {'type': 'plain_text', 'text': ':red_circle: Error Alert', 'emoji': True}
27        },
28        {
29            'type': 'section',
30            'fields': [
31                {'type': 'mrkdwn', 'text': f'*Error:*\n{error_message}'},
32                {'type': 'mrkdwn', 'text': f'*Location:*\n{location}'}
33            ]
34        },
35        {
36            'type': 'section',
37            'text': {'type': 'mrkdwn', 'text': f'*Time:* {datetime.utcnow().isoformat()}Z'}
38        }
39    ]
40
41    if details:
42        blocks.append({
43            'type': 'section',
44            'text': {'type': 'mrkdwn', 'text': f'*Details:*\n```{details}```'}
45        })
46
47    response = requests.post(WEBHOOK_URL, json={'blocks': blocks}, timeout=5)
48    response.raise_for_status()
49    return True
50
51def notify_status(title: str, status: str, color: str = 'good') -> bool:
52    """Send a colored status notification (color: good/warning/danger)."""
53    payload = {
54        'attachments': [{
55            'color': color,
56            'title': title,
57            'text': status,
58            'footer': f'Replit App | {datetime.utcnow().strftime("%Y-%m-%d %H:%M")} UTC'
59        }]
60    }
61    response = requests.post(WEBHOOK_URL, json=payload, timeout=5)
62    response.raise_for_status()
63    return True
64
65# Usage:
66# from slack_utils import notify, notify_error, notify_status
67# notify('Background job completed: 1,432 records processed')
68# notify_error('Payment failed', 'payments.py:87', str(exception))
69# notify_status('Deploy Complete', 'v2.1.4 deployed to production', 'good')

1// bot-server.js — Slack Bot with Web API and slash commands
2const express = require('express');
3const { WebClient } = require('@slack/web-api');
4const crypto = require('crypto');
5
6const app = express();
7const slack = new WebClient(process.env.SLACK_BOT_TOKEN);
8
9// Parse raw body for signature verification
10app.use('/slack', express.raw({ type: '*/*' }));
11app.use(express.json());
12app.use(express.urlencoded({ extended: true }));
13
14// Verify Slack request signature (prevents spoofed requests)
15function verifySlackSignature(req) {
16  const signingSecret = process.env.SLACK_SIGNING_SECRET;
17  const timestamp = req.headers['x-slack-request-timestamp'];
18  const signature = req.headers['x-slack-signature'];
19  
20  // Reject requests older than 5 minutes (replay attack prevention)
21  if (Math.abs(Date.now() / 1000 - timestamp) > 300) return false;
22  
23  const body = req.body.toString();
24  const sigBase = `v0:${timestamp}:${body}`;
25  const hmac = crypto.createHmac('sha256', signingSecret)
26    .update(sigBase)
27    .digest('hex');
28  const expected = `v0=${hmac}`;
29  
30  return crypto.timingSafeEqual(Buffer.from(expected), Buffer.from(signature));
31}
32
33// Handle Slack slash commands
34app.post('/slack/commands', (req, res) => {
35  // Body is raw for signature verification
36  const body = req.body.toString();
37  const params = new URLSearchParams(body);
38  const command = params.get('command');
39  const text = params.get('text');
40  const userId = params.get('user_id');
41  const channelId = params.get('channel_id');
42
43  if (command === '/status') {
44    // Respond immediately (Slack requires < 3 second response)
45    res.json({
46      response_type: 'in_channel',
47      text: `:white_check_mark: App is running | Uptime: ${process.uptime().toFixed(0)}s | User: <@${userId}>`
48    });
49  } else {
50    res.json({ text: `Unknown command: ${command}` });
51  }
52});
53
54// Handle Slack event subscriptions (URL verification + events)
55app.post('/slack/events', (req, res) => {
56  const body = req.body;
57  
58  // URL verification challenge (sent once when you register the URL)
59  if (body.type === 'url_verification') {
60    return res.json({ challenge: body.challenge });
61  }
62  
63  // Handle app_mention event (when someone @mentions your bot)
64  if (body.event?.type === 'app_mention') {
65    const { channel, text, user } = body.event;
66    slack.chat.postMessage({
67      channel,
68      text: `Hello <@${user}>! You said: ${text}`
69    }).catch(console.error);
70  }
71  
72  res.sendStatus(200);
73});
74
75// Post a message via Bot API (programmatic, not via webhook)
76async function postMessage(channel, text) {
77  return slack.chat.postMessage({ channel, text });
78}
79
80app.listen(3000, '0.0.0.0', () => {
81  console.log('Slack bot server running on port 3000');
82});