elevenlabs-webhook-nodejs 1.0.0

package/baileys/src/services/worker-manager.js

@@ -0,0 +1,597 @@
+import { fork, execSync } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { v4 as uuidv4 } from 'uuid';
+import { config } from '../config.js';
+import logger from '../utils/logger.js';
+import * as store from './account-store.js';
+import webhookDispatcher from './webhook-dispatcher.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const WORKER_PATH = path.resolve(__dirname, '..', '..', 'worker.js');
+
+/**
+ * In-memory state for each account's worker process.
+ * @type {Map<string, {
+ *   process: ChildProcess,
+ *   status: string,
+ *   phone: string|null,
+ *   qrResolvers: Array<Function>,
+ *   connectResolvers: Array<Function>,
+ *   pendingRequests: Map<string, { resolve, reject, timer }>,
+ *   restartCount: number,
+ *   lastRestartAt: number,
+ * }>}
+ */
+const workers = new Map();
+
+// ─── Composite Chat ID Helpers ───────────────────────────
+
+/**
+ * Build a composite chat ID: '{accountId}:{jid}'
+ * Globally unique even when the same contact messages different accounts.
+ */
+export function buildChatId(accountId, jid) {
+  return `${accountId}:${jid}`;
+}
+
+/**
+ * Parse a composite chat ID back into accountId and JID.
+ */
+function parseChatId(chatId) {
+  const sep = chatId.indexOf(':');
+  if (sep === -1) throw new Error(`Invalid composite chat ID: ${chatId}`);
+  return { accountId: chatId.slice(0, sep), jid: chatId.slice(sep + 1) };
+}
+
+// ─── Public API ──────────────────────────────────────────
+
+/**
+ * Create a new WhatsApp account. Forks a worker and waits for QR.
+ * @returns {{ account_id, checkpoint?, status }}
+ */
+export async function createAccount() {
+  const accountId = uuidv4();
+  const authDir = store.ensureAccountDir(accountId);
+
+  await store.saveAccount(accountId, {
+    status: 'creating',
+    phone: null,
+    createdAt: new Date().toISOString(),
+  });
+
+  const worker = forkWorker(accountId, authDir);
+
+  // Wait for either QR or direct connection (if auth state exists)
+  const result = await Promise.race([
+    waitForQr(accountId),
+    waitForConnect(accountId),
+    timeout(config.qrTimeoutMs, 'QR timeout'),
+  ]);
+
+  if (result.type === 'qr') {
+    return {
+      account_id: accountId,
+      object: 'Account',
+      status: 'CREATION_SUCCESS',
+      checkpoint: { qrcode: result.qr },
+    };
+  }
+
+  if (result.type === 'connected') {
+    return {
+      account_id: accountId,
+      object: 'Account',
+      status: 'CREATION_SUCCESS',
+    };
+  }
+
+  // Timeout — return what we have
+  return {
+    account_id: accountId,
+    object: 'Account',
+    status: 'CREATION_SUCCESS',
+  };
+}
+
+/**
+ * Reconnect an existing account.
+ */
+export async function reconnectAccount(accountId) {
+  const account = await store.getAccount(accountId);
+  if (!account) throw new Error(`Account ${accountId} not found`);
+
+  const existing = workers.get(accountId);
+
+  // Already connected
+  if (existing?.status === 'connected') {
+    return {
+      account_id: accountId,
+      object: 'Account',
+      status: 'RECONNECT_SUCCESS',
+    };
+  }
+
+  const authDir = store.ensureAccountDir(accountId);
+  forkWorker(accountId, authDir);
+
+  const result = await Promise.race([
+    waitForQr(accountId),
+    waitForConnect(accountId),
+    timeout(config.qrTimeoutMs, 'Reconnect timeout'),
+  ]);
+
+  if (result.type === 'qr') {
+    return {
+      account_id: accountId,
+      object: 'Account',
+      status: 'RECONNECT_SUCCESS',
+      checkpoint: { qrcode: result.qr },
+    };
+  }
+
+  return {
+    account_id: accountId,
+    object: 'Account',
+    status: 'RECONNECT_SUCCESS',
+  };
+}
+
+/**
+ * Get account status in Unipile format.
+ */
+export async function getAccountStatus(accountId) {
+  const account = await store.getAccount(accountId);
+  if (!account) throw new Error(`Account ${accountId} not found`);
+
+  const worker = workers.get(accountId);
+  const status = worker?.status || 'disconnected';
+  const phone = worker?.phone || account.phone || null;
+  const unipileStatus = status === 'connected' ? 'ok' : 'error';
+
+  return {
+    sources: [{ id: accountId, status: unipileStatus }],
+    status: unipileStatus,
+    connection_params: {
+      im: { phone_number: phone },
+    },
+  };
+}
+
+/**
+ * Disconnect and remove an account.
+ */
+export async function disconnectAccount(accountId) {
+  const worker = workers.get(accountId);
+
+  if (worker?.process) {
+    try {
+      worker.process.send({ type: 'disconnect' });
+      // Give worker time to logout gracefully
+      await new Promise(resolve => setTimeout(resolve, 2_000));
+    } catch {}
+    try { worker.process.kill(); } catch {}
+  }
+
+  workers.delete(accountId);
+  await store.deleteAccount(accountId);
+  store.deleteAccountDir(accountId);
+
+  // Clean MongoDB auth state if configured
+  if (config.mongodbUri) {
+    try {
+      const { MongoClient } = await import('mongodb');
+      const client = new MongoClient(config.mongodbUri);
+      await client.connect();
+      const { deleteMongoDBAuthState } = await import('../utils/use-mongodb-auth-state.js');
+      await deleteMongoDBAuthState(client.db(), accountId);
+      await client.close();
+    } catch (err) {
+      logger.warn({ accountId, error: err.message }, 'Failed to clean MongoDB auth state');
+    }
+  }
+
+  logger.info({ accountId }, 'Account disconnected and removed');
+}
+
+/**
+ * Send a message to a chat.
+ * chatId is a composite ID: '{accountId}:{jid}' — parsed to route to the correct worker.
+ */
+export async function sendMessage(chatId, text) {
+  const { accountId, jid } = parseChatId(chatId);
+  const worker = workers.get(accountId);
+
+  if (!worker?.process) throw new Error(`No connected worker for account ${accountId}`);
+  if (worker.status !== 'connected') throw new Error(`Account ${accountId} not connected`);
+
+  return sendRequest(worker, { type: 'send', chatId: jid, text });
+}
+
+/**
+ * Forward a cached media message to another phone number.
+ * Used by the operator workflow to forward patient photos to the doctor.
+ */
+export async function forwardMedia(chatId, messageId, toPhone, caption) {
+  const { accountId } = parseChatId(chatId);
+  const worker = workers.get(accountId);
+
+  if (!worker?.process) throw new Error(`No connected worker for account ${accountId}`);
+  if (worker.status !== 'connected') throw new Error(`Account ${accountId} not connected`);
+
+  return sendRequest(worker, { type: 'forward_media', messageId, toPhone, caption });
+}
+
+/**
+ * Send a base64-encoded image to a chat.
+ */
+export async function sendImage(chatId, imageBase64, caption) {
+  const { accountId, jid } = parseChatId(chatId);
+  const worker = workers.get(accountId);
+
+  if (!worker?.process) throw new Error(`No connected worker for account ${accountId}`);
+  if (worker.status !== 'connected') throw new Error(`Account ${accountId} not connected`);
+
+  return sendRequest(worker, { type: 'send_image', chatId: jid, imageBase64, caption });
+}
+
+/**
+ * Download audio from a cached voice message.
+ */
+export async function downloadAudio(chatId, messageId) {
+  const { accountId } = parseChatId(chatId);
+  const worker = workers.get(accountId);
+
+  if (!worker?.process) throw new Error(`No connected worker for account ${accountId}`);
+  if (worker.status !== 'connected') throw new Error(`Account ${accountId} not connected`);
+
+  return sendRequest(worker, { type: 'download_audio', messageId });
+}
+
+/**
+ * Start a new chat with a phone number.
+ */
+export async function startChat(accountId, phone, text) {
+  const worker = workers.get(accountId);
+  if (!worker?.process) throw new Error(`Account ${accountId} not connected`);
+  if (worker.status !== 'connected') throw new Error('Account not connected');
+
+  return sendRequest(worker, { type: 'start_chat', phone, text });
+}
+
+/**
+ * Restore all persisted accounts on startup.
+ */
+export async function restoreAll() {
+  // Kill any orphaned worker processes left from a previous run
+  try {
+    execSync(`pkill -f "${WORKER_PATH}" 2>/dev/null || true`);
+    logger.info('Killed orphaned worker processes');
+  } catch {}
+
+  const accounts = await store.getAllAccounts();
+  const restorable = Object.entries(accounts)
+    .filter(([, a]) => a.status === 'connected' || a.status === 'disconnected')
+    .map(([id]) => id);
+
+  if (restorable.length === 0) {
+    logger.info('No restorable accounts found');
+    return;
+  }
+
+  logger.info({ count: restorable.length, total: Object.keys(accounts).length }, 'Restoring accounts');
+
+  for (const accountId of restorable) {
+    try {
+      const authDir = store.getAccountAuthDir(accountId);
+      forkWorker(accountId, authDir);
+      logger.info({ accountId }, 'Worker forked for restoration');
+    } catch (err) {
+      logger.error({ accountId, error: err.message }, 'Failed to restore account');
+    }
+  }
+}
+
+/**
+ * Gracefully shut down all workers.
+ */
+export async function shutdownAll() {
+  logger.info({ count: workers.size }, 'Shutting down all workers');
+
+  const promises = [];
+  for (const [accountId, worker] of workers.entries()) {
+    if (worker.process) {
+      promises.push(
+        new Promise(resolve => {
+          worker.process.once('exit', resolve);
+          try { worker.process.send({ type: 'shutdown' }); } catch {}
+          setTimeout(() => {
+            try { worker.process.kill(); } catch {}
+            resolve();
+          }, 3_000);
+        })
+      );
+    }
+  }
+
+  await Promise.allSettled(promises);
+  workers.clear();
+}
+
+/**
+ * Get summary of all workers for health check.
+ */
+export function getHealthInfo() {
+  const accounts = [];
+  for (const [id, w] of workers.entries()) {
+    accounts.push({ id, status: w.status, phone: w.phone });
+  }
+  return { workers: accounts.length, accounts };
+}
+
+// ─── Internal Helpers ────────────────────────────────────
+
+function forkWorker(accountId, authDir) {
+  // Kill any existing process to prevent orphan workers
+  const existing = workers.get(accountId);
+  if (existing?.process) {
+    existing.process.removeAllListeners('exit'); // prevent auto-restart race
+    try { existing.process.kill(); } catch {}
+    // Reject pending requests from the old worker
+    for (const [reqId, pending] of existing.pendingRequests.entries()) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error('Worker replaced'));
+    }
+    existing.pendingRequests.clear();
+  }
+
+  const child = fork(WORKER_PATH, [], {
+    stdio: ['pipe', 'pipe', 'pipe', 'ipc'],
+  });
+
+  const workerState = {
+    process: child,
+    status: 'starting',
+    phone: null,
+    qrResolvers: [],
+    connectResolvers: [],
+    pendingRequests: new Map(),
+    restartCount: existing?.restartCount || 0,
+    lastRestartAt: Date.now(),
+  };
+
+  workers.set(accountId, workerState);
+
+  // Pipe worker stdout/stderr
+  child.stdout?.on('data', (data) => {
+    logger.debug({ accountId, source: 'worker-stdout' }, data.toString().trim());
+  });
+  child.stderr?.on('data', (data) => {
+    logger.error({ accountId, source: 'worker-stderr' }, data.toString().trim());
+  });
+
+  // Handle IPC messages — guard against stale process
+  child.on('message', (msg) => {
+    const current = workers.get(accountId);
+    if (current?.process !== child) return;
+    handleWorkerMessage(accountId, msg);
+  });
+
+  // Handle worker exit — guard against stale process
+  child.on('exit', (code, signal) => {
+    const current = workers.get(accountId);
+    if (current?.process !== child) return;
+    logger.warn({ accountId, code, signal }, 'Worker process exited');
+    handleWorkerExit(accountId, code);
+  });
+
+  // Initialize the worker
+  child.send({ type: 'init', accountId, authDir, mongodbUri: config.mongodbUri, mediaForwardTo: config.mediaForwardTo });
+
+  return workerState;
+}
+
+function handleWorkerMessage(accountId, msg) {
+  const worker = workers.get(accountId);
+  if (!worker) return;
+
+  switch (msg.type) {
+    case 'qr':
+      worker.status = 'qr_pending';
+      for (const resolve of worker.qrResolvers) {
+        resolve({ type: 'qr', qr: msg.qr });
+      }
+      worker.qrResolvers = [];
+      break;
+
+    case 'connected':
+      worker.status = 'connected';
+      worker.phone = msg.phone;
+      worker.restartCount = 0; // Reset on successful connection
+      store.saveAccount(accountId, { status: 'connected', phone: msg.phone })
+        .catch(err => logger.error({ accountId, error: err.message }, 'Failed to save account'));
+      store.logMessage({ accountId, action: 'connection', reason: 'connected', phone: msg.phone }).catch(() => {});
+      for (const resolve of worker.connectResolvers) {
+        resolve({ type: 'connected', phone: msg.phone });
+      }
+      worker.connectResolvers = [];
+      logger.info({ accountId, phone: msg.phone }, 'Account connected');
+      break;
+
+    case 'disconnected':
+      worker.status = msg.reason?.includes('conflict') ? 'conflict' : 'disconnected';
+      store.saveAccount(accountId, { status: worker.status })
+        .catch(err => logger.error({ accountId, error: err.message }, 'Failed to save account'));
+      store.logMessage({ accountId, action: 'connection', reason: 'disconnected', detail: msg.reason, statusCode: msg.statusCode }).catch(() => {});
+      logger.warn({ accountId, reason: msg.reason, status: worker.status }, 'Account disconnected');
+      break;
+
+    case 'logged_out':
+      worker.status = 'logged_out';
+      store.saveAccount(accountId, { status: 'logged_out' })
+        .catch(err => logger.error({ accountId, error: err.message }, 'Failed to save account'));
+      store.logMessage({ accountId, action: 'connection', reason: 'logged_out' }).catch(() => {});
+      logger.warn({ accountId }, 'Account logged out');
+      break;
+
+    case 'status':
+      worker.status = msg.status;
+      break;
+
+    case 'message':
+      webhookDispatcher.dispatch(msg.payload);
+      break;
+
+    case 'reply': {
+      const pending = worker.pendingRequests.get(msg.reqId);
+      if (pending) {
+        clearTimeout(pending.timer);
+        worker.pendingRequests.delete(msg.reqId);
+        if (msg.error) {
+          pending.reject(new Error(msg.error));
+        } else {
+          pending.resolve(msg.data);
+        }
+      }
+      break;
+    }
+
+    case 'raw_message':
+      store.logRawMessage({ accountId, ...msg }).catch(() => {});
+      break;
+
+    case 'message_log':
+      store.logMessage({ accountId, ...msg }).catch(() => {});
+      if (msg.action === 'filtered') {
+        logger.debug({ accountId, reason: msg.reason, messageId: msg.messageId, remoteJid: msg.remoteJid }, 'Message filtered');
+      } else {
+        logger.info({ accountId, messageId: msg.messageId, contentType: msg.contentType, contactPhone: msg.contactPhone }, 'Message dispatched');
+      }
+      break;
+
+    case 'ready':
+      logger.info({ accountId }, 'Worker ready');
+      break;
+  }
+}
+
+async function handleWorkerExit(accountId, code) {
+  const worker = workers.get(accountId);
+  if (!worker) return;
+
+  const pendingCount = worker.pendingRequests.size;
+  store.logMessage({
+    accountId,
+    action: 'worker_exit',
+    reason: `exit_code:${code}`,
+    previousStatus: worker.status,
+    restartCount: worker.restartCount,
+    pendingRequestsLost: pendingCount,
+  }).catch(() => {});
+
+  // Reject all pending requests
+  for (const [reqId, pending] of worker.pendingRequests.entries()) {
+    clearTimeout(pending.timer);
+    pending.reject(new Error('Worker process exited'));
+  }
+  worker.pendingRequests.clear();
+
+  // Resolve waiting callers with error
+  for (const resolve of worker.qrResolvers) {
+    resolve({ type: 'error', error: 'Worker exited' });
+  }
+  worker.qrResolvers = [];
+  for (const resolve of worker.connectResolvers) {
+    resolve({ type: 'error', error: 'Worker exited' });
+  }
+  worker.connectResolvers = [];
+
+  // Don't restart if logged out or conflicting with another session
+  if (worker.status === 'logged_out' || worker.status === 'conflict') return;
+
+  // Don't restart if account was deleted
+  const account = await store.getAccount(accountId);
+  if (!account) {
+    workers.delete(accountId);
+    return;
+  }
+
+  // Auto-restart with backoff
+  worker.restartCount++;
+  if (worker.restartCount > config.workerMaxRestarts) {
+    logger.error({ accountId, restarts: worker.restartCount }, 'Max restarts exceeded, giving up');
+    worker.status = 'failed';
+    store.saveAccount(accountId, { status: 'failed' })
+      .catch(err => logger.error({ accountId, error: err.message }, 'Failed to save account'));
+    store.logMessage({ accountId, action: 'worker_failed', reason: 'max_restarts_exceeded', restartCount: worker.restartCount }).catch(() => {});
+    return;
+  }
+
+  const delay = config.workerRestartDelayMs * worker.restartCount;
+  logger.info({ accountId, attempt: worker.restartCount, delay }, 'Restarting worker');
+
+  setTimeout(() => {
+    const authDir = store.getAccountAuthDir(accountId);
+    try {
+      forkWorker(accountId, authDir);
+    } catch (err) {
+      logger.error({ accountId, error: err.message }, 'Failed to restart worker');
+    }
+  }, delay);
+}
+
+
+function sendRequest(worker, msg) {
+  return new Promise((resolve, reject) => {
+    const reqId = uuidv4();
+    const timer = setTimeout(() => {
+      worker.pendingRequests.delete(reqId);
+      store.logMessage({
+        accountId: msg.chatId || msg.phone || 'unknown',
+        action: 'send_failed',
+        reason: 'worker_request_timeout',
+        requestType: msg.type,
+        chatId: msg.chatId,
+      }).catch(() => {});
+      reject(new Error('Worker request timeout'));
+    }, 30_000);
+
+    worker.pendingRequests.set(reqId, { resolve, reject, timer });
+    worker.process.send({ ...msg, reqId });
+  });
+}
+
+function waitForQr(accountId) {
+  return new Promise((resolve) => {
+    const worker = workers.get(accountId);
+    if (worker) worker.qrResolvers.push(resolve);
+  });
+}
+
+function waitForConnect(accountId) {
+  return new Promise((resolve) => {
+    const worker = workers.get(accountId);
+    if (worker) worker.connectResolvers.push(resolve);
+  });
+}
+
+function timeout(ms, message) {
+  return new Promise((resolve) => {
+    setTimeout(() => resolve({ type: 'timeout', message }), ms);
+  });
+}
+
+export default {
+  createAccount,
+  reconnectAccount,
+  getAccountStatus,
+  disconnectAccount,
+  sendMessage,
+  forwardMedia,
+  downloadAudio,
+  sendImage,
+  startChat,
+  restoreAll,
+  shutdownAll,
+  getHealthInfo,
+};

package/baileys/src/utils/jid.js

@@ -0,0 +1,79 @@
+/**
+ * Convert a phone number to WhatsApp JID.
+ * Input: '905551234567' or '+905551234567'
+ * Output: '905551234567@s.whatsapp.net'
+ */
+export function phoneToJid(phone) {
+  return phone.replace(/[^0-9]/g, '') + '@s.whatsapp.net';
+}
+
+/**
+ * Extract phone number from JID.
+ * Input: '905551234567@s.whatsapp.net'
+ * Output: '+905551234567'
+ *
+ * Returns '' for LID JIDs (@lid) — these should be resolved
+ * to phone-based JIDs via lidMapping before reaching here.
+ */
+export function jidToPhone(jid) {
+  if (!jid) return '';
+  if (jid.endsWith('@lid')) return '';
+  const num = jid.split('@')[0].split(':')[0];
+  return '+' + num;
+}
+
+/**
+ * Extract phone number from sock.user.id.
+ * Input: '905551234567:5@s.whatsapp.net'
+ * Output: '+905551234567'
+ */
+export function phoneFromSockUser(id) {
+  if (!id) return '';
+  return '+' + id.split(':')[0].split('@')[0];
+}
+
+/**
+ * Extract text from a Baileys message object.
+ * Handles plain text, extended text, captions, button responses.
+ */
+export function extractText(msg) {
+  const m = msg.message;
+  if (!m) return null;
+  return m.conversation
+    || m.extendedTextMessage?.text
+    || m.imageMessage?.caption
+    || m.videoMessage?.caption
+    || m.documentMessage?.caption
+    || m.buttonsResponseMessage?.selectedDisplayText
+    || m.listResponseMessage?.title
+    || m.templateButtonReplyMessage?.selectedDisplayText
+    || null;
+}
+
+/**
+ * Media placeholder matching Unipile's format.
+ * The main app replaces this with a Turkish-friendly message.
+ */
+export const MEDIA_PLACEHOLDER = '-- Unipile cannot display this type of message yet';
+
+/**
+ * Human-readable descriptions per media content type.
+ * Sent as message text so the AI agent knows what the user sent.
+ */
+export const MEDIA_TYPE_LABELS = {
+  imageMessage:              '[Kullanıcı fotoğraf gönderdi]',
+  videoMessage:              '[Kullanıcı video gönderdi]',
+  audioMessage:              '[Kullanıcı sesli mesaj gönderdi]',
+  documentMessage:           '[Kullanıcı dosya gönderdi]',
+  stickerMessage:            '[Kullanıcı çıkartma gönderdi]',
+  contactMessage:            '[Kullanıcı rehber kartı gönderdi]',
+  contactsArrayMessage:      '[Kullanıcı rehber kartları gönderdi]',
+  locationMessage:           '[Kullanıcı konum gönderdi]',
+  liveLocationMessage:       '[Kullanıcı canlı konum gönderdi]',
+  pollCreationMessage:       '[Kullanıcı anket gönderdi]',
+  pollCreationMessageV3:     '[Kullanıcı anket gönderdi]',
+  orderMessage:              '[Kullanıcı sipariş gönderdi]',
+  productMessage:            '[Kullanıcı ürün gönderdi]',
+  albumMessage:              '[Kullanıcı albüm gönderdi]',
+  stickerPackMessage:        '[Kullanıcı çıkartma paketi gönderdi]',
+};

package/baileys/src/utils/logger.js

@@ -0,0 +1,16 @@
+import pino from 'pino';
+import { config } from '../config.js';
+
+const logger = pino({
+  level: config.logLevel,
+  transport: {
+    target: 'pino-pretty',
+    options: {
+      colorize: true,
+      translateTime: 'HH:MM:ss',
+      ignore: 'pid,hostname',
+    },
+  },
+});
+
+export default logger;