How to Integrate Replit with Smooch (now Zendesk Sunshine Conversations)

1# Python — install required packages
2# Run in Replit Shell:
3# pip install requests pyjwt flask
4# Or add to requirements.txt:
5# requests>=2.28.0
6# PyJWT>=2.8.0
7# flask>=2.3.0
8
9# For Node.js:
10# npm install express axios jsonwebtoken
11
12# Verify PyJWT is installed
13try:
14    import jwt
15    print(f'PyJWT version: {jwt.__version__}')
16except ImportError:
17    print('Run: pip install PyJWT')

1// Node.js — JWT generation utility (jwt-utils.js)
2const jwt = require('jsonwebtoken');
3
4const KEY_ID = process.env.SMOOCH_KEY_ID;
5const KEY_SECRET = process.env.SMOOCH_KEY_SECRET;
6
7function generateAppToken() {
8  if (!KEY_ID || !KEY_SECRET) {
9    throw new Error('SMOOCH_KEY_ID and SMOOCH_KEY_SECRET must be set in Replit Secrets (lock icon 🔒)');
10  }
11  const payload = { scope: 'app' };
12  const options = {
13    header: { alg: 'HS256', typ: 'JWT', kid: KEY_ID },
14    expiresIn: '1h'
15  };
16  return jwt.sign(payload, KEY_SECRET, options);
17}
18
19function getAuthHeaders() {
20  return { Authorization: `Bearer ${generateAppToken()}` };
21}
22
23module.exports = { generateAppToken, getAuthHeaders };
24
25// Test JWT generation
26try {
27  const token = generateAppToken();
28  console.log(`JWT generated successfully (${token.length} chars)`);
29  const decoded = jwt.decode(token, { complete: true });
30  console.log('Header:', JSON.stringify(decoded.header));
31  console.log('Payload scope:', decoded.payload.scope);
32} catch (err) {
33  console.error('JWT generation failed:', err.message);
34}

1# Python — send messages via Sunshine Conversations (send_message.py)
2import requests
3import jwt
4import time
5import os
6
7APP_ID = os.environ['SMOOCH_APP_ID']
8KEY_ID = os.environ['SMOOCH_KEY_ID']
9KEY_SECRET = os.environ['SMOOCH_KEY_SECRET']
10BASE_URL = 'https://api.smooch.io/v2'
11
12def generate_jwt():
13    payload = {'scope': 'app', 'iat': int(time.time())}
14    headers_extra = {'kid': KEY_ID}
15    return jwt.encode(payload, KEY_SECRET, algorithm='HS256', headers=headers_extra)
16
17def get_headers():
18    return {'Authorization': f'Bearer {generate_jwt()}', 'Content-Type': 'application/json'}
19
20def get_or_create_user(external_id):
21    """Get or create a Sunshine Conversations user by external ID."""
22    resp = requests.post(
23        f'{BASE_URL}/apps/{APP_ID}/users',
24        json={'externalId': external_id},
25        headers=get_headers()
26    )
27    return resp.json().get('user', {})
28
29def get_user_conversation(user_id):
30    """Get the default conversation for a user."""
31    resp = requests.get(
32        f'{BASE_URL}/apps/{APP_ID}/conversations',
33        params={'filter[userId]': user_id},
34        headers=get_headers()
35    )
36    convos = resp.json().get('conversations', [])
37    if convos:
38        return convos[0]['id']
39    # Create a conversation if none exists
40    create_resp = requests.post(
41        f'{BASE_URL}/apps/{APP_ID}/conversations',
42        json={'type': 'personal', 'participants': [{'userId': user_id}]},
43        headers=get_headers()
44    )
45    return create_resp.json().get('conversation', {}).get('id')
46
47def send_text_message(external_user_id, text):
48    """Send a text message to a user by their external ID."""
49    user = get_or_create_user(external_user_id)
50    user_id = user.get('id')
51    convo_id = get_user_conversation(user_id)
52    payload = {
53        'author': {'type': 'business'},
54        'content': {'type': 'text', 'text': text}
55    }
56    resp = requests.post(
57        f'{BASE_URL}/apps/{APP_ID}/conversations/{convo_id}/messages',
58        json=payload,
59        headers=get_headers()
60    )
61    result = resp.json()
62    print(f'Message sent: {result.get("messages", [{}])[0].get("id", "unknown")}')
63    return result
64
65# Send a test message
66send_text_message('test-user-001', 'Hello from Replit! This is a test message.')

1// Node.js — Sunshine Conversations webhook handler (webhook.js)
2const express = require('express');
3const crypto = require('crypto');
4
5const app = express();
6
7// Use raw body for signature verification
8app.use(express.json());
9
10const WEBHOOK_SECRET = process.env.SMOOCH_WEBHOOK_SECRET;
11const APP_ID = process.env.SMOOCH_APP_ID;
12
13function verifyWebhookSignature(req) {
14  if (!WEBHOOK_SECRET) return true; // Skip verification if no secret configured
15  const receivedKey = req.headers['x-api-key'];
16  return receivedKey === WEBHOOK_SECRET;
17}
18
19app.post('/webhook', (req, res) => {
20  // Verify webhook authenticity
21  if (!verifyWebhookSignature(req)) {
22    console.error('Invalid webhook signature');
23    return res.status(401).json({ error: 'Invalid signature' });
24  }
25
26  const payload = req.body;
27  const appId = payload.app?.id;
28
29  if (appId !== APP_ID) {
30    return res.status(400).json({ error: 'App ID mismatch' });
31  }
32
33  // Always respond 200 first, then process
34  res.json({ received: true });
35
36  const events = payload.events || [];
37  for (const event of events) {
38    const type = event.type;
39    console.log(`Event: ${type}`);
40
41    if (type === 'conversation:message') {
42      const msg = event.payload?.message;
43      const author = event.payload?.conversation;
44      if (msg?.author?.type === 'user') {
45        const text = msg.content?.text || '[non-text message]';
46        const channel = msg.source?.type || 'unknown';
47        console.log(`Incoming [${channel}]: ${text}`);
48        // Add routing logic here
49      }
50    }
51  }
52});
53
54app.listen(3000, '0.0.0.0', () => console.log('Sunshine Conversations webhook server running'));

1# Python — multi-channel message router with deduplication (router.py)
2from flask import Flask, request, jsonify
3import os
4
5app = Flask(__name__)
6
7WEBHOOK_SECRET = os.environ.get('SMOOCH_WEBHOOK_SECRET', '')
8processed_ids = set()  # In production, use Redis for persistence
9
10CHANNEL_HANDLERS = {
11    'whatsapp': lambda text: f'[WhatsApp template response for: {text[:50]}]',
12    'sms': lambda text: text[:160],  # SMS length limit
13    'messenger': lambda text: text,
14    'web': lambda text: text,
15}
16
17@app.route('/webhook', methods=['POST'])
18def webhook():
19    # Verify webhook secret
20    if WEBHOOK_SECRET and request.headers.get('x-api-key') != WEBHOOK_SECRET:
21        return jsonify({'error': 'Unauthorized'}), 401
22
23    payload = request.get_json()
24    res = jsonify({'received': True}), 200  # Respond immediately
25
26    events = payload.get('events', [])
27    for event in events:
28        event_id = event.get('id', '')
29        if event_id in processed_ids:
30            print(f'Skipping duplicate event: {event_id}')
31            continue
32        processed_ids.add(event_id)
33
34        if event.get('type') == 'conversation:message':
35            msg = event.get('payload', {}).get('message', {})
36            if msg.get('author', {}).get('type') == 'user':
37                channel = msg.get('source', {}).get('type', 'unknown')
38                text = msg.get('content', {}).get('text', '')
39                handler = CHANNEL_HANDLERS.get(channel, lambda t: t)
40                formatted = handler(text)
41                print(f'[{channel}] Received: {text}')
42                print(f'[{channel}] Would send: {formatted}')
43                # Call send_text_message(user_id, formatted) here
44
45    return res
46
47if __name__ == '__main__':
48    app.run(host='0.0.0.0', port=3000)