natureco-cli 2.23.28 → 2.23.30

package/src/commands/gateway-server.js

@@ -4,13 +4,12 @@ const path = require('path');
 const os = require('os');
 const { spawn, execSync } = require('child_process');
 const pino = require('pino');
+const { loadBaileys } = require('../utils/baileys');
+const { ApiError } = require('../utils/errors');
 
 const PID_FILE = path.join(os.homedir(), '.natureco', 'gateway.pid');
 const LOG_FILE = path.join(os.homedir(), '.natureco', 'gateway.log');
 
-// WhatsApp imports
-let makeWASocket, useMultiFileAuthState, DisconnectReason, fetchLatestBaileysVersion, Browsers;
-
 // Silent logger for Baileys
 const silentLogger = {
   level: 'silent',
@@ -23,18 +22,6 @@ const silentLogger = {
   child: () => silentLogger
 };
 
-// Lazy load Baileys
-function loadBaileys() {
-  if (!makeWASocket) {
-    const baileys = require('@whiskeysockets/baileys');
-    makeWASocket = baileys.default;
-    useMultiFileAuthState = baileys.useMultiFileAuthState;
-    DisconnectReason = baileys.DisconnectReason;
-    fetchLatestBaileysVersion = baileys.fetchLatestBaileysVersion;
-    Browsers = baileys.Browsers;
-  }
-}
-
 // Create Baileys logger — real pino in worker mode, silent otherwise
 let _baileysLogger = null;
 function getBaileysLogger() {
@@ -151,7 +138,8 @@ async function startGateway() {
 
 async function runGatewayWorker() {
   // This runs in the background
-  log('gateway', 'Starting NatureCo Gateway v2.11.3...', 'green');
+  const pkg = require('../../package.json');
+  log('gateway', `Starting NatureCo Gateway v${pkg.version}...`, 'green');
   
   // Load config
   const { getConfig } = require('../utils/config');
@@ -165,6 +153,7 @@ async function runGatewayWorker() {
   // Store provider instances globally for HTTP endpoint
   global.whatsappSock = null;
   global.telegramBot = null;
+  global.signalProvider = null;
   
   // Start WhatsApp if configured
   if (config.whatsappConnected && config.whatsappBotId) {
@@ -188,6 +177,55 @@ async function runGatewayWorker() {
   } else {
     log('telegram', 'not configured, skipping', 'gray');
   }
+
+  // Start Signal if configured
+  if (config.signalBotId && config.signalHttpUrl) {
+    log('signal', `starting provider (${config.signalAccount || config.signalHttpUrl})`, 'cyan');
+    startSignalProvider(config);
+  } else if (config.signalBotId) {
+    log('signal', 'not configured (no HTTP URL), skipping', 'gray');
+  } else {
+    log('signal', 'not configured, skipping', 'gray');
+  }
+  // Start IRC if configured
+  if (config.ircBotId && config.ircHost && config.ircNick) {
+    log('irc', `connecting to ${config.ircNick} @ ${config.ircHost}:${config.ircPort}`, 'cyan');
+    startIrcProvider(config);
+  } else if (config.ircBotId) {
+    log('irc', 'not configured (missing host or nick), skipping', 'gray');
+  } else {
+    log('irc', 'not configured, skipping', 'gray');
+  }
+  // Start Mattermost if configured
+  if (config.mattermostBotId && config.mattermostBaseUrl && config.mattermostToken) {
+    log('mattermost', `connecting to ${config.mattermostBaseUrl}`, 'cyan');
+    startMattermostProvider(config);
+  } else if (config.mattermostBotId) {
+    log('mattermost', 'not configured (missing URL or token), skipping', 'gray');
+  } else {
+    log('mattermost', 'not configured, skipping', 'gray');
+  }
+  // Start iMessage if configured
+  if (config.imessageBotId) {
+    if (process.platform === 'darwin') {
+      log('imessage', 'starting provider (macOS)', 'cyan');
+      startImessageProvider(config);
+    } else {
+      log('imessage', 'macOS only, skipping', 'yellow');
+    }
+  } else {
+    log('imessage', 'not configured, skipping', 'gray');
+  }
+  // Start SMS provider if configured
+  if (config.smsBotId && config.smsAccountSid && config.smsAuthToken) {
+    log('sms', `starting provider (${config.smsFromNumber || 'Messaging Service'})`, 'cyan');
+    startSmsProvider(config);
+  } else if (config.smsBotId) {
+    log('sms', 'not configured (missing Account SID), skipping', 'gray');
+  } else {
+    log('sms', 'not configured, skipping', 'gray');
+  }
+  if (config.webhooks?.length) log('webhooks', `${config.webhooks.length} route(s) configured`, 'gray');
   
   // Start HTTP server for message sending
   startHttpServer();
@@ -196,33 +234,45 @@ async function runGatewayWorker() {
   startCronJobs(config);
   
   // Health check every 60 seconds
-  setInterval(() => {
-    log('gateway', 'health check: OK', 'gray');
+  setInterval(async () => {
+    const alive = fs.existsSync(PID_FILE) && (() => { try { process.kill(process.pid, 0); return true; } catch { return false; } })();
+    const wsOk = global.gatewayWs && global.gatewayWs.readyState === 1;
+    if (alive && wsOk) {
+      log('gateway', 'health check: OK', 'gray');
+    } else {
+      log('gateway', `health check: WARN (alive=${alive}, ws=${wsOk})`, 'yellow');
+    }
   }, 60000);
   
   log('gateway', 'Gateway running in background', 'green');
   
   // Handle shutdown
-  process.on('SIGINT', () => {
+  const shutdown = () => {
     log('gateway', 'Shutting down...', 'yellow');
-    if (fs.existsSync(PID_FILE)) {
-      fs.unlinkSync(PID_FILE);
+    if (global.signalProvider?.ws) {
+      try { global.signalProvider.ws.close(); } catch {}
     }
-    process.exit(0);
-  });
-  
-  process.on('SIGTERM', () => {
-    log('gateway', 'Shutting down...', 'yellow');
+    if (signalPollingInterval) {
+      clearInterval(signalPollingInterval);
+      signalPollingInterval = null;
+    }
+    stopIrcProvider();
+    stopMattermostProvider();
+    stopImessageProvider();
+    stopSmsProvider();
     if (fs.existsSync(PID_FILE)) {
       fs.unlinkSync(PID_FILE);
     }
     process.exit(0);
-  });
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
 }
 
 async function startWhatsAppProvider(sessionDir, config) {
   try {
-    loadBaileys();
+    const { makeWASocket, useMultiFileAuthState, DisconnectReason, fetchLatestBaileysVersion, Browsers } = loadBaileys();
     
     const { state, saveCreds } = await useMultiFileAuthState(sessionDir);
     const { version } = await fetchLatestBaileysVersion();
@@ -493,6 +543,976 @@ async function startTelegramProvider(config) {
   }
 }
 
+async function startSignalProvider(config) {
+  const baseUrl = config.signalHttpUrl;
+  const account = config.signalAccount;
+  const mode = config.signalApiMode || 'auto';
+
+  // Detect API mode
+  let detectedMode = mode;
+  if (mode === 'auto') {
+    try {
+      const nativeRes = await fetch(`${baseUrl}/api/v1/check`, { signal: AbortSignal.timeout(5000) });
+      if (nativeRes.ok) {
+        detectedMode = 'native';
+        log('signal', 'detected native JSON-RPC API', 'gray');
+      }
+    } catch {}
+    if (detectedMode === 'auto') {
+      try {
+        const containerRes = await fetch(`${baseUrl}/v1/about`, { signal: AbortSignal.timeout(5000) });
+        if (containerRes.ok) {
+          detectedMode = 'container';
+          log('signal', 'detected container REST API', 'gray');
+        }
+      } catch {}
+    }
+    if (detectedMode === 'auto') {
+      log('signal', 'API not reachable, will retry', 'yellow');
+    }
+  }
+
+  if (detectedMode === 'auto' || detectedMode === 'none') {
+    log('signal', 'API unreachable, will start daemon on demand', 'gray');
+    return;
+  }
+
+  global.signalProvider = { baseUrl, account, mode: detectedMode };
+
+  // Start event stream for incoming messages (native mode uses SSE)
+  if (detectedMode === 'native') {
+    startSignalEventStream(baseUrl, account, config);
+  } else if (detectedMode === 'container') {
+    startSignalWebSocket(baseUrl, account, config);
+  }
+
+  log('signal', 'provider ready', 'green');
+}
+
+async function startSignalEventStream(baseUrl, account, config) {
+  const eventsUrl = `${baseUrl}/api/v1/events?account=${encodeURIComponent(account)}`;
+
+  const connect = async () => {
+    try {
+      const response = await fetch(eventsUrl, {
+        signal: AbortSignal.timeout(300000),
+        headers: { 'Accept': 'text/event-stream' },
+      });
+
+      if (!response.ok) {
+        throw new Error(`SSE HTTP ${response.status}`);
+      }
+
+      log('signal', 'SSE event stream connected', 'cyan');
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = '';
+
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+
+        let eventType = '';
+        let eventData = '';
+
+        for (const line of lines) {
+          if (line.startsWith('event: ')) {
+            eventType = line.slice(7).trim();
+          } else if (line.startsWith('data: ')) {
+            eventData = line.slice(6).trim();
+          } else if (line === '' && eventData) {
+            processSignalEvent(eventType, eventData, config);
+            eventType = '';
+            eventData = '';
+          }
+        }
+      }
+    } catch (err) {
+      if (err.name === 'AbortError') {
+        log('signal', 'SSE stream timeout, reconnecting...', 'yellow');
+      } else {
+        log('signal', `SSE error: ${err.message}, reconnecting in 10s...`, 'yellow');
+      }
+    }
+
+    setTimeout(connect, 10000);
+  };
+
+  connect();
+}
+
+async function startSignalWebSocket(baseUrl, account, config) {
+  const wsUrl = baseUrl.replace(/^http/, 'ws') + `/v1/receive/${encodeURIComponent(account)}`;
+
+  const connect = async () => {
+    try {
+      let WebSocket;
+      try {
+        WebSocket = require('ws');
+      } catch {
+        log('signal', 'ws module not available, falling back to polling', 'yellow');
+        startSignalPolling(baseUrl, account, config);
+        return;
+      }
+
+      const ws = new WebSocket(wsUrl);
+
+      ws.on('open', () => {
+        log('signal', 'WebSocket event stream connected', 'cyan');
+      });
+
+      ws.on('message', (data) => {
+        try {
+          const envelope = JSON.parse(data.toString());
+          processSignalEnvelope(envelope, config);
+        } catch (err) {
+          log('signal', `Failed to parse WS message: ${err.message}`, 'red');
+        }
+      });
+
+      ws.on('close', (code) => {
+        log('signal', `WebSocket closed (code ${code}), reconnecting in 10s...`, 'yellow');
+        setTimeout(connect, 10000);
+      });
+
+      ws.on('error', (err) => {
+        log('signal', `WebSocket error: ${err.message}`, 'red');
+        ws.close();
+      });
+
+      global.signalProvider.ws = ws;
+
+    } catch (err) {
+      log('signal', `WebSocket failed: ${err.message}, retrying in 10s...`, 'yellow');
+      setTimeout(connect, 10000);
+    }
+  };
+
+  connect();
+}
+
+// Fallback polling for container mode when ws is not available
+let signalPollingInterval = null;
+function startSignalPolling(baseUrl, account, config) {
+  if (signalPollingInterval) return;
+  log('signal', 'starting polling fallback (30s interval)', 'gray');
+  signalPollingInterval = setInterval(async () => {
+    try {
+      const res = await fetch(`${baseUrl}/v1/receive/${encodeURIComponent(account)}`, {
+        signal: AbortSignal.timeout(15000),
+      });
+      if (res.ok) {
+        const envelopes = await res.json();
+        if (Array.isArray(envelopes)) {
+          for (const envelope of envelopes) {
+            processSignalEnvelope(envelope, config);
+          }
+        }
+      }
+    } catch {}
+  }, 30000);
+}
+
+async function processSignalEvent(eventType, eventData, config) {
+  try {
+    const data = JSON.parse(eventData);
+    if (data.envelope) {
+      processSignalEnvelope(data.envelope, config);
+    }
+  } catch (err) {
+    log('signal', `Event parse error: ${err.message}`, 'red');
+  }
+}
+
+async function processSignalEnvelope(envelope, config) {
+  try {
+    const dataMessage = envelope.dataMessage || envelope.syncMessage?.sent?.message;
+    if (!dataMessage) return;
+
+    const sender = envelope.sourceUuid || envelope.sourceNumber || envelope.sourceName;
+    if (!sender) return;
+
+    // Skip self-messages
+    if (envelope.sourceNumber === config.signalAccount) return;
+
+    const messageText = dataMessage.message || '';
+    if (!messageText.trim()) return;
+
+    log('signal', `Inbound from ${sender}: "${messageText.slice(0, 80)}"`, 'cyan');
+
+    // Check DM policy
+    const dmPolicy = config.signalDmPolicy || 'pairing';
+    if (dmPolicy === 'disabled') return;
+
+    // Get AI response
+    try {
+      const { sendMessage } = require('../utils/api');
+      const { getMemoryPrompt, extractMemoryFromMessage, addMemoryEntry } = require('../utils/memory');
+      const { getConfig } = require('../utils/config');
+      const cfg = getConfig();
+
+      const conversationId = `signal_${sender}`;
+      const botId = 'universal-provider';
+      const memoryPrompt = getMemoryPrompt(botId);
+
+      let systemPrompt = `You are a helpful Signal assistant. Keep responses concise.`;
+      if (memoryPrompt) {
+        systemPrompt += '\n\n' + memoryPrompt;
+      }
+
+      const response = await sendMessage(
+        cfg.providerApiKey || cfg.apiKey || '', botId, messageText,
+        conversationId, systemPrompt
+      );
+      const reply = response?.reply || response?.message || '';
+
+      if (reply) {
+        await sendSignalMessage(config, sender, reply);
+        log('signal', `Reply sent to ${sender} (${reply.length} chars)`, 'green');
+
+        const memoryEntries = extractMemoryFromMessage(messageText);
+        for (const entry of memoryEntries) {
+          addMemoryEntry(botId, entry.key, entry.value);
+        }
+      }
+    } catch (err) {
+      log('signal', `Response error: ${err.message}`, 'red');
+    }
+  } catch (err) {
+    log('signal', `Envelope error: ${err.message}`, 'red');
+  }
+}
+
+async function sendSignalMessage(config, recipient, message) {
+  const baseUrl = config.signalHttpUrl;
+  const account = config.signalAccount;
+  const mode = config.signalApiMode || 'auto';
+
+  if (mode === 'native' || mode === 'auto') {
+    // Try native JSON-RPC first
+    const rpcPayload = {
+      jsonrpc: '2.0',
+      method: 'send',
+      params: {
+        recipient: [recipient],
+        message,
+        account,
+      },
+      id: Date.now(),
+    };
+
+    try {
+      const res = await fetch(`${baseUrl}/api/v1/rpc`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(rpcPayload),
+        signal: AbortSignal.timeout(30000),
+      });
+      if (res.ok) return;
+    } catch {}
+  }
+
+  // Fallback to container mode
+  const containerPayload = {
+    message,
+    number: account,
+    recipients: [recipient],
+    text_mode: 'normal',
+  };
+
+  const res = await fetch(`${baseUrl}/v2/send`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(containerPayload),
+    signal: AbortSignal.timeout(30000),
+  });
+
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Signal send failed (HTTP ${res.status}): ${text.slice(0, 200)}`);
+  }
+}
+
+// IRC provider
+let ircClient = null;
+let ircReconnectTimer = null;
+
+async function startIrcProvider(config) {
+  if (ircClient) {
+    log('irc', 'already connected', 'yellow');
+    return;
+  }
+
+  const net = require('net');
+  const tls = require('tls');
+
+  const host = config.ircHost;
+  const port = config.ircPort || 6697;
+  const useTls = config.ircTls !== false;
+  const nick = config.ircNick;
+  const username = config.ircUsername || nick;
+  const realname = config.ircRealname || 'NatureCo';
+  const password = config.ircPassword || '';
+  const channels = config.ircChannels || [];
+  const nickservEnabled = config.ircNickservEnabled !== false;
+  const nickservPassword = config.ircNickservPassword || '';
+
+  let buffer = '';
+  let currentNick = nick;
+  let registered = false;
+  let quitRequested = false;
+
+  const connect = () => {
+    if (quitRequested) return;
+
+    registered = false;
+    const socket = useTls
+      ? tls.connect({ host, port, servername: host })
+      : net.createConnection({ host, port });
+
+    socket.setEncoding('utf8');
+
+    const sendRaw = (line) => {
+      socket.write(line + '\r\n');
+    };
+
+    socket.once('connect', () => {
+      log('irc', `connected to ${host}:${port}`, 'green');
+      if (password) sendRaw(`PASS ${password}`);
+      sendRaw(`NICK ${currentNick}`);
+      sendRaw(`USER ${username} 0 * :${realname}`);
+    });
+
+    socket.on('data', (chunk) => {
+      buffer += chunk;
+      const lines = buffer.split('\r\n');
+      buffer = lines.pop() || '';
+
+      for (const line of lines) {
+        if (!line.trim()) continue;
+
+        // PING handler
+        if (line.startsWith('PING ')) {
+          sendRaw('PONG ' + line.slice(5));
+          continue;
+        }
+
+        // Parse IRC message
+        const parsed = parseIrcLine(line);
+        if (!parsed) continue;
+
+        // Track nick changes
+        if (parsed.command === 'NICK' && parsed.prefixNick === currentNick) {
+          currentNick = parsed.trailing || parsed.params[0];
+        }
+
+        // Welcome — server ready
+        if (parsed.command === '001') {
+          registered = true;
+          log('irc', `registered as ${currentNick}`, 'cyan');
+
+          // NickServ auth
+          if (nickservEnabled && nickservPassword) {
+            sendRaw(`PRIVMSG NickServ :IDENTIFY ${nickservPassword}`);
+            log('irc', 'NickServ IDENTIFY sent', 'gray');
+          }
+
+          // Join channels
+          for (const ch of channels) {
+            sendRaw(`JOIN ${ch.startsWith('#') ? ch : '#' + ch}`);
+            log('irc', `joining ${ch.startsWith('#') ? ch : '#' + ch}`, 'gray');
+          }
+
+          global.ircClient = { sendRaw, isReady: () => registered };
+          continue;
+        }
+
+        // Handle PRIVMSG (incoming messages)
+        if (parsed.command === 'PRIVMSG' && registered) {
+          const senderNick = parsed.prefixNick;
+          if (senderNick === currentNick) continue; // skip self
+
+          const target = parsed.params[0];
+          const text = parsed.trailing || '';
+
+          if (!text.trim()) continue;
+
+          const isChannel = target.startsWith('#');
+          log('irc', `${isChannel ? target : senderNick}: ${text.slice(0, 100)}`, 'cyan');
+
+          // In DM or channel message with mention
+          const isDirect = !isChannel;
+          if (!isDirect && !text.toLowerCase().includes(currentNick.toLowerCase())) continue;
+
+          processIrcMessage(config, senderNick, target, text, socket);
+        }
+      }
+    });
+
+    socket.on('close', () => {
+      global.ircClient = null;
+      if (!quitRequested) {
+        log('irc', 'connection lost, reconnecting in 10s...', 'yellow');
+        ircReconnectTimer = setTimeout(connect, 10000);
+      }
+    });
+
+    socket.on('error', (err) => {
+      log('irc', `socket error: ${err.message}`, 'red');
+    });
+
+    ircClient = socket;
+  };
+
+  connect();
+}
+function parseIrcLine(line) {
+  const result = { raw: line, prefix: null, prefixNick: null, command: '', params: [], trailing: '' };
+  let rest = line;
+
+  if (rest.startsWith(':')) {
+    const spaceIdx = rest.indexOf(' ');
+    if (spaceIdx === -1) return null;
+    result.prefix = rest.slice(1, spaceIdx);
+    const bangIdx = result.prefix.indexOf('!');
+    result.prefixNick = bangIdx !== -1 ? result.prefix.slice(0, bangIdx) : result.prefix;
+    rest = rest.slice(spaceIdx + 1);
+  }
+
+  const spaceIdx = rest.indexOf(' ');
+  if (spaceIdx === -1) {
+    result.command = rest;
+    return result;
+  }
+  result.command = rest.slice(0, spaceIdx);
+  rest = rest.slice(spaceIdx + 1);
+
+  // Trailing
+  const trailIdx = rest.indexOf(' :');
+  if (trailIdx !== -1) {
+    result.trailing = rest.slice(trailIdx + 2);
+    rest = rest.slice(0, trailIdx);
+  }
+
+  result.params = rest.split(' ').filter(Boolean);
+  return result;
+}
+
+async function processIrcMessage(config, sender, target, text, socket) {
+  try {
+    const { sendMessage } = require('../utils/api');
+    const { getMemoryPrompt } = require('../utils/memory');
+    const { getConfig } = require('../utils/config');
+    const cfg = getConfig();
+
+    const conversationId = `irc_${sender}_${target}`;
+    const botId = 'universal-provider';
+    const memoryPrompt = getMemoryPrompt(botId);
+
+    let systemPrompt = `You are a helpful IRC assistant. Keep responses concise. Use IRC-friendly formatting.`;
+    if (memoryPrompt) systemPrompt += '\n\n' + memoryPrompt;
+
+    const response = await sendMessage(
+      cfg.providerApiKey || cfg.apiKey || '', botId, text,
+      conversationId, systemPrompt
+    );
+    const reply = response?.reply || response?.message || '';
+
+    if (reply) {
+      const ircTarget = target.startsWith('#') ? target : sender;
+      sendIrcMessage(socket, ircTarget, reply);
+      log('irc', `Reply sent to ${ircTarget} (${reply.length} chars)`, 'green');
+    }
+  } catch (err) {
+    log('irc', `Response error: ${err.message}`, 'red');
+  }
+}
+
+function sendIrcMessage(socket, target, text) {
+  if (!socket) return;
+  const maxLen = 400;
+  const lines = text.split('\n');
+  for (const line of lines) {
+    const cleanLine = line.replace(/\r/g, '').trim();
+    if (!cleanLine) continue;
+    if (cleanLine.length <= maxLen) {
+      socket.write(`PRIVMSG ${target} :${cleanLine}\r\n`);
+    } else {
+      const words = cleanLine.split(' ');
+      let chunk = '';
+      for (const word of words) {
+        if (chunk.length + word.length + 1 > maxLen) {
+          socket.write(`PRIVMSG ${target} :${chunk}\r\n`);
+          chunk = word;
+        } else {
+          chunk = chunk ? chunk + ' ' + word : word;
+        }
+      }
+      if (chunk) socket.write(`PRIVMSG ${target} :${chunk}\r\n`);
+    }
+  }
+}
+
+function stopIrcProvider() {
+  if (ircReconnectTimer) {
+    clearTimeout(ircReconnectTimer);
+    ircReconnectTimer = null;
+  }
+  if (ircClient) {
+    try {
+      ircClient.write('QUIT :Gateway shutting down\r\n');
+      ircClient.end();
+    } catch {}
+    ircClient = null;
+  }
+  global.ircClient = null;
+}
+
+// Mattermost provider
+let mattermostWs = null;
+let mattermostReconnectTimer = null;
+
+async function startMattermostProvider(config) {
+  const baseUrl = config.mattermostBaseUrl.replace(/\/+$/, '');
+  const token = config.mattermostToken;
+
+  // Fetch bot user info
+  try {
+    const meRes = await fetch(`${baseUrl}/api/v4/users/me`, {
+      headers: { 'Authorization': `Bearer ${token}` },
+      signal: AbortSignal.timeout(10000),
+    });
+    if (!meRes.ok) {
+      log('mattermost', `API auth failed (HTTP ${meRes.status})`, 'red');
+      return;
+    }
+    const me = await meRes.json();
+    log('mattermost', `authenticated as @${me.username} (${me.id})`, 'green');
+
+    global.mattermostProvider = { baseUrl, token, userId: me.id, username: me.username };
+
+    // Connect WebSocket for real-time events
+    connectMattermostWebSocket(baseUrl, token, config);
+
+  } catch (err) {
+    log('mattermost', `connection failed: ${err.message}`, 'red');
+  }
+}
+
+function connectMattermostWebSocket(baseUrl, token, config) {
+  const wsUrl = baseUrl.replace(/^http/, 'ws') + '/api/v4/websocket';
+
+  const connect = () => {
+    try {
+      let WebSocket;
+      try {
+        WebSocket = require('ws');
+      } catch {
+        log('mattermost', 'ws module not available', 'yellow');
+        return;
+      }
+
+      const ws = new WebSocket(wsUrl);
+
+      ws.on('open', () => {
+        log('mattermost', 'WebSocket connected', 'cyan');
+
+        // Authenticate
+        ws.send(JSON.stringify({
+          seq: 1,
+          action: 'authentication_challenge',
+          data: { token },
+        }));
+      });
+
+      ws.on('message', (data) => {
+        try {
+          const msg = JSON.parse(data.toString());
+
+          if (msg.event === 'posted') {
+            handleMattermostPost(msg.data, msg.broadcast, config);
+          } else if (msg.event === 'hello') {
+            log('mattermost', 'WebSocket authenticated', 'green');
+          } else if (msg.event === 'user_added' || msg.event === 'user_removed') {
+            // no-op
+          }
+        } catch (err) {
+          log('mattermost', `message parse error: ${err.message}`, 'red');
+        }
+      });
+
+      ws.on('close', (code) => {
+        log('mattermost', `WebSocket closed (code ${code})`, 'yellow');
+        mattermostWs = null;
+        mattermostReconnectTimer = setTimeout(connect, 10000);
+      });
+
+      ws.on('error', (err) => {
+        log('mattermost', `WebSocket error: ${err.message}`, 'red');
+        ws.close();
+      });
+
+      mattermostWs = ws;
+
+    } catch (err) {
+      log('mattermost', `WebSocket connect failed: ${err.message}`, 'red');
+      mattermostReconnectTimer = setTimeout(connect, 30000);
+    }
+  };
+
+  connect();
+}
+
+async function handleMattermostPost(data, broadcast, config) {
+  try {
+    if (!data?.post) return;
+    const post = typeof data.post === 'string' ? JSON.parse(data.post) : data.post;
+
+    // Skip bot's own messages
+    if (post.user_id === global.mattermostProvider?.userId) return;
+
+    const channelId = broadcast?.channel_id || post.channel_id;
+    if (!channelId) return;
+
+    const messageText = post.message || '';
+    if (!messageText.trim()) return;
+
+    const senderId = post.user_id;
+    log('mattermost', `Inbound from user ${senderId}: "${messageText.slice(0, 80)}"`, 'cyan');
+
+    // Skip system messages
+    if (post.props?.from_webhook) return;
+
+    // Get AI response
+    const { sendMessage } = require('../utils/api');
+    const { getMemoryPrompt } = require('../utils/memory');
+    const { getConfig } = require('../utils/config');
+    const cfg = getConfig();
+
+    const conversationId = `mattermost_${channelId}`;
+    const botId = 'universal-provider';
+    const memoryPrompt = getMemoryPrompt(botId);
+
+    let systemPrompt = `You are a helpful Mattermost assistant. Keep responses concise.`;
+    if (memoryPrompt) systemPrompt += '\n\n' + memoryPrompt;
+
+    const response = await sendMessage(
+      cfg.providerApiKey || cfg.apiKey || '', botId, messageText,
+      conversationId, systemPrompt
+    );
+    const reply = response?.reply || response?.message || '';
+
+    if (reply) {
+      await sendMattermostMessage(config, channelId, reply);
+      log('mattermost', `Reply sent to channel ${channelId} (${reply.length} chars)`, 'green');
+    }
+  } catch (err) {
+    log('mattermost', `Post error: ${err.message}`, 'red');
+  }
+}
+
+async function sendMattermostMessage(config, channelId, message) {
+  const baseUrl = config.mattermostBaseUrl.replace(/\/+$/, '');
+  const token = config.mattermostToken;
+
+  const res = await fetch(`${baseUrl}/api/v4/posts`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${token}`,
+    },
+    body: JSON.stringify({
+      channel_id: channelId,
+      message,
+    }),
+    signal: AbortSignal.timeout(15000),
+  });
+
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Mattermost send failed (HTTP ${res.status}): ${text.slice(0, 200)}`);
+  }
+}
+
+function stopMattermostProvider() {
+  if (mattermostReconnectTimer) {
+    clearTimeout(mattermostReconnectTimer);
+    mattermostReconnectTimer = null;
+  }
+  if (mattermostWs) {
+    try { mattermostWs.close(); } catch {}
+    mattermostWs = null;
+  }
+  global.mattermostProvider = null;
+}
+
+// iMessage provider
+let imessagePollInterval = null;
+let imessageLastMessageId = null;
+
+async function startImessageProvider(config) {
+  const imsgPath = config.imessageCliPath || findImsgBin();
+  if (!imsgPath || !fs.existsSync(imsgPath)) {
+    log('imessage', 'imsg binary not found, install with: brew install mbilker/imsg/imsg', 'red');
+    return;
+  }
+
+  log('imessage', `using imsg: ${imsgPath}`, 'gray');
+  global.imessageProvider = { imsgPath };
+
+  // Start polling for new messages
+  imessagePollInterval = setInterval(async () => {
+    try {
+      const result = execSync(`"${imsgPath}" messages --format json --limit 5 2>/dev/null`, {
+        encoding: 'utf-8', timeout: 10000, stdio: 'pipe',
+      });
+      const lines = result.trim().split('\n').filter(Boolean);
+      for (const line of lines) {
+        try {
+          const msg = JSON.parse(line);
+          await processImessageMessage(msg, config);
+        } catch {}
+      }
+    } catch {}
+  }, 15000);
+
+  log('imessage', 'polling started (15s interval)', 'green');
+}
+
+function findImsgBin() {
+  const config = require('../utils/config').getConfig();
+  if (config.imessageCliPath && fs.existsSync(config.imessageCliPath)) return config.imessageCliPath;
+  try {
+    const result = execSync('which imsg 2>/dev/null', { encoding: 'utf-8', timeout: 5000 });
+    const p = result.trim();
+    if (p && fs.existsSync(p)) return p;
+  } catch {}
+  return null;
+}
+
+async function processImessageMessage(msg, config) {
+  try {
+    // Deduplicate
+    if (msg.id && msg.id === imessageLastMessageId) return;
+    if (msg.id) imessageLastMessageId = msg.id;
+
+    // Skip outgoing messages (from us)
+    if (msg.is_from_me || msg.from_me) return;
+
+    const sender = msg.sender || msg.from || msg.address || '';
+    const text = msg.text || msg.message || '';
+
+    if (!text.trim() || !sender) return;
+
+    log('imessage', `Inbound from ${sender}: "${text.slice(0, 80)}"`, 'cyan');
+
+    const { sendMessage } = require('../utils/api');
+    const { getMemoryPrompt } = require('../utils/memory');
+    const { getConfig } = require('../utils/config');
+    const cfg = getConfig();
+
+    const conversationId = `imessage_${sender}`;
+    const botId = 'universal-provider';
+    const memoryPrompt = getMemoryPrompt(botId);
+
+    let systemPrompt = `You are a helpful iMessage assistant. Keep responses concise.`;
+    if (memoryPrompt) systemPrompt += '\n\n' + memoryPrompt;
+
+    const response = await sendMessage(
+      cfg.providerApiKey || cfg.apiKey || '', botId, text,
+      conversationId, systemPrompt
+    );
+    const reply = response?.reply || response?.message || '';
+
+    if (reply) {
+      execSync(`"${global.imessageProvider.imsgPath}" send --address "${sender}" --message "${reply.replace(/"/g, '\\"')}" 2>/dev/null`, {
+        timeout: 15000, stdio: 'pipe',
+      });
+      log('imessage', `Reply sent to ${sender} (${reply.length} chars)`, 'green');
+    }
+  } catch (err) {
+    log('imessage', `Message error: ${err.message}`, 'red');
+  }
+}
+
+function stopImessageProvider() {
+  if (imessagePollInterval) {
+    clearInterval(imessagePollInterval);
+    imessagePollInterval = null;
+  }
+  global.imessageProvider = null;
+}
+
+// SMS (Twilio) provider
+let smsReplayCache = new Map();
+const SMS_RATE_LIMIT_WINDOW = 60000;
+const SMS_RATE_LIMIT_MAX = 30;
+const smsRateLimitMap = new Map();
+
+async function startSmsProvider(config) {
+  log('sms', 'provider initialized for outbound sending', 'green');
+
+  if (config.smsEnableWebhook !== false) {
+    log('sms', 'webhook endpoint will be registered on HTTP server', 'gray');
+  }
+
+  global.smsProvider = {
+    accountSid: config.smsAccountSid,
+    authToken: config.smsAuthToken,
+    fromNumber: config.smsFromNumber,
+    messagingServiceSid: config.smsMessagingServiceSid || null,
+  };
+}
+
+async function sendSmsMessage(config, to, message) {
+  const accountSid = config.smsAccountSid;
+  const authToken = config.smsAuthToken;
+  const from = config.smsFromNumber;
+  const messagingServiceSid = config.smsMessagingServiceSid;
+
+  const base64Auth = Buffer.from(`${accountSid}:${authToken}`).toString('base64');
+
+  const body = new URLSearchParams();
+  if (messagingServiceSid) {
+    body.append('MessagingServiceSid', messagingServiceSid);
+  } else {
+    body.append('From', from);
+  }
+  body.append('To', to);
+  body.append('Body', message);
+
+  const res = await fetch(`https://api.twilio.com/2010-04-01/Accounts/${accountSid}/Messages.json`, {
+    method: 'POST',
+    headers: {
+      'Authorization': `Basic ${base64Auth}`,
+      'Content-Type': 'application/x-www-form-urlencoded',
+    },
+    body: body.toString(),
+    signal: AbortSignal.timeout(30000),
+  });
+
+  if (!res.ok) {
+    const text = await res.text();
+    let detail = text.slice(0, 300);
+    try {
+      const errJson = JSON.parse(text);
+      detail = errJson.message || detail;
+    } catch {}
+    throw new Error(`Twilio send failed (HTTP ${res.status}): ${detail}`);
+  }
+
+  return res.json();
+}
+
+function verifyTwilioSignature(authToken, url, params, signature) {
+  const crypto = require('crypto');
+  // Sort params by key
+  const sorted = Object.keys(params).sort();
+  const data = url + sorted.map(k => k + params[k]).join('');
+  const expected = crypto.createHmac('sha1', authToken).update(data).digest('base64');
+  try {
+    return crypto.timingSafeEqual(Buffer.from(expected), Buffer.from(signature));
+  } catch {
+    return false;
+  }
+}
+
+async function handleSmsWebhook(config, body, req) {
+  // Rate limiting
+  const ip = req.socket?.remoteAddress || 'unknown';
+  const now = Date.now();
+  const windowKey = `${ip}:${Math.floor(now / SMS_RATE_LIMIT_WINDOW)}`;
+  const count = (smsRateLimitMap.get(windowKey) || 0) + 1;
+  smsRateLimitMap.set(windowKey, count);
+  if (count > SMS_RATE_LIMIT_MAX) {
+    return { status: 429, body: { error: 'Too many requests' } };
+  }
+
+  // Replay protection
+  const messageSid = body.MessageSid || '';
+  if (messageSid && smsReplayCache.has(messageSid)) {
+    return { status: 200, body: { ok: true, cached: true } };
+  }
+  if (messageSid) {
+    smsReplayCache.set(messageSid, true);
+    setTimeout(() => smsReplayCache.delete(messageSid), 600000);
+    if (smsReplayCache.size > 10000) {
+      const keys = [...smsReplayCache.keys()].slice(0, 2000);
+      keys.forEach(k => smsReplayCache.delete(k));
+    }
+  }
+
+  // Signature validation
+  const signature = req.headers['x-twilio-signature'] || '';
+  if (signature && config.smsAuthToken) {
+    const fullUrl = `${req.headers['x-forwarded-proto'] || 'http'}://${req.headers.host}${req.url}`;
+    const params = {};
+    for (const [k, v] of Object.entries(body)) {
+      params[k] = String(v);
+    }
+    if (!verifyTwilioSignature(config.smsAuthToken, fullUrl, params, signature)) {
+      log('sms', 'invalid Twilio signature, rejecting', 'red');
+      return { status: 403, body: { error: 'Invalid signature' } };
+    }
+  }
+
+  const from = body.From || '';
+  const to = body.To || '';
+  const text = body.Body || '';
+
+  if (!from || !text.trim()) {
+    return { status: 200, body: { ok: true, ignored: true } };
+  }
+
+  log('sms', `Inbound from ${from}: "${text.slice(0, 80)}"`, 'cyan');
+
+  // Check DM policy
+  const dmPolicy = config.smsDmPolicy || 'allowlist';
+  if (dmPolicy === 'disabled') {
+    return { status: 200, body: { ok: true, ignored: true } };
+  }
+
+  // Get AI response
+  try {
+    const { sendMessage } = require('../utils/api');
+    const { getMemoryPrompt } = require('../utils/memory');
+    const { getConfig } = require('../utils/config');
+    const cfg = getConfig();
+
+    const conversationId = `sms_${from}`;
+    const botId = 'universal-provider';
+    const memoryPrompt = getMemoryPrompt(botId);
+
+    let systemPrompt = `You are a helpful SMS assistant. Keep responses concise (SMS format).`;
+    if (memoryPrompt) systemPrompt += '\n\n' + memoryPrompt;
+
+    const response = await sendMessage(
+      cfg.providerApiKey || cfg.apiKey || '', botId, text,
+      conversationId, systemPrompt
+    );
+    const reply = response?.reply || response?.message || '';
+
+    if (reply) {
+      await sendSmsMessage(config, from, reply);
+      log('sms', `Reply sent to ${from} (${reply.length} chars)`, 'green');
+    }
+  } catch (err) {
+    log('sms', `Response error: ${err.message}`, 'red');
+  }
+
+  return { status: 200, body: { ok: true } };
+}
+
+function stopSmsProvider() {
+  smsReplayCache.clear();
+  smsRateLimitMap.clear();
+  global.smsProvider = null;
+}
+
 function startHttpServer() {
   const http = require('http');
   
@@ -508,6 +1528,33 @@ function startHttpServer() {
       return;
     }
     
+    if (req.method === 'POST' && req.url === '/webhooks/sms') {
+      // Twilio SMS webhook handler
+      const { getConfig } = require('../utils/config');
+      const cfg = getConfig();
+
+      let body = '';
+      req.on('data', chunk => { body += chunk.toString(); });
+      req.on('end', async () => {
+        // Parse form-encoded body
+        const params = new URLSearchParams(body);
+        const formBody = {};
+        for (const [k, v] of params) formBody[k] = v;
+
+        // Create a mock req-like object for signature validation
+        const mockReq = {
+          url: req.url,
+          headers: req.headers,
+          socket: req.socket,
+        };
+
+        const result = await handleSmsWebhook(cfg, formBody, mockReq);
+        res.writeHead(result.status, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(result.body));
+      });
+      return;
+    }
+
     if (req.method === 'POST' && req.url === '/send') {
       let body = '';
       
@@ -563,6 +1610,65 @@ function startHttpServer() {
             res.writeHead(200, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify({ success: true, channel: 'telegram', target }));
             
+          } else if (channel === 'signal') {
+            const { getConfig } = require('../utils/config');
+            const cfg = getConfig();
+            if (!cfg.signalHttpUrl) {
+              res.writeHead(503, { 'Content-Type': 'application/json' });
+              res.end(JSON.stringify({ error: 'Signal not connected' }));
+              return;
+            }
+            await sendSignalMessage(cfg, target, message);
+            log('http', `Signal message sent to ${target}`, 'green');
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true, channel: 'signal', target }));
+          } else if (channel === 'irc') {
+            if (!global.ircClient?.isReady()) {
+              res.writeHead(503, { 'Content-Type': 'application/json' });
+              res.end(JSON.stringify({ error: 'IRC not connected' }));
+              return;
+            }
+            sendIrcMessage(ircClient, target, message);
+            log('http', `IRC message sent to ${target}`, 'green');
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true, channel: 'irc', target }));
+          } else if (channel === 'mattermost') {
+            if (!global.mattermostProvider) {
+              res.writeHead(503, { 'Content-Type': 'application/json' });
+              res.end(JSON.stringify({ error: 'Mattermost not connected' }));
+              return;
+            }
+            await sendMattermostMessage(config, target, message);
+            log('http', `Mattermost message sent to channel ${target}`, 'green');
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true, channel: 'mattermost', target }));
+          } else if (channel === 'imessage') {
+            if (!global.imessageProvider) {
+              res.writeHead(503, { 'Content-Type': 'application/json' });
+              res.end(JSON.stringify({ error: 'iMessage not connected' }));
+              return;
+            }
+            try {
+              execSync(`"${global.imessageProvider.imsgPath}" send --address "${target.replace(/"/g, '\\"')}" --message "${message.replace(/"/g, '\\"')}" 2>/dev/null`, {
+                timeout: 15000, stdio: 'pipe',
+              });
+              log('http', `iMessage sent to ${target}`, 'green');
+              res.writeHead(200, { 'Content-Type': 'application/json' });
+              res.end(JSON.stringify({ success: true, channel: 'imessage', target }));
+            } catch (sendErr) {
+              res.writeHead(500, { 'Content-Type': 'application/json' });
+              res.end(JSON.stringify({ error: `iMessage send failed: ${sendErr.message}` }));
+            }
+          } else if (channel === 'sms') {
+            if (!global.smsProvider) {
+              res.writeHead(503, { 'Content-Type': 'application/json' });
+              res.end(JSON.stringify({ error: 'SMS not connected' }));
+              return;
+            }
+            await sendSmsMessage(config, target, message);
+            log('http', `SMS sent to ${target}`, 'green');
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true, channel: 'sms', target }));
           } else {
             res.writeHead(400, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify({ error: 'Invalid channel. Use "whatsapp" or "telegram"' }));
@@ -650,7 +1756,7 @@ function startCronJobs(config) {
               
               if (!response.ok) {
                 const errorText = await response.text();
-                throw new Error(`Anthropic API error: ${response.status} - ${errorText}`);
+                throw new ApiError(`Anthropic API error: ${response.status} - ${errorText}`, response.status);
               }
               
               const data = await response.json();
@@ -674,7 +1780,7 @@ function startCronJobs(config) {
               
               if (!response.ok) {
                 const errorText = await response.text();
-                throw new Error(`Provider API error: ${response.status} - ${errorText}`);
+                throw new ApiError(`Provider API error: ${response.status} - ${errorText}`, response.status);
               }
               
               const data = await response.json();
@@ -709,6 +1815,45 @@ function startCronJobs(config) {
               
               await global.telegramBot.sendMessage(cronJob.target, reply);
               log('cron', `Sent to Telegram: ${cronJob.target}`, 'green');
+            } else if (cronJob.action === 'signal') {
+              const { getConfig } = require('../utils/config');
+              const cfg = getConfig();
+              if (!cfg.signalHttpUrl) {
+                log('cron', 'Signal not connected, skipping', 'red');
+                return;
+              }
+              await sendSignalMessage(cfg, cronJob.target, reply);
+              log('cron', `Sent to Signal: ${cronJob.target}`, 'green');
+            } else if (cronJob.action === 'irc') {
+              if (!global.ircClient?.isReady()) {
+                log('cron', 'IRC not connected, skipping', 'red');
+                return;
+              }
+              sendIrcMessage(ircClient, cronJob.target, reply);
+              log('cron', `Sent to IRC: ${cronJob.target}`, 'green');
+            } else if (cronJob.action === 'mattermost') {
+              if (!global.mattermostProvider) {
+                log('cron', 'Mattermost not connected, skipping', 'red');
+                return;
+              }
+              await sendMattermostMessage(config, cronJob.target, reply);
+              log('cron', `Sent to Mattermost: ${cronJob.target}`, 'green');
+            } else if (cronJob.action === 'imessage') {
+              if (!global.imessageProvider) {
+                log('cron', 'iMessage not connected, skipping', 'red');
+                return;
+              }
+              execSync(`"${global.imessageProvider.imsgPath}" send --address "${cronJob.target.replace(/"/g, '\\"')}" --message "${reply.replace(/"/g, '\\"')}" 2>/dev/null`, {
+                timeout: 15000, stdio: 'pipe',
+              });
+              log('cron', `Sent to iMessage: ${cronJob.target}`, 'green');
+            } else if (cronJob.action === 'sms') {
+              if (!global.smsProvider) {
+                log('cron', 'SMS not connected, skipping', 'red');
+                return;
+              }
+              await sendSmsMessage(config, cronJob.target, reply);
+              log('cron', `Sent to SMS: ${cronJob.target}`, 'green');
             }
             
           } catch (err) {