Complete Guide to Twilio Missed Call Handling: Call Forwarding, Voicemail, and Notifications

				
					exports.handler = async function(context, event, callback) {
 console.log("Sent to voicemail");
 const twiml = new Twilio.twiml.VoiceResponse();


 // Dynamically import ky.
 let ky;
 try {
   ky = (await import('ky')).default;
 } catch (error) {
   console.error('Error importing ky:', error);
   return callback(error);
 }


 // Built-in modules.
 const { spawn } = require('child_process');
 const ffmpegPath = require('ffmpeg-static');


 // Determine the recording SID.
 let recordingSid = event.RecordingSid;
 console.log(JSON.stringify(event));
 if (!recordingSid && event.RecordingUrl) {
   const parts = event.RecordingUrl.split('/');
   recordingSid = parts[parts.length - 1];
 }
 console.log("recordingSid:", recordingSid);


 // Use the RecordingUrl from the event if available; otherwise, build it manually.
 let mediaUrl;
 if (event.RecordingUrl) {
   mediaUrl = event.RecordingUrl;
   if (!mediaUrl.endsWith('.mp3')) {
     mediaUrl += '.mp3';
   }
 } else {
   const accountSid = context.ACCOUNT_SID;
   mediaUrl = `https://api.twilio.com/2010-04-01/Accounts/${accountSid}/Recordings/${recordingSid}.mp3`;
 }
 console.log("Constructed mediaUrl:", mediaUrl);


 // If the URL is publicly accessible, you may not need an auth header.
 // But if you do, you can construct it as shown below.
 const accountSid = context.ACCOUNT_SID;
 const basicAuth = Buffer.from(`${accountSid}:${context.AUTH_TOKEN}`).toString('base64');


 // A simple retry mechanism to download the MP3 file.
 async function downloadMp3(url, retries = 3, delayMs = 2000) {
   for (let attempt = 1; attempt <= retries; attempt++) {
     try {
       const response = await ky.get(url, {
         responseType: 'arrayBuffer',
         throwHttpErrors: false,
         headers: {
           // If authentication is not needed, you can comment this out.
           Authorization: `Basic ${basicAuth}`
         }
       });
       if (response.ok) {
         const arrayBuffer = await response.arrayBuffer();
         return Buffer.from(arrayBuffer);
       } else {
         console.warn(`Attempt ${attempt}: Received HTTP ${response.status}`);
         if (attempt < retries) {
           console.log(`Waiting ${delayMs}ms before retrying...`);
           await new Promise(resolve => setTimeout(resolve, delayMs));
         }
       }
     } catch (err) {
       console.error(`Attempt ${attempt} error:`, err);
       if (attempt < retries) {
         await new Promise(resolve => setTimeout(resolve, delayMs));
       }
     }
   }
   throw new Error(`Failed to download MP3 file after ${retries} attempts`);
 }


 // --- Download the MP3 file ---
 let mp3Buffer;
 try {
   mp3Buffer = await downloadMp3(mediaUrl);
   console.log("Successfully downloaded MP3 file");
 } catch (error) {
   console.error('Error downloading MP3 file:', error);
   return callback(error);
 }


 // --- Convert MP3 buffer to OGG/Opus format for Telegram using ffmpeg ---
 async function convertMp3ToOgg(inputBuffer) {
   return new Promise((resolve, reject) => {
     const ffmpeg = spawn(ffmpegPath, [
       '-i', 'pipe:0',       // read input from stdin
       '-c:a', 'libopus',    // encode using libopus
       '-b:a', '64000',      // set bitrate to 64kbps
       '-f', 'ogg',          // output format OGG
       'pipe:1'              // output to stdout
     ]);
      let outputData = [];
     ffmpeg.stdout.on('data', (chunk) => outputData.push(chunk));
     ffmpeg.stderr.on('data', (chunk) => console.error('ffmpeg stderr:', chunk.toString()));
      ffmpeg.on('error', (err) => reject(err));
     ffmpeg.on('close', (code) => {
       if (code !== 0) {
         return reject(new Error(`ffmpeg exited with code ${code}`));
       }
       resolve(Buffer.concat(outputData));
     });
      ffmpeg.stdin.write(inputBuffer);
     ffmpeg.stdin.end();
   });
 }
  let oggBuffer;
 try {
   oggBuffer = await convertMp3ToOgg(mp3Buffer);
   console.log("Successfully converted MP3 to OGG");
 } catch (error) {
   console.error('Error converting MP3 to OGG:', error);
   return callback(error);
 }


 // --- Gather call information ---
 const callTime = new Date().toLocaleString();
 const caller = event.From || 'Unknown';
 const transcription = event.TranscriptionText || 'No transcription available.';
 const caption = `Voicemail received on ${callTime}\nFrom: ${caller}`;


 // Retrieve Telegram credentials.
 const telegramBotToken = context.TELEGRAM_BOT_TOKEN;
 const telegramChatId = context.TELEGRAM_CHAT_ID;


 // --- Send the voice recording to Telegram using sendVoice ---
 const telegramVoiceUrl = `https://api.telegram.org/bot${telegramBotToken}/sendVoice`;
 try {
   // Use the built-in FormData and Blob (available in Node.js v18) to construct the multipart/form-data.
   const form = new FormData();
   form.append('chat_id', telegramChatId);
   const voiceBlob = new Blob([oggBuffer], { type: 'audio/ogg' });
   form.append('voice', voiceBlob, 'voicemail.ogg');
   form.append('caption', caption);
  
   const voiceResponse = await ky.post(telegramVoiceUrl, {
     body: form,
     throwHttpErrors: false
   });
   const voiceJson = await voiceResponse.json();
   if (!voiceJson.ok) {
     console.error('Telegram sendVoice API error:', voiceJson);
   } else {
     console.log('Telegram sendVoice API response:', voiceJson);
   }
 } catch (error) {
   console.error('Exception while sending voice to Telegram:', error);
 }


 // --- Send a second Telegram message with call info and transcription using sendMessage ---
 const telegramMessageUrl = `https://api.telegram.org/bot${telegramBotToken}/sendMessage`;
 const messageText = `${caption}\nTranscription: ${transcription}`;
 try {
   const messageResponse = await ky.post(telegramMessageUrl, {
     json: {
       chat_id: telegramChatId,
       text: messageText
     },
     throwHttpErrors: false
   });
   const messageJson = await messageResponse.json();
   if (!messageJson.ok) {
     console.error('Telegram sendMessage API error:', messageJson);
   } else {
     console.log('Telegram sendMessage API response:', messageJson);
   }
 } catch (error) {
   console.error('Exception while sending message to Telegram:', error);
 }


 // --- Finalize the call ---
 twiml.say("Thank you for your message. Goodbye.");
 twiml.hangup();


 return callback(null, twiml);
};