How to Integrate Replit with Webex by Cisco

1// check-webex-secrets.js
2const required = ['WEBEX_BOT_TOKEN'];
3for (const key of required) {
4  if (!process.env[key]) {
5    throw new Error(`Missing: ${key}. Add it in Replit Secrets (lock icon 🔒).`);
6  }
7}
8// Quick verification call to get bot info
9fetch('https://webexapis.com/v1/people/me', {
10  headers: { 'Authorization': `Bearer ${process.env.WEBEX_BOT_TOKEN}` }
11})
12  .then(r => r.json())
13  .then(d => {
14    if (d.displayName) {
15      console.log(`Authenticated as: ${d.displayName} (${d.emails?.[0]})`);
16      console.log('Bot type:', d.type);  // 'bot' for bots, 'person' for personal tokens
17    } else {
18      console.error('Authentication failed:', JSON.stringify(d));
19    }
20  })
21  .catch(err => console.error('Connection error:', err.message));

1// webex-messages.js — Send messages to Webex spaces
2const TOKEN = process.env.WEBEX_BOT_TOKEN;
3const ROOM_ID = process.env.WEBEX_ROOM_ID;
4const BASE_URL = 'https://webexapis.com/v1';
5
6async function webexRequest(method, endpoint, body = null) {
7  const options = {
8    method,
9    headers: {
10      'Authorization': `Bearer ${TOKEN}`,
11      'Content-Type': 'application/json',
12      'Accept': 'application/json'
13    }
14  };
15  if (body) options.body = JSON.stringify(body);
16
17  const response = await fetch(`${BASE_URL}${endpoint}`, options);
18  if (!response.ok) {
19    const errText = await response.text();
20    throw new Error(`Webex API ${response.status}: ${errText}`);
21  }
22  if (response.status === 204) return null;
23  return response.json();
24}
25
26// Send a plain text message to a room
27async function sendMessage(text, roomId = ROOM_ID) {
28  const message = await webexRequest('POST', '/messages', {
29    roomId,
30    text
31  });
32  console.log('Message sent:', message.id);
33  return message;
34}
35
36// Send a markdown-formatted message
37async function sendMarkdownMessage(markdown, roomId = ROOM_ID) {
38  return webexRequest('POST', '/messages', {
39    roomId,
40    markdown  // Supports **bold**, _italic_, ## headers, - lists, [links](url)
41  });
42}
43
44// Send a direct message to a person by email
45async function sendDirectMessage(toEmail, text) {
46  return webexRequest('POST', '/messages', {
47    toPersonEmail: toEmail,
48    text
49  });
50}
51
52// List all spaces the bot is in
53async function getRooms() {
54  const result = await webexRequest('GET', '/rooms');
55  return result?.items || [];
56}
57
58// Get details of a specific room
59async function getRoomDetails(roomId) {
60  return webexRequest('GET', `/rooms/${roomId}`);
61}
62
63// Example: send a deployment notification
64(async () => {
65  try {
66    // List rooms first to find the right room ID
67    const rooms = await getRooms();
68    console.log('Available spaces:');
69    rooms.forEach(r => console.log(` - ${r.id}: ${r.title}`));
70
71    // Send a notification
72    if (ROOM_ID) {
73      await sendMarkdownMessage(
74        '## Deployment Complete ✓\n\n' +
75        '**Service:** API Server\n' +
76        '**Version:** v2.1.0\n' +
77        '**Status:** Success\n' +
78        '**Duration:** 45 seconds'
79      );
80      console.log('Notification sent!');
81    }
82  } catch (err) {
83    console.error('Error:', err.message);
84  }
85})();
86
87module.exports = { sendMessage, sendMarkdownMessage, sendDirectMessage, getRooms, webexRequest };

1# webex_client.py — Webex REST API client for Replit (Python)
2import os
3import requests
4from datetime import datetime, timedelta, timezone
5
6TOKEN = os.environ['WEBEX_BOT_TOKEN']
7ROOM_ID = os.environ.get('WEBEX_ROOM_ID', '')
8BASE_URL = 'https://webexapis.com/v1'
9HEADERS = {
10    'Authorization': f'Bearer {TOKEN}',
11    'Content-Type': 'application/json'
12}
13
14def webex_request(method: str, endpoint: str, body: dict = None) -> dict:
15    """Make an authenticated Webex API request."""
16    response = requests.request(method, f'{BASE_URL}{endpoint}', headers=HEADERS, json=body)
17    response.raise_for_status()
18    if response.status_code == 204:
19        return {}
20    return response.json()
21
22def send_message(text: str, room_id: str = None, markdown: str = None) -> dict:
23    """Send a text or markdown message to a Webex space."""
24    rid = room_id or ROOM_ID
25    if not rid:
26        raise ValueError('room_id required. Set WEBEX_ROOM_ID in Replit Secrets or pass room_id parameter.')
27    body = {'roomId': rid}
28    if markdown:
29        body['markdown'] = markdown
30    else:
31        body['text'] = text
32    return webex_request('POST', '/messages', body)
33
34def send_direct_message(to_email: str, text: str) -> dict:
35    """Send a direct message to a person by their Webex email."""
36    return webex_request('POST', '/messages', {'toPersonEmail': to_email, 'text': text})
37
38def create_meeting(
39    title: str,
40    start: datetime,
41    end: datetime,
42    password: str = None,
43    invitee_emails: list = None
44) -> dict:
45    """Create a Webex meeting and return the meeting details including join URL."""
46    body = {
47        'title': title,
48        'start': start.isoformat(),
49        'end': end.isoformat(),
50        'enabledAutoRecordMeeting': False,
51        'allowAnyUserToBeCoHost': False
52    }
53    if password:
54        body['password'] = password
55    if invitee_emails:
56        body['invitees'] = [{'email': e} for e in invitee_emails]
57
58    meeting = webex_request('POST', '/meetings', body)
59    return {
60        'id': meeting.get('id'),
61        'title': meeting.get('title'),
62        'joinUrl': meeting.get('webLink'),
63        'sipAddress': meeting.get('sipAddress'),
64        'password': meeting.get('password'),
65        'start': meeting.get('start')
66    }
67
68def get_rooms() -> list:
69    """List all spaces the bot or user is a member of."""
70    result = webex_request('GET', '/rooms')
71    return result.get('items', [])
72
73if __name__ == '__main__':
74    # List rooms
75    rooms = get_rooms()
76    print(f'Member of {len(rooms)} spaces:')
77    for r in rooms[:5]:
78        print(f'  {r["id"]}: {r["title"]}')
79
80    # Create a test meeting in 1 hour
81    now = datetime.now(timezone.utc)
82    meeting = create_meeting(
83        title='Team Sync',
84        start=now + timedelta(hours=1),
85        end=now + timedelta(hours=2),
86        password='MeetingPass123',
87        invitee_emails=['colleague@example.com']
88    )
89    print(f'\nMeeting created: {meeting["title"]}')
90    print(f'Join URL: {meeting["joinUrl"]}')
91    print(f'Password: {meeting["password"]}')

1// webex-bot.js — Webex Bot with webhook event handling
2const express = require('express');
3const crypto = require('crypto');
4const { sendMessage, webexRequest } = require('./webex-messages');
5const app = express();
6app.use(express.json());
7
8const TOKEN = process.env.WEBEX_BOT_TOKEN;
9const WEBHOOK_SECRET = process.env.WEBEX_WEBHOOK_SECRET || '';
10
11// Verify Webex webhook signature
12function verifySignature(rawBody, signature) {
13  if (!WEBHOOK_SECRET) return true; // Skip in dev (add secret for production)
14  const hmac = crypto.createHmac('sha1', WEBHOOK_SECRET);
15  hmac.update(JSON.stringify(rawBody));
16  const expected = hmac.digest('hex');
17  return signature === expected;
18}
19
20// Get the full message content (webhooks only include message ID)
21async function fetchMessage(messageId) {
22  return webexRequest('GET', `/messages/${messageId}`);
23}
24
25// Route: receive Webex webhook events
26app.post('/webex/webhook', async (req, res) => {
27  const signature = req.headers['x-spark-signature'];
28  if (!verifySignature(req.body, signature)) {
29    return res.status(401).json({ error: 'Invalid signature' });
30  }
31
32  // Respond 200 immediately — Webex retries if no response within 15 seconds
33  res.status(200).json({ received: true });
34
35  // Process event asynchronously
36  setImmediate(async () => {
37    try {
38      const { resource, event, data } = req.body;
39      console.log(`Webex event: ${resource}.${event}`);
40
41      if (resource === 'messages' && event === 'created') {
42        // Fetch the full message content
43        const message = await fetchMessage(data.id);
44
45        // Ignore messages sent by the bot itself (prevent infinite loops)
46        const botInfo = await webexRequest('GET', '/people/me');
47        if (message.personId === botInfo.id) return;
48
49        const text = (message.text || '').trim();
50        const roomId = message.roomId;
51        console.log(`Message in ${roomId}: ${text}`);
52
53        // Command routing
54        const lower = text.toLowerCase();
55        if (lower.includes('help') || lower === 'help') {
56          await sendMessage(
57            'Available commands:\n• **status** — get system status\n• **report** — get latest report\n• **help** — show this help message',
58            roomId  // Markdown
59          );
60        } else if (lower.includes('status')) {
61          await sendMessage(`**System Status** ✓\n\nAll systems operational.\nLast check: ${new Date().toUTCString()}`, roomId);
62        } else if (lower.includes('report')) {
63          // TODO: fetch actual report data
64          await sendMessage('Generating report... Please wait.', roomId);
65        } else {
66          // Default: echo the message as a demo
67          await sendMessage(`I received your message: "${text}". Type **help** for available commands.`, roomId);
68        }
69      }
70    } catch (err) {
71      console.error('Webhook processing error:', err.message);
72    }
73  });
74});
75
76// Register webhook (run once to set up)
77async function registerWebhook(deployedUrl) {
78  try {
79    const existing = await webexRequest('GET', '/webhooks');
80    const items = existing?.items || [];
81    if (items.some(w => w.targetUrl === `${deployedUrl}/webex/webhook`)) {
82      console.log('Webhook already registered.');
83      return;
84    }
85    const webhook = await webexRequest('POST', '/webhooks', {
86      name: 'Replit Bot Webhook',
87      targetUrl: `${deployedUrl}/webex/webhook`,
88      resource: 'messages',
89      event: 'created',
90      secret: WEBHOOK_SECRET
91    });
92    console.log('Webhook registered:', webhook.id);
93  } catch (err) {
94    console.error('Webhook registration failed:', err.message);
95  }
96}
97
98app.listen(3000, '0.0.0.0', () => {
99  console.log('Webex Bot server running on port 3000');
100  // registerWebhook('https://yourapp.replit.app'); // Uncomment after deploying
101});