Merge pull request #27 from komplexb/feat/image-upload-2025

feat: OneNote Image to Telegram Photo Upload

Author: komplexb

eventData.json

@@ -2,7 +2,7 @@
   "onenoteSettings": {
     "notebookName": "2nd Brain",
     "sectionName": "Test",
-    "isSequential": false
+    "isSequential": true
   },
   "messageSettings": {
     "channelHandle": "@notifyer_quotes_dev",

lib/notify.js

@@ -1,7 +1,7 @@
 const { htmlToMarkdown } = require('./markdown')
 const HTMLParser = require('node-html-parser')
 const { markdownv2 } = require('telegram-format')
-const { getNoteContents }  = require('./onenote')
+const { getNoteContents, extractFirstImage, downloadImage }  = require('./onenote')
 
 const fetch = require('superagent')
 
@@ -146,33 +146,69 @@ async function withTelegram(note, messageSettings, login = false) {
   } = messageSettings
   const msg = await structureMessage({ note, titlePrefix, isLogin: login })
 
-  let text = markdownv2.bold(markdownv2.escape(msg.prefix))
-  text += markdownv2.escape(`\n\n`)
-  text += markdownv2.underline(markdownv2.escape(msg.title))
-  text += markdownv2.escape(`\n\n`)
-  text += msg.body
-
-  if(showEditLink) {
-    // const openInOnenote = markdownv2.url("Open In OneNote", markdownv2.escape(msg.url))
-    text += markdownv2.escape(`\n\n`)
-    text += markdownv2.url("Edit note", msg.webUrl)
-  }
-
   return new Promise(async(resolve, reject) => {
     try {
+      // Handle image processing independently
+      let hasImage = false
+      try {
+        const noteContent = await getNoteContents(note.url)
+        const imageInfo = extractFirstImage(noteContent.content)
+
+        if (imageInfo?.imageUrl) {
+          console.log('Found image in note, sending photo first')
+
+          // Create caption with subject and alt text
+          let caption = markdownv2.bold(markdownv2.escape(msg.prefix))
+          caption += markdownv2.escape(`\n\n`)
+          caption += markdownv2.underline(markdownv2.escape(msg.title))
+          caption += markdownv2.escape(`\n\n`)
+
+          // Use alt text if available, otherwise use preview text
+          const captionText = imageInfo.altText || msg.previewText
+          caption += markdownv2.escape(captionText)
+
+          if(showEditLink) {
+            caption += markdownv2.escape(`\n\n`)
+            caption += markdownv2.url("Edit note", msg.webUrl)
+          }
+
+          // Download and send image with size limits
+          const imageBuffer = await downloadImage(imageInfo.dataFullresSrc || imageInfo.imageUrl)
+          await sendPhotoToTelegram(imageBuffer, caption, channelHandle)
+          hasImage = true
+        }
+      } catch (imageErr) {
+        console.warn('Image processing failed, continuing with text message:', imageErr.message)
+        // Image processing failure doesn't affect text message flow
+      }
+
+      // Send note body text
+      let text = markdownv2.bold(markdownv2.escape(msg.prefix))
+      text += markdownv2.escape(`\n\n`)
+      text += markdownv2.underline(markdownv2.escape(msg.title))
+      text += markdownv2.escape(`\n\n`)
+      text += msg.body
+
+      if(showEditLink) {
+        text += markdownv2.escape(`\n\n`)
+        text += markdownv2.url("Edit note", msg.webUrl)
+      }
+
       await sendNoteToTelegram(text, channelHandle, { disable_web_page_preview: disablePreview });
+
       resolve({
         status: 200,
         title: msg.title,
         body: msg.previewText,
+        hasImage
       })
     } catch (err) {
       console.error('Title: ', msg.title)
-      console.error('withTelegram', err.response.body.description)
+      console.error('withTelegram', err.response?.body?.description || err.message)
       reject({
         status: 400,
         title: msg.title || 'Error',
-        body: err.response.body.description,
+        body: err.response?.body?.description || err.message,
       })
     }
   });
@@ -209,8 +245,45 @@ const sendNoteToTelegram = async(msg, channelHandle, requestArgs, escapeMsg = fa
   })
 }
 
+/**
+ * Send photo to Telegram channel using buffer
+ * @param {Buffer} imageBuffer - Image buffer data
+ * @param {string} caption - Photo caption in MarkdownV2 format
+ * @param {string} channelHandle - Telegram channel ID
+ * @returns {Promise} Telegram API response
+ */
+const sendPhotoToTelegram = async(imageBuffer, caption, channelHandle) => {
+  const baseUrl = process.env.TELEGRAM_URL.replace(
+    '{NotifyerBotToken}',
+    process.env.TELEGRAM_BOT_TOKEN
+  )
+  const urlPath = 'sendPhoto';
+
+  return new Promise((resolve, reject) => {
+    fetch
+      .post(`${baseUrl}/${urlPath}`)
+      .field('chat_id', channelHandle)
+      .field('caption', caption)
+      .field('parse_mode', 'MarkdownV2')
+      .attach('photo', imageBuffer, 'image.jpg')
+      .timeout({ response: 30000, deadline: 45000 })
+      .then(response => {
+        if (response?.ok) {
+          console.log('Photo Pushed!')
+          resolve(response)
+        } else {
+          throw new Error(response)
+        }
+      })
+      .catch(err => {
+        reject(err);
+      })
+  })
+}
+
 module.exports = {
   withPush: push,
   withTelegram,
-  sendNoteToTelegram
+  sendNoteToTelegram,
+  sendPhotoToTelegram
 }

lib/onenote.js

@@ -313,14 +313,125 @@ function getRandomNote(notes, sectionHandle) {
     localStorage.getItem(`recent_${sectionHandle}`, true) || []
 
   if (recentNotes.includes(note.id)) {
-    getRandomNote(notes)
+    return getRandomNote(notes, sectionHandle)
   }
 
   return note
 }
 
+/**
+ * Extract first image from OneNote HTML content
+ * @param {string} htmlContent - OneNote page HTML content
+ * @returns {Object|null} { imageUrl, altText, dataFullresSrc } or null if no image found
+ */
+function extractFirstImage(htmlContent) {
+  const HTMLParser = require('node-html-parser')
+  const wrapper = HTMLParser.parse(htmlContent)
+
+  const firstImg = wrapper.querySelector('img')
+  if (!firstImg) {
+    return null
+  }
+
+  return {
+    imageUrl: firstImg.getAttribute('src'),
+    dataFullresSrc: firstImg.getAttribute('data-fullres-src'),
+    altText: firstImg.getAttribute('alt') || '',
+    width: firstImg.getAttribute('width'),
+    height: firstImg.getAttribute('height')
+  }
+}
+
+/**
+ * Check image size before downloading
+ * @param {string} imageUrl - The Graph API image endpoint URL
+ * @returns {Promise<number>} Image size in bytes
+ */
+async function getImageSize(imageUrl) {
+  const { accessToken } = localStorage.getItem('onenote')
+
+  return new Promise((resolve, reject) => {
+    apiRequests
+      .head(imageUrl)
+      .timeout({ response: 10000, deadline: 15000 })
+      .set('Authorization', `Bearer ${accessToken}`)
+      .then(response => {
+        if (response?.ok) {
+          const contentLength = response.headers['content-length']
+          resolve(contentLength ? parseInt(contentLength) : 0)
+        } else {
+          throw new Error(response)
+        }
+      })
+      .catch(err => {
+        console.error('getImageSize', err)
+        reject(err)
+      })
+  })
+}
+
+/**
+ * Download image from Microsoft Graph API endpoint with size limits
+ * @param {string} imageUrl - The Graph API image endpoint URL
+ * @param {number} maxSizeBytes - Maximum file size in bytes (default 3MB)
+ * @returns {Promise<Buffer>} Image buffer
+ */
+async function downloadImage(imageUrl, maxSizeBytes = 3 * 1024 * 1024) {
+  const { accessToken } = localStorage.getItem('onenote')
+
+  // Check size first
+  try {
+    const imageSize = await getImageSize(imageUrl)
+    if (imageSize > maxSizeBytes) {
+      throw new Error(`Image too large: ${imageSize} bytes (max: ${maxSizeBytes})`)
+    }
+    console.log(`Downloading image: ${imageSize} bytes`)
+  } catch (err) {
+    console.warn('Could not check image size, proceeding with download:', err.message)
+  }
+
+  return new Promise((resolve, reject) => {
+    apiRequests
+      .get(imageUrl)
+      .timeout({ response: 30000, deadline: 45000 })
+      .set('Authorization', `Bearer ${accessToken}`)
+      .buffer(true)
+      .parse((res, callback) => {
+        const chunks = []
+        let downloadedBytes = 0
+
+        res.on('data', chunk => {
+          downloadedBytes += chunk.length
+          if (downloadedBytes > maxSizeBytes) {
+            return callback(new Error(`Image download exceeded size limit: ${downloadedBytes} bytes`))
+          }
+          chunks.push(chunk)
+        })
+
+        res.on('end', () => {
+          console.log(`Downloaded ${downloadedBytes} bytes`)
+          callback(null, Buffer.concat(chunks))
+        })
+      })
+      .then(response => {
+        if (response && response.ok) {
+          resolve(response.body)
+        } else {
+          throw new Error(response)
+        }
+      })
+      .catch(err => {
+        console.error('downloadImage', err)
+        reject(err)
+      })
+  })
+}
+
 module.exports = {
   getNote,
   getNoteContents,
-  setNoteSection
+  setNoteSection,
+  extractFirstImage,
+  downloadImage,
+  getImageSize
 }

package.json

@@ -7,6 +7,7 @@
     "app": "sls invoke local -f app",
     "deploy": "sls deploy --stage prod",
     "predeploy": "npm run remove",
+    "remove-logs": "aws logs delete-log-group --log-group-name /aws/lambda/notifyer-cron-prod-app --region ap-southeast-2",
     "dev": "sls invoke local -f app --watch --path ./eventData.json",
     "agentdev": "sls invoke local -f app --path ./eventData.json",
     "offline": "sls offline start --port 4500",