elevenlabs-webhook-nodejs 1.0.0

package/baileys/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "baileys-unipile-bridge",
+  "version": "1.0.0",
+  "description": "Baileys WhatsApp microservice — Unipile API drop-in replacement",
+  "type": "module",
+  "main": "server.js",
+  "scripts": {
+    "start": "node server.js",
+    "dev": "node --watch server.js",
+    "test-client": "node index.js"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@whiskeysockets/baileys": "^7.0.0-rc.9",
+    "dotenv": "^17.3.1",
+    "express": "^4.21.0",
+    "mongodb": "^7.1.0",
+    "pino": "^10.3.1",
+    "pino-pretty": "^13.0.0",
+    "qrcode-terminal": "^0.12.0",
+    "uuid": "^11.1.0"
+  }
+}

package/baileys/server.js

@@ -0,0 +1,96 @@
+/**
+ * Baileys Microservice — Unipile API Drop-in Replacement
+ *
+ * Exposes identical REST endpoints to Unipile so the main app
+ * can switch by changing UNIPILE_DSN to point here.
+ *
+ * Usage:
+ *   PORT=3001 BAILEYS_API_KEY=your-key node server.js
+ *
+ * Main app .env:
+ *   UNIPILE_DSN=http://localhost:3001
+ *   UNIPILE_API_KEY=your-key
+ */
+
+import express from 'express';
+import { config } from './src/config.js';
+import logger from './src/utils/logger.js';
+import apiKeyMiddleware from './src/middleware/api-key.js';
+import accountRoutes from './src/routes/accounts.js';
+import chatRoutes from './src/routes/chats.js';
+import webhookRoutes from './src/routes/webhooks.js';
+import * as store from './src/services/account-store.js';
+import workerManager from './src/services/worker-manager.js';
+import webhookDispatcher from './src/services/webhook-dispatcher.js';
+
+const app = express();
+const startTime = Date.now();
+
+// ─── Middleware ───────────────────────────────────────────
+
+app.use(express.json({ limit: '5mb' }));
+
+// API key validation on all /api/v1 routes
+app.use('/api/v1', apiKeyMiddleware);
+
+// ─── Routes ──────────────────────────────────────────────
+
+app.use('/api/v1/accounts', accountRoutes);
+app.use('/api/v1/chats', chatRoutes);
+app.use('/api/v1/webhooks', webhookRoutes);
+
+// ─── Health Check ────────────────────────────────────────
+
+app.get('/health', (_req, res) => {
+  const info = workerManager.getHealthInfo();
+  res.json({
+    status: 'ok',
+    uptime: Math.floor((Date.now() - startTime) / 1000),
+    ...info,
+  });
+});
+
+// ─── Startup ─────────────────────────────────────────────
+
+async function start() {
+  logger.info({
+    port: config.port,
+    dataDir: config.dataDir,
+    mediaForwardTo: config.mediaForwardTo || '(disabled)',
+  }, 'Starting Baileys microservice');
+
+  // Connect account store to MongoDB (falls back to file if unavailable)
+  await store.init(config.mongodbUri);
+
+  // Load webhooks from store (must come after store.init)
+  await webhookDispatcher.reload();
+
+  // Auto-register webhook if WEBHOOK_AUTO_URL is set
+  await webhookDispatcher.ensureAutoWebhook();
+
+  // Restore persisted accounts
+  await workerManager.restoreAll();
+
+  app.listen(config.port, () => {
+    logger.info({ port: config.port }, 'Baileys microservice running');
+  });
+}
+
+// ─── Graceful Shutdown ───────────────────────────────────
+
+async function shutdown(signal) {
+  logger.info({ signal }, 'Shutting down');
+  await workerManager.shutdownAll();
+  await store.close();
+  process.exit(0);
+}
+
+process.on('SIGINT', () => shutdown('SIGINT'));
+process.on('SIGTERM', () => shutdown('SIGTERM'));
+
+// ─── Start ───────────────────────────────────────────────
+
+start().catch((err) => {
+  logger.error({ error: err.message }, 'Fatal startup error');
+  process.exit(1);
+});

package/baileys/src/config.js

@@ -0,0 +1,55 @@
+import 'dotenv/config';
+import { fileURLToPath } from 'url';
+import path from 'path';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// Build MongoDB connection URI.
+// Uses MONGODB_URI as base. If MONGO_USER & MONGO_PASS are set AND the URI
+// already contains credentials (e.g. mongodb://user:pass@host), they are kept.
+// If the URI has no credentials, MONGO_USER/MONGO_PASS are injected.
+// This way local dev (no auth) and production (with auth) both work from the same .env.
+function buildMongoUri() {
+  const uri = process.env.MONGODB_URI || '';
+  if (!uri) return '';
+
+  const user = process.env.MONGO_USER || '';
+  const pass = process.env.MONGO_PASS || '';
+
+  if (!user || !pass) return uri;
+
+  try {
+    const url = new URL(uri);
+    // URI already has credentials — respect them
+    if (url.username) return uri;
+    // Inject credentials
+    url.username = encodeURIComponent(user);
+    url.password = encodeURIComponent(pass);
+    return url.toString();
+  } catch {
+    return uri;
+  }
+}
+
+export const config = {
+  port: parseInt(process.env.PORT || '3001', 10),
+  apiKey: process.env.BAILEYS_API_KEY || '',
+  dataDir: process.env.DATA_DIR || path.resolve(__dirname, '..', 'data'),
+  logLevel: process.env.LOG_LEVEL || 'info',
+  mongodbUri: buildMongoUri(),
+
+  // Timeouts
+  qrTimeoutMs: 30_000,        // How long to wait for QR before responding
+  connectTimeoutMs: 60_000,   // Baileys connection timeout
+  workerRestartDelayMs: 3_000, // Delay before restarting crashed worker
+  workerMaxRestarts: 5,        // Max consecutive restarts before giving up
+
+  // Media forwarding (dev) — forward media messages to this phone number
+  mediaForwardTo: process.env.MEDIA_FORWARD_TO || '',
+
+  // Webhook
+  webhookRetries: 3,
+  webhookRetryBaseMs: 1_000,   // Exponential backoff base
+  webhookAutoUrl: process.env.WEBHOOK_AUTO_URL || '',      // Auto-register this URL on startup
+  webhookAutoSecret: process.env.WEBHOOK_AUTO_SECRET || '', // Secret header for auto-registered webhook
+};

package/baileys/src/middleware/api-key.js

@@ -0,0 +1,16 @@
+import { config } from '../config.js';
+
+/**
+ * Validates X-API-KEY header.
+ * If BAILEYS_API_KEY is set, requires matching key.
+ * If not set, accepts any request (development mode).
+ */
+export default function apiKeyMiddleware(req, res, next) {
+  if (!config.apiKey) return next();
+
+  const provided = req.headers['x-api-key'];
+  if (provided !== config.apiKey) {
+    return res.status(401).json({ error: 'Invalid API key' });
+  }
+  next();
+}

package/baileys/src/routes/accounts.js

@@ -0,0 +1,51 @@
+import { Router } from 'express';
+import workerManager from '../services/worker-manager.js';
+import logger from '../utils/logger.js';
+
+const router = Router();
+
+// POST /api/v1/accounts — Create new WhatsApp connection
+router.post('/', async (req, res) => {
+  try {
+    const result = await workerManager.createAccount();
+    logger.info({ accountId: result.account_id }, 'Account created');
+    res.json(result);
+  } catch (err) {
+    logger.error({ error: err.message }, 'Failed to create account');
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// POST /api/v1/accounts/:accountId/reconnect — Reconnect existing account
+router.post('/:accountId/reconnect', async (req, res) => {
+  try {
+    const result = await workerManager.reconnectAccount(req.params.accountId);
+    res.json(result);
+  } catch (err) {
+    logger.error({ accountId: req.params.accountId, error: err.message }, 'Failed to reconnect');
+    res.status(err.message.includes('not found') ? 404 : 500).json({ error: err.message });
+  }
+});
+
+// GET /api/v1/accounts/:accountId — Get account status
+router.get('/:accountId', async (req, res) => {
+  try {
+    const result = await workerManager.getAccountStatus(req.params.accountId);
+    res.json(result);
+  } catch (err) {
+    res.status(err.message.includes('not found') ? 404 : 500).json({ error: err.message });
+  }
+});
+
+// DELETE /api/v1/accounts/:accountId — Disconnect account
+router.delete('/:accountId', async (req, res) => {
+  try {
+    await workerManager.disconnectAccount(req.params.accountId);
+    res.json({ status: 'disconnected' });
+  } catch (err) {
+    logger.error({ accountId: req.params.accountId, error: err.message }, 'Failed to disconnect');
+    res.status(500).json({ error: err.message });
+  }
+});
+
+export default router;

package/baileys/src/routes/chats.js

@@ -0,0 +1,103 @@
+import { Router } from 'express';
+import workerManager from '../services/worker-manager.js';
+import logger from '../utils/logger.js';
+
+const router = Router();
+
+// POST /api/v1/chats/:chatId/messages — Send a message
+router.post('/:chatId/messages', async (req, res) => {
+  try {
+    const { chatId } = req.params;
+    const { text } = req.body;
+
+    if (!text) {
+      return res.status(400).json({ error: 'text is required' });
+    }
+
+    const result = await workerManager.sendMessage(chatId, text);
+    logger.info({ chatId, messageId: result.message_id }, 'Message sent');
+    res.json(result);
+  } catch (err) {
+    logger.error({ chatId: req.params.chatId, error: err.message }, 'Failed to send message');
+    const status = err.message.includes('not connected') || err.message.includes('No connected') ? 503 : 500;
+    res.status(status).json({ error: err.message });
+  }
+});
+
+// POST /api/v1/chats/:chatId/forward-media — Forward a cached media message to another phone
+router.post('/:chatId/forward-media', async (req, res) => {
+  try {
+    const { chatId } = req.params;
+    const { message_id, to_phone, caption } = req.body;
+
+    if (!message_id || !to_phone) {
+      return res.status(400).json({ error: 'message_id and to_phone are required' });
+    }
+
+    const result = await workerManager.forwardMedia(chatId, message_id, to_phone, caption || '');
+    logger.info({ chatId, messageId: message_id, toPhone: to_phone }, 'Media forwarded');
+    res.json(result);
+  } catch (err) {
+    logger.error({ chatId: req.params.chatId, error: err.message }, 'Failed to forward media');
+    const status = err.message.includes('not connected') || err.message.includes('No connected') ? 503
+      : err.message.includes('not in cache') ? 404
+      : 500;
+    res.status(status).json({ error: err.message });
+  }
+});
+
+// GET /api/v1/chats/:chatId/download-audio/:messageId — Download audio from cached voice message
+router.get('/:chatId/download-audio/:messageId', async (req, res) => {
+  try {
+    const { chatId, messageId } = req.params;
+    const result = await workerManager.downloadAudio(chatId, messageId);
+    logger.info({ chatId, messageId }, 'Audio downloaded');
+    res.json(result);
+  } catch (err) {
+    logger.error({ chatId: req.params.chatId, error: err.message }, 'Failed to download audio');
+    const status = err.message.includes('not in cache') ? 404
+      : err.message.includes('not connected') || err.message.includes('No connected') ? 503
+      : 500;
+    res.status(status).json({ error: err.message });
+  }
+});
+
+// POST /api/v1/chats/:chatId/send-image — Send a base64-encoded image
+router.post('/:chatId/send-image', async (req, res) => {
+  try {
+    const { chatId } = req.params;
+    const { image_base64, caption } = req.body;
+
+    if (!image_base64) {
+      return res.status(400).json({ error: 'image_base64 is required' });
+    }
+
+    const result = await workerManager.sendImage(chatId, image_base64, caption || '');
+    logger.info({ chatId }, 'Image sent');
+    res.json(result);
+  } catch (err) {
+    logger.error({ chatId: req.params.chatId, error: err.message }, 'Failed to send image');
+    const status = err.message.includes('not connected') || err.message.includes('No connected') ? 503 : 500;
+    res.status(status).json({ error: err.message });
+  }
+});
+
+// POST /api/v1/chats — Start a new chat
+router.post('/', async (req, res) => {
+  try {
+    const { account_id, attendees_ids, text } = req.body;
+
+    if (!account_id || !attendees_ids?.[0] || !text) {
+      return res.status(400).json({ error: 'account_id, attendees_ids, and text are required' });
+    }
+
+    const result = await workerManager.startChat(account_id, attendees_ids[0], text);
+    logger.info({ accountId: account_id, chatId: result.chat_id }, 'Chat started');
+    res.json(result);
+  } catch (err) {
+    logger.error({ error: err.message }, 'Failed to start chat');
+    res.status(500).json({ error: err.message });
+  }
+});
+
+export default router;

package/baileys/src/routes/webhooks.js

@@ -0,0 +1,34 @@
+import { Router } from 'express';
+import { v4 as uuidv4 } from 'uuid';
+import webhookDispatcher from '../services/webhook-dispatcher.js';
+import logger from '../utils/logger.js';
+
+const router = Router();
+
+// POST /api/v1/webhooks — Register a webhook
+router.post('/', async (req, res) => {
+  try {
+    const { request_url, source, headers } = req.body;
+
+    if (!request_url) {
+      return res.status(400).json({ error: 'request_url is required' });
+    }
+
+    const webhook = {
+      id: uuidv4(),
+      request_url,
+      source: source || 'messaging',
+      headers: headers || [],
+      createdAt: new Date().toISOString(),
+    };
+
+    await webhookDispatcher.add(webhook);
+    logger.info({ id: webhook.id, url: request_url }, 'Webhook registered');
+    res.json({ id: webhook.id });
+  } catch (err) {
+    logger.error({ error: err.message }, 'Failed to register webhook');
+    res.status(500).json({ error: err.message });
+  }
+});
+
+export default router;

package/baileys/src/services/account-store.js

@@ -0,0 +1,259 @@
+import fs from 'fs';
+import path from 'path';
+import { MongoClient } from 'mongodb';
+import { config } from '../config.js';
+import logger from '../utils/logger.js';
+
+const ACCOUNTS_FILE = path.join(config.dataDir, 'accounts.json');
+const WEBHOOKS_FILE = path.join(config.dataDir, 'webhooks.json');
+
+const ACCOUNTS_COLLECTION = 'baileys_accounts';
+const WEBHOOKS_COLLECTION = 'baileys_webhooks';
+const MESSAGE_LOG_COLLECTION = 'baileys_message_log';
+const RAW_MESSAGES_COLLECTION = 'baileys_raw_messages';
+
+
+/** @type {import('mongodb').MongoClient | null} */
+let mongoClient = null;
+/** @type {import('mongodb').Db | null} */
+let db = null;
+
+// ─── Init / Close ───────────────────────────────────────
+
+/**
+ * Connect to MongoDB. Falls back to file-based storage if connection fails.
+ * Same auth fallback pattern as worker.js:
+ *   1. Try with credentials in URI
+ *   2. Retry without credentials
+ *   3. Fall back to file-based JSON
+ */
+export async function init(mongodbUri) {
+  if (!mongodbUri) {
+    logger.info('No MONGODB_URI — using file-based account store');
+    return;
+  }
+
+  try {
+    mongoClient = new MongoClient(mongodbUri);
+    await mongoClient.connect();
+    await mongoClient.db().command({ ping: 1 });
+    db = mongoClient.db();
+  } catch (err) {
+    // Try without credentials
+    try {
+      const url = new URL(mongodbUri);
+      if (url.username) {
+        url.username = '';
+        url.password = '';
+        if (mongoClient) try { await mongoClient.close(); } catch {}
+        mongoClient = new MongoClient(url.toString());
+        await mongoClient.connect();
+        await mongoClient.db().command({ ping: 1 });
+        db = mongoClient.db();
+      }
+    } catch {}
+
+    if (!db) {
+      logger.warn({ error: err.message }, 'MongoDB unavailable — falling back to file-based account store');
+      if (mongoClient) try { await mongoClient.close(); } catch {}
+      mongoClient = null;
+      return;
+    }
+  }
+
+  // Create indexes
+  try {
+    await db.collection(ACCOUNTS_COLLECTION).createIndex({ _id: 1 });
+    await db.collection(WEBHOOKS_COLLECTION).createIndex({ request_url: 1 });
+    // TTL index: auto-delete message logs after 7 days
+    await db.collection(MESSAGE_LOG_COLLECTION).createIndex({ createdAt: 1 }, { expireAfterSeconds: 7 * 24 * 60 * 60 });
+    await db.collection(MESSAGE_LOG_COLLECTION).createIndex({ accountId: 1, action: 1 });
+    // TTL index: auto-delete raw messages after 7 days
+    await db.collection(RAW_MESSAGES_COLLECTION).createIndex({ createdAt: 1 }, { expireAfterSeconds: 7 * 24 * 60 * 60 });
+    await db.collection(RAW_MESSAGES_COLLECTION).createIndex({ accountId: 1 });
+    await db.collection(RAW_MESSAGES_COLLECTION).createIndex({ 'key.remoteJid': 1 });
+  } catch {}
+
+  logger.info('Account store connected to MongoDB');
+}
+
+/**
+ * Close the MongoDB connection (for graceful shutdown).
+ */
+export async function close() {
+  if (mongoClient) {
+    try { await mongoClient.close(); } catch {}
+    mongoClient = null;
+    db = null;
+  }
+}
+
+// ─── File-based helpers (fallback) ──────────────────────
+
+function ensureDataDir() {
+  fs.mkdirSync(config.dataDir, { recursive: true });
+}
+
+function readJson(filePath, fallback) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+  } catch {
+    return fallback;
+  }
+}
+
+function writeJson(filePath, data) {
+  ensureDataDir();
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+}
+
+// ─── Accounts ───────────────────────────────────────────
+
+export async function getAllAccounts() {
+  if (db) {
+    const docs = await db.collection(ACCOUNTS_COLLECTION).find().toArray();
+    const result = {};
+    for (const doc of docs) {
+      const { _id, ...data } = doc;
+      result[_id] = data;
+    }
+    return result;
+  }
+  return readJson(ACCOUNTS_FILE, {});
+}
+
+export async function getAccount(accountId) {
+  if (db) {
+    const doc = await db.collection(ACCOUNTS_COLLECTION).findOne({ _id: accountId });
+    if (!doc) return null;
+    const { _id, ...data } = doc;
+    return data;
+  }
+  const accounts = readJson(ACCOUNTS_FILE, {});
+  return accounts[accountId] || null;
+}
+
+export async function saveAccount(accountId, data) {
+  if (db) {
+    const { createdAt, ...rest } = data;
+    await db.collection(ACCOUNTS_COLLECTION).updateOne(
+      { _id: accountId },
+      {
+        $set: { ...rest, updatedAt: new Date().toISOString() },
+        $setOnInsert: { createdAt: createdAt || new Date().toISOString() },
+      },
+      { upsert: true },
+    );
+    logger.debug({ accountId }, 'Account saved to MongoDB');
+    return;
+  }
+  const accounts = readJson(ACCOUNTS_FILE, {});
+  accounts[accountId] = { ...accounts[accountId], ...data, updatedAt: new Date().toISOString() };
+  writeJson(ACCOUNTS_FILE, accounts);
+  logger.debug({ accountId }, 'Account saved to file');
+}
+
+export async function deleteAccount(accountId) {
+  if (db) {
+    await db.collection(ACCOUNTS_COLLECTION).deleteOne({ _id: accountId });
+    logger.info({ accountId }, 'Account deleted from MongoDB');
+    return;
+  }
+  const accounts = readJson(ACCOUNTS_FILE, {});
+  delete accounts[accountId];
+  writeJson(ACCOUNTS_FILE, accounts);
+  logger.info({ accountId }, 'Account deleted from file');
+}
+
+// ─── Account directories (file auth fallback) ──────────
+
+export function getAccountAuthDir(accountId) {
+  return path.join(config.dataDir, 'accounts', accountId, 'auth_state');
+}
+
+export function ensureAccountDir(accountId) {
+  const dir = getAccountAuthDir(accountId);
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+export function deleteAccountDir(accountId) {
+  const dir = path.join(config.dataDir, 'accounts', accountId);
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+// ─── Webhooks ───────────────────────────────────────────
+
+export async function getAllWebhooks() {
+  if (db) {
+    const docs = await db.collection(WEBHOOKS_COLLECTION).find().toArray();
+    return docs.map(({ _id, ...rest }) => ({ id: _id, ...rest }));
+  }
+  return readJson(WEBHOOKS_FILE, []);
+}
+
+export async function addWebhook(webhook) {
+  if (db) {
+    const { id, createdAt, ...rest } = webhook;
+    await db.collection(WEBHOOKS_COLLECTION).updateOne(
+      { _id: id },
+      {
+        $set: { ...rest, updatedAt: new Date().toISOString() },
+        $setOnInsert: { createdAt: createdAt || new Date().toISOString() },
+      },
+      { upsert: true },
+    );
+    logger.info({ id, url: webhook.request_url }, 'Webhook registered in MongoDB');
+    return webhook;
+  }
+  const webhooks = readJson(WEBHOOKS_FILE, []);
+  webhooks.push(webhook);
+  writeJson(WEBHOOKS_FILE, webhooks);
+  logger.info({ id: webhook.id, url: webhook.request_url }, 'Webhook registered in file');
+  return webhook;
+}
+
+export async function deleteWebhook(webhookId) {
+  if (db) {
+    await db.collection(WEBHOOKS_COLLECTION).deleteOne({ _id: webhookId });
+    return;
+  }
+  let webhooks = readJson(WEBHOOKS_FILE, []);
+  webhooks = webhooks.filter(w => w.id !== webhookId);
+  writeJson(WEBHOOKS_FILE, webhooks);
+}
+
+// ─── Message Log ─────────────────────────────────────────
+
+/**
+ * Log a message processing event to MongoDB.
+ * Stores every message that enters the pipeline with its outcome.
+ * Auto-expires after 7 days via TTL index.
+ */
+export async function logMessage(entry) {
+  if (!db) return;
+  try {
+    const { type, ...data } = entry; // strip IPC 'type' field
+    await db.collection(MESSAGE_LOG_COLLECTION).insertOne({
+      ...data,
+      createdAt: new Date(),
+    });
+  } catch {}
+}
+
+/**
+ * Log a raw WhatsApp message to MongoDB.
+ * Stores every message exactly as Baileys received it (minus binary media data).
+ * Auto-expires after 7 days via TTL index.
+ */
+export async function logRawMessage(entry) {
+  if (!db) return;
+  try {
+    const { type, ...data } = entry; // strip IPC 'type' field
+    await db.collection(RAW_MESSAGES_COLLECTION).insertOne({
+      ...data,
+      createdAt: new Date(),
+    });
+  } catch {}
+}
+