claude-phone-local 2.0.0

package/voice-app/lib/http-server.js

@@ -0,0 +1,242 @@
+/**
+ * HTTP Server for TTS Audio Delivery
+ *
+ * Express server that:
+ * 1. Serves generated TTS audio files to FreeSWITCH
+ * 2. Provides health check endpoint
+ * 3. Accepts audio uploads and returns playback URLs
+ * 4. Automatically cleans up old temporary files
+ */
+
+const express = require('express');
+const path = require('path');
+const fs = require('fs').promises;
+const debug = require('debug')('voice-app:http-server');
+const crypto = require('crypto');
+
+// Cleanup interval: every 2 minutes
+const CLEANUP_INTERVAL = 120000;
+// File max age: 10 minutes
+const FILE_MAX_AGE = 600000;
+
+/**
+ * Create HTTP Server
+ *
+ * @param {string} audioDir - Directory to serve audio files from
+ * @param {number} port - Port to listen on (default: 3000)
+ * @returns {Object} { app, server, saveAudio, getAudioUrl, close, finalize }
+ */
+function createHttpServer(audioDir, port = 3000) {
+  const app = express();
+
+  // Parse JSON bodies
+  app.use(express.json());
+
+  // Parse binary bodies for audio upload
+  app.use('/audio', express.raw({ type: 'audio/*', limit: '10mb' }));
+
+  // Serve static audio files
+  app.use('/audio-files', express.static(audioDir, {
+    setHeaders: (res, filepath) => {
+      // Set appropriate content type for audio files
+      if (filepath.endsWith('.wav')) {
+        res.setHeader('Content-Type', 'audio/wav');
+      } else if (filepath.endsWith('.mp3')) {
+        res.setHeader('Content-Type', 'audio/mpeg');
+      }
+    }
+  }));
+
+  // Serve STATIC audio files (beeps, hold music) - NOT subject to cleanup
+  app.use('/static', express.static(path.join(__dirname, '..', 'static'), {
+    setHeaders: (res, filepath) => {
+      if (filepath.endsWith('.wav')) {
+        res.setHeader('Content-Type', 'audio/wav');
+      } else if (filepath.endsWith('.mp3')) {
+        res.setHeader('Content-Type', 'audio/mpeg');
+      }
+    }
+  }));
+
+  // Health check endpoint
+  app.get('/health', (req, res) => {
+    res.json({
+      status: 'healthy',
+      timestamp: new Date().toISOString(),
+      audioDir,
+      port
+    });
+  });
+
+  // Audio upload endpoint
+  app.post("/audio", async (req, res) => {
+    try {
+      const audioBuffer = req.body;
+
+      if (!audioBuffer || audioBuffer.length === 0) {
+        return res.status(400).json({
+          error: 'No audio data provided'
+        });
+      }
+
+      // Generate unique filename
+      const filename = `audio_${Date.now()}_${crypto.randomBytes(8).toString('hex')}.wav`;
+      const filepath = path.join(audioDir, filename);
+
+      debug(`Saving audio to ${filepath} (${audioBuffer.length} bytes)`);
+
+      // Save to disk
+      await fs.writeFile(filepath, audioBuffer);
+
+      // Generate URL
+      const url = `http://localhost:${port}/audio-files/${filename}`;
+
+      debug(`Audio saved, URL: ${url}`);
+
+      res.json({
+        success: true,
+        url,
+        filename,
+        size: audioBuffer.length
+      });
+
+    } catch (error) {
+      console.error('Error saving audio:', error);
+      res.status(500).json({
+        error: 'Failed to save audio',
+        message: error.message
+      });
+    }
+  });
+
+  // NOTE: 404 and error handlers are added in finalize() AFTER additional routes
+
+  // Start server
+  const server = app.listen(port, () => {
+    debug(`HTTP server listening on port ${port}`);
+    debug(`Serving audio files from ${audioDir}`);
+  });
+
+  // Cleanup old files periodically
+  const cleanupTimer = setInterval(async () => {
+    try {
+      await cleanupOldFiles(audioDir, FILE_MAX_AGE);
+    } catch (error) {
+      console.error('Error during cleanup:', error);
+    }
+  }, CLEANUP_INTERVAL);
+
+  // Cleanup on server close
+  const originalClose = server.close.bind(server);
+  server.close = (callback) => {
+    debug('Stopping HTTP server');
+    clearInterval(cleanupTimer);
+    originalClose(callback);
+  };
+
+  /**
+   * Save audio buffer to file and return URL
+   * @param {Buffer} audioBuffer - Audio data
+   * @param {string} format - File format (wav, mp3)
+   * @returns {Promise<string>} URL to audio file
+   */
+  async function saveAudio(audioBuffer, format = 'wav') {
+    const filename = `audio_${Date.now()}_${crypto.randomBytes(8).toString('hex')}.${format}`;
+    const filepath = path.join(audioDir, filename);
+
+    debug(`Saving ${format} audio to ${filepath} (${audioBuffer.length} bytes)`);
+
+    await fs.writeFile(filepath, audioBuffer);
+
+    const url = `http://localhost:${port}/audio-files/${filename}`;
+    debug(`Audio saved, URL: ${url}`);
+
+    return url;
+  }
+
+  /**
+   * Get URL for a filename in audio directory
+   * @param {string} filename - Name of audio file
+   * @returns {string} Full URL
+   */
+  function getAudioUrl(filename) {
+    return `http://localhost:${port}/audio-files/${filename}`;
+  }
+
+  /**
+   * Finalize the Express app by adding 404 and error handlers
+   * Call this AFTER adding any additional routes
+   */
+  function finalize() {
+    // 404 handler
+    app.use((req, res) => {
+      res.status(404).json({
+        error: 'Not found',
+        path: req.path
+      });
+    });
+
+    // Error handler
+    app.use((err, req, res, next) => {
+      console.error('Server error:', err);
+      res.status(500).json({
+        error: 'Internal server error',
+        message: err.message
+      });
+    });
+
+    debug('HTTP server finalized with 404/error handlers');
+  }
+
+  return {
+    app,
+    server,
+    saveAudio,
+    getAudioUrl,
+    close: () => server.close(),
+    finalize
+  };
+}
+
+/**
+ * Cleanup files older than maxAge
+ * @param {string} directory - Directory to clean
+ * @param {number} maxAge - Max age in milliseconds
+ */
+async function cleanupOldFiles(directory, maxAge) {
+  try {
+    const files = await fs.readdir(directory);
+    const now = Date.now();
+    let deletedCount = 0;
+
+    for (const file of files) {
+      const filepath = path.join(directory, file);
+
+      try {
+        const stats = await fs.stat(filepath);
+        const age = now - stats.mtimeMs;
+
+        if (age > maxAge) {
+          debug(`Deleting old file: ${file} (age: ${Math.round(age / 1000)}s)`);
+          await fs.unlink(filepath);
+          deletedCount++;
+        }
+      } catch (error) {
+        // Skip files that can't be accessed
+        debug(`Error checking file ${file}:`, error.message);
+      }
+    }
+
+    if (deletedCount > 0) {
+      debug(`Cleanup complete: deleted ${deletedCount} old files`);
+    }
+
+  } catch (error) {
+    console.error('Error during cleanup:', error);
+  }
+}
+
+module.exports = {
+  createHttpServer,
+  cleanupOldFiles
+};

package/voice-app/lib/logger.js

@@ -0,0 +1,35 @@
+/**
+ * Simple logger module
+ * Provides consistent logging format with timestamps
+ */
+
+function formatMessage(level, message, data = {}) {
+  const timestamp = new Date().toISOString();
+  const dataStr = Object.keys(data).length > 0 ? ' ' + JSON.stringify(data) : '';
+  return `[${timestamp}] ${level.toUpperCase()} ${message}${dataStr}`;
+}
+
+function info(message, data) {
+  console.log(formatMessage('info', message, data));
+}
+
+function warn(message, data) {
+  console.warn(formatMessage('warn', message, data));
+}
+
+function error(message, data) {
+  console.error(formatMessage('error', message, data));
+}
+
+function debug(message, data) {
+  if (process.env.DEBUG) {
+    console.log(formatMessage('debug', message, data));
+  }
+}
+
+module.exports = {
+  info,
+  warn,
+  error,
+  debug
+};

package/voice-app/lib/multi-registrar.js

@@ -0,0 +1,133 @@
+/**
+ * Multi-Extension SIP Registrar
+ * Registers multiple extensions with 3CX independently
+ */
+
+class MultiRegistrar {
+  constructor(srf, baseConfig) {
+    this.srf = srf;
+    this.baseConfig = baseConfig;
+    this.registrations = new Map();
+  }
+
+  /**
+   * Register all devices from config object
+   * @param {Object} devices - Object keyed by extension with device configs
+   */
+  registerAll(devices) {
+    const extensions = Object.keys(devices);
+    console.log('[MULTI-REGISTRAR] Starting registration for ' + extensions.length + ' devices');
+    
+    for (const [extension, device] of Object.entries(devices)) {
+      this.registerDevice(device);
+    }
+  }
+
+  /**
+   * Register a single device
+   */
+  registerDevice(device) {
+    const config = {
+      extension: device.extension,
+      auth_id: device.authId,
+      password: device.password,
+      domain: this.baseConfig.domain,
+      registrar: this.baseConfig.registrar,
+      registrar_port: this.baseConfig.registrar_port,
+      expiry: this.baseConfig.expiry,
+      local_address: this.baseConfig.local_address,
+      local_port: this.baseConfig.local_port
+    };
+
+    console.log('[MULTI-REGISTRAR] Registering ' + device.name + ' (ext ' + device.extension + ')');
+    this.sendRegister(device, config);
+  }
+
+  /**
+   * Send REGISTER request for a device
+   */
+  sendRegister(device, config) {
+    const self = this;
+    const uri = 'sip:' + config.registrar + ':' + config.registrar_port + ';transport=udp';
+    // Include local_port in Contact so INVITEs come to the right port (5070 when SBC is on 5060)
+    const localPort = config.local_port || 5060;
+    const contact = 'sip:' + config.extension + '@' + config.local_address + ':' + localPort;
+
+    console.log('[MULTI-REGISTRAR] REGISTER ' + device.name + ' to ' + uri);
+    console.log('[MULTI-REGISTRAR]   Contact: ' + contact);
+
+    this.srf.request(uri, {
+      method: 'REGISTER',
+      headers: {
+        'From': '<sip:' + config.extension + '@' + config.domain + '>',
+        'To': '<sip:' + config.extension + '@' + config.domain + '>',
+        'Contact': '<' + contact + '>;expires=' + config.expiry,
+        'Expires': config.expiry,
+        'User-Agent': 'ClaudePhoneLocal-VoiceServer/1.0'
+      },
+      auth: {
+        username: config.auth_id,
+        password: config.password
+      }
+    }, function(err, req) {
+      if (err) {
+        console.error('[MULTI-REGISTRAR] ' + device.name + ' request error: ' + err.message);
+        self.scheduleRetry(device, config, 60);
+        return;
+      }
+
+      req.on('response', function(res) {
+        if (res.status === 200) {
+          console.log('[MULTI-REGISTRAR] ' + device.name + ' SUCCESS - Registered as ext ' + config.extension);
+          
+          var expiry = config.expiry;
+          var contactHeader = res.get('Contact');
+          if (contactHeader) {
+            var match = contactHeader.match(/expires=(\d+)/i);
+            if (match) expiry = parseInt(match[1], 10);
+          }
+          
+          self.registrations.set(config.extension, {
+            device: device,
+            config: config,
+            expiry: expiry,
+            registeredAt: Date.now()
+          });
+          
+          var refreshTime = Math.floor(expiry * 0.9);
+          console.log('[MULTI-REGISTRAR] ' + device.name + ' refresh in ' + refreshTime + 's');
+          self.scheduleRefresh(device, config, refreshTime);
+          
+        } else if (res.status === 401 || res.status === 407) {
+          console.log('[MULTI-REGISTRAR] ' + device.name + ' auth challenge - handled by drachtio');
+        } else {
+          console.error('[MULTI-REGISTRAR] ' + device.name + ' FAILED: ' + res.status + ' ' + res.reason);
+          self.scheduleRetry(device, config, 60);
+        }
+      });
+    });
+  }
+
+  scheduleRefresh(device, config, seconds) {
+    const self = this;
+    setTimeout(function() {
+      console.log('[MULTI-REGISTRAR] Refreshing ' + device.name);
+      self.sendRegister(device, config);
+    }, seconds * 1000);
+  }
+
+  scheduleRetry(device, config, seconds) {
+    const self = this;
+    console.log('[MULTI-REGISTRAR] ' + device.name + ' retry in ' + seconds + 's');
+    setTimeout(function() {
+      self.sendRegister(device, config);
+    }, seconds * 1000);
+  }
+
+  stop() {
+    this.registrations.clear();
+    console.log('[MULTI-REGISTRAR] Stopped all registrations');
+  }
+}
+
+module.exports = MultiRegistrar;

package/voice-app/lib/outbound-handler.js

@@ -0,0 +1,299 @@
+/**
+ * Outbound Call Handler
+ * Core logic for initiating outbound SIP calls via drachtio
+ * v2: Added voiceId support for device-specific TTS
+ *
+ * Uses Early Offer pattern:
+ * 1. Create FreeSWITCH endpoint first to get local SDP
+ * 2. Send INVITE with our SDP
+ * 3. On answer, connect the endpoint with remote SDP
+ */
+
+const { v4: uuidv4 } = require('uuid');
+const logger = require('./logger');
+const ttsService = require('./tts-service');
+
+/**
+ * Initiate an outbound call
+ *
+ * @param {Object} srf - drachtio SRF instance
+ * @param {Object} mediaServer - FreeSWITCH media server
+ * @param {Object} options - Call options
+ * @param {string} options.to - Phone number in E.164 format (+15551234567)
+ * @param {string} options.message - Message to play when answered
+ * @param {string} [options.callerId] - Caller ID (defaults to DEFAULT_CALLER_ID env var)
+ * @param {number} [options.timeoutSeconds=30] - Ring timeout in seconds
+ * @returns {Promise<Object>} { callId, dialog, endpoint }
+ */
+async function initiateOutboundCall(srf, mediaServer, options) {
+  const {
+    to,
+    message,
+    callerId,
+    timeoutSeconds = 30,
+    deviceConfig = null
+  } = options;
+
+  const callId = uuidv4();
+  const startTime = Date.now();
+
+  try {
+    logger.info('Initiating outbound call', {
+      callId,
+      to,
+      callerId,
+      timeout: timeoutSeconds
+    });
+
+    // STEP 1: Create FreeSWITCH endpoint first (Early Offer pattern)
+    logger.info('Creating FreeSWITCH endpoint', { callId });
+    const endpoint = await mediaServer.createEndpoint();
+
+    // Get local SDP from FreeSWITCH
+    const localSdp = endpoint.local.sdp;
+
+    // Format SIP URI for 3CX
+    // Remove '+' from E.164 format for SIP URI
+    // Internal extensions: dial as-is. External (E.164 with +): add 9 prefix for PSTN
+    const isExternal = to.startsWith('+');
+    // Upstream hardcoded a '9' outdial prefix for their PBX. Most systems do not
+    // use one, so it defaults to empty and is configurable.
+    const outdialPrefix = process.env.SIP_OUTDIAL_PREFIX || '';
+    const phoneNumber = isExternal ? outdialPrefix + to.replace(/^\+1?/, '') : to;
+    // Falls back to the registrar (the local SBC) rather than a hardcoded IP from
+    // someone else's network, which silently broke every outbound call.
+    const sipTrunkHost = process.env.SIP_TRUNK_HOST || process.env.SIP_REGISTRAR || '127.0.0.1';
+    const externalIp = process.env.EXTERNAL_IP || '10.70.7.81';
+    const defaultCallerId = callerId || process.env.DEFAULT_CALLER_ID || '+15551234567';
+
+    // SIP Authentication for 3CX extension registration
+    // .env defines SIP_AUTH_ID / SIP_PASSWORD; the old names here never matched,
+    // so outbound calls went out unauthenticated and 3CX rejected them.
+    const sipAuthUsername = process.env.SIP_AUTH_USERNAME || process.env.SIP_AUTH_ID;
+    const sipAuthPassword = process.env.SIP_AUTH_PASSWORD || process.env.SIP_PASSWORD;
+
+    // Without an explicit transport drachtio dials TCP, but the 3CX SBC listens on
+    // UDP 5060 - which surfaces as "Connection refused ... tcp/<sbc>:5060" and a 503.
+    const trunkTransport = process.env.SIP_TRUNK_TRANSPORT || 'udp';
+    const sipUri = 'sip:' + phoneNumber + '@' + sipTrunkHost + ';transport=' + trunkTransport;
+
+    logger.info('Dialing SIP URI', {
+      callId,
+      sipUri,
+      from: defaultCallerId,
+      hasAuth: !!(sipAuthUsername && sipAuthPassword)
+    });
+
+    // STEP 2: Create UAC (outbound call) with Early Offer
+    // Use device extension and display name if available, otherwise fall back to callerId
+    const fromExtension = deviceConfig ? deviceConfig.extension : defaultCallerId.replace('+', '');
+    const displayName = deviceConfig ? deviceConfig.name : null;
+    const fromHeader = displayName
+      ? '"' + displayName + '" <sip:' + fromExtension + '@' + sipTrunkHost + '>'
+      : '<sip:' + fromExtension + '@' + sipTrunkHost + '>';
+
+    const uacOptions = {
+      localSdp: localSdp,
+      headers: {
+        'From': fromHeader,
+        'User-Agent': 'ClaudePhoneLocal-VoiceServer/1.0',
+        'X-Call-ID': callId
+      }
+    };
+
+    // Add SIP authentication - prefer device credentials, fall back to env vars
+    const authUsername = deviceConfig ? deviceConfig.authId : sipAuthUsername;
+    const authPassword = deviceConfig ? deviceConfig.password : sipAuthPassword;
+
+    if (authUsername && authPassword) {
+      uacOptions.auth = {
+        username: authUsername,
+        password: authPassword
+      };
+      logger.info('SIP authentication enabled', {
+        callId,
+        username: authUsername,
+        device: deviceConfig ? deviceConfig.name : 'default'
+      });
+    }
+
+    let isRinging = false;
+    let callAnswered = false;
+
+    // Create the outbound call (returns dialog directly, not { uas, uac })
+    const uac = await srf.createUAC(sipUri, uacOptions, {
+      cbRequest: function(err, req) {
+        // Called when INVITE is sent
+        if (err) {
+          logger.error('INVITE send failed', { callId, error: err.message });
+        } else {
+          logger.info('INVITE sent successfully', { callId });
+        }
+      },
+      cbProvisional: function(res) {
+        // Called on provisional responses (180 Ringing, 183 Progress, etc.)
+        logger.info('Provisional response received', {
+          callId,
+          status: res.status,
+          reason: res.reason
+        });
+
+        if (res.status === 180) {
+          isRinging = true;
+          logger.info('Phone is ringing', { callId, to });
+        }
+      }
+    });
+
+    // STEP 3: Call was answered! Connect endpoint with remote SDP
+    callAnswered = true;
+    const latency = Date.now() - startTime;
+
+    logger.info('Call answered', {
+      callId,
+      to,
+      latency,
+      isRinging
+    });
+
+    // Modify endpoint with remote SDP to complete media connection
+    await endpoint.modify(uac.remote.sdp);
+
+    logger.info('Media connection established', { callId });
+
+    // Setup call cleanup on remote hangup
+    uac.on('destroy', function() {
+      logger.info('Remote party hung up', { callId });
+      if (endpoint) {
+        endpoint.destroy().catch(function(err) {
+          logger.warn('Failed to destroy endpoint on hangup', {
+            callId,
+            error: err.message
+          });
+        });
+      }
+    });
+
+    return {
+      callId,
+      dialog: uac,
+      endpoint,
+      isRinging,
+      latency
+    };
+
+  } catch (error) {
+    const latency = Date.now() - startTime;
+
+    logger.error('Outbound call failed', {
+      callId,
+      to,
+      error: error.message,
+      latency
+    });
+
+    // Handle specific SIP error codes
+    if (error.status) {
+      const status = error.status;
+      if (status === 486) {
+        throw new Error('busy');
+      } else if (status === 480 || status === 408) {
+        throw new Error('no_answer');
+      } else if (status === 404) {
+        throw new Error('not_found');
+      } else if (status === 503) {
+        throw new Error('service_unavailable');
+      } else if (status === 401 || status === 407) {
+        throw new Error('auth_failed');
+      }
+    }
+
+    throw error;
+  }
+}
+
+/**
+ * Play a TTS message to an active call
+ *
+ * @param {Object} endpoint - FreeSWITCH endpoint
+ * @param {string} message - Text to convert to speech and play
+ * @param {Object} [options] - Playback options
+ * @param {string} [options.voiceId] - ElevenLabs voice ID for device-specific voice
+ * @returns {Promise<void>}
+ */
+async function playMessage(endpoint, message, options) {
+  options = options || {};
+  var voiceId = options.voiceId || null;
+  var startTime = Date.now();
+
+  try {
+    logger.info('Generating TTS for outbound call', {
+      textLength: message.length,
+      voiceId: voiceId || 'default'
+    });
+
+    // Generate TTS audio file with optional device voice
+    var audioUrl = await ttsService.generateSpeech(message, voiceId);
+
+    logger.info('Playing TTS to caller', { audioUrl: audioUrl });
+
+    // Play the audio file via FreeSWITCH
+    await endpoint.play(audioUrl);
+
+    var duration = Date.now() - startTime;
+
+    logger.info('TTS playback completed', {
+      duration: duration,
+      audioUrl: audioUrl
+    });
+
+  } catch (error) {
+    logger.error('Failed to play message', {
+      error: error.message
+    });
+    throw error;
+  }
+}
+
+/**
+ * Hangup an active outbound call
+ *
+ * @param {Object} dialog - drachtio dialog (UAC)
+ * @param {Object} endpoint - FreeSWITCH endpoint
+ * @param {string} callId - Call UUID for logging
+ */
+async function hangupCall(dialog, endpoint, callId) {
+  logger.info('Hanging up outbound call', { callId: callId });
+
+  try {
+    // Destroy SIP dialog
+    if (dialog && !dialog.destroyed) {
+      await dialog.destroy();
+      logger.info('Dialog destroyed', { callId: callId });
+    }
+  } catch (error) {
+    logger.warn('Failed to destroy dialog', {
+      callId: callId,
+      error: error.message
+    });
+  }
+
+  try {
+    // Destroy FreeSWITCH endpoint
+    if (endpoint) {
+      await endpoint.destroy();
+      logger.info('Endpoint destroyed', { callId: callId });
+    }
+  } catch (error) {
+    logger.warn('Failed to destroy endpoint', {
+      callId: callId,
+      error: error.message
+    });
+  }
+}
+
+module.exports = {
+  initiateOutboundCall: initiateOutboundCall,
+  playMessage: playMessage,
+  hangupCall: hangupCall
+};