@link-assistant/web-capture 1.10.4 → 1.10.5

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @link-assistant/web-capture
 
+## 1.10.5
+
+### Patch Changes
+
+- 05132b4: Support public Google Drive image file URLs across capture formats.
+
 ## 1.10.4
 
 ### Patch Changes

package/bin/web-capture.js

@@ -497,6 +497,17 @@ function archiveExtension(archiveFormat) {
   return 'zip';
 }
 
+function sanitizeImageExtension(extension) {
+  if (!extension) {
+    return null;
+  }
+
+  const normalized = extension.toLowerCase().replace(/^\./, '');
+  return ['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg'].includes(normalized)
+    ? normalized
+    : null;
+}
+
 function writeGoogleDocsTextOutput({
   content,
   absoluteUrl,
@@ -601,6 +612,10 @@ async function captureUrl(url, options) {
   // Import required modules
   const {
     fetchHtml,
+    fetchGoogleDriveImage,
+    fetchGoogleDriveImageHtml,
+    googleDriveImageHtmlForUrl,
+    googleDriveImageTextForUrl,
     convertToUtf8,
     convertRelativeUrls,
     normalizeUrlForTextContent,
@@ -926,22 +941,42 @@ async function captureUrl(url, options) {
   }
 
   try {
+    if (['image', 'png', 'jpeg', 'screenshot'].includes(normalizedFormat)) {
+      const googleDriveImage = await fetchGoogleDriveImage(absoluteUrl);
+      if (googleDriveImage) {
+        if (explicitOutput === '-') {
+          process.stdout.write(googleDriveImage.buffer);
+        } else {
+          const outPath = explicitOutput || googleDriveImage.filename;
+          fs.writeFileSync(outPath, googleDriveImage.buffer);
+          console.error(`Google Drive image saved to: ${outPath}`);
+        }
+        return;
+      }
+    }
+
     if (normalizedFormat === 'txt' || normalizedFormat === 'text') {
       let text;
       if (isGithubRepositoryUrl(absoluteUrl)) {
         const snapshot = await fetchGithubRepositorySnapshot(absoluteUrl);
         text = formatGithubRepositoryText(snapshot);
       } else {
-        const response = await fetch(normalizeUrlForTextContent(absoluteUrl));
-        if (!response.ok) {
-          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-        }
-        const contentType =
-          response.headers.get('content-type') || 'text/plain';
-        if (!contentType.includes('text/')) {
-          throw new Error(`Expected text content, got ${contentType}`);
+        const googleDriveImageHtml =
+          await fetchGoogleDriveImageHtml(absoluteUrl);
+        if (googleDriveImageHtml) {
+          text = googleDriveImageTextForUrl(absoluteUrl);
+        } else {
+          const response = await fetch(normalizeUrlForTextContent(absoluteUrl));
+          if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+          }
+          const contentType =
+            response.headers.get('content-type') || 'text/plain';
+          if (!contentType.includes('text/')) {
+            throw new Error(`Expected text content, got ${contentType}`);
+          }
+          text = await response.text();
         }
-        text = await response.text();
       }
       const output =
         explicitOutput === '-'
@@ -992,17 +1027,30 @@ async function captureUrl(url, options) {
       const { dismissPopups, scrollToLoadContent } =
         await import('../src/popups.js');
       const browserOpts = theme ? { colorScheme: theme } : {};
+      const googleDriveImage = await fetchGoogleDriveImage(absoluteUrl);
+      const googleDriveHtml = googleDriveImage
+        ? googleDriveImageHtmlForUrl(absoluteUrl, {
+            imageSrc: `data:${googleDriveImage.contentType};base64,${googleDriveImage.buffer.toString('base64')}`,
+          })
+        : null;
       const browser = await createBrowser(engine, browserOpts);
       try {
         const page = await browser.newPage();
         await page.setViewport({ width, height });
-        await page.goto(absoluteUrl, {
-          waitUntil: 'networkidle0',
-          timeout: 30000,
-        });
-        await new Promise((resolve) => setTimeout(resolve, 5000));
-        await scrollToLoadContent(page);
-        await dismissPopups(page);
+        if (googleDriveHtml) {
+          await page.setContent(googleDriveHtml, {
+            waitUntil: 'networkidle0',
+            timeout: 30000,
+          });
+        } else {
+          await page.goto(absoluteUrl, {
+            waitUntil: 'networkidle0',
+            timeout: 30000,
+          });
+          await new Promise((resolve) => setTimeout(resolve, 5000));
+          await scrollToLoadContent(page);
+          await dismissPopups(page);
+        }
         const rawPage = page.rawPage || page;
         const pdfBuffer = await rawPage.pdf({
           format: 'A4',
@@ -1079,11 +1127,19 @@ async function captureUrl(url, options) {
       // Collect images
       const $ = cheerio.load(html);
       const images = [];
+      const imageExtensionByUrl = new Map();
       $('img').each(function () {
         const src = $(this).attr('src');
         if (src && !src.startsWith('data:') && !src.startsWith('blob:')) {
           try {
-            images.push(new URL(src, absoluteUrl).href);
+            const imgUrl = new URL(src, absoluteUrl).href;
+            images.push(imgUrl);
+            const hintedExtension = sanitizeImageExtension(
+              $(this).attr('data-web-capture-extension')
+            );
+            if (hintedExtension && !imageExtensionByUrl.has(imgUrl)) {
+              imageExtensionByUrl.set(imgUrl, hintedExtension);
+            }
           } catch {
             /* skip */
           }
@@ -1100,7 +1156,10 @@ async function captureUrl(url, options) {
       ) {
         let idx = 1;
         for (const imgUrl of uniqueImages) {
-          const ext = imgUrl.match(/\.(jpe?g|gif|webp|svg|png)/i)?.[1] || 'png';
+          const ext =
+            imageExtensionByUrl.get(imgUrl) ||
+            imgUrl.match(/\.(jpe?g|gif|webp|svg|png)/i)?.[1] ||
+            'png';
           imageMap.set(imgUrl, `images/image-${idx}.${ext}`);
           idx++;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/web-capture",
-  "version": "1.10.4",
+  "version": "1.10.5",
   "description": "CLI and microservice to render web pages as HTML, Markdown, or PNG",
   "main": "src/index.js",
   "bin": {

package/src/archive.js

@@ -58,12 +58,19 @@ export async function archiveHandler(req, res) {
     // Collect images from the HTML
     const $ = cheerio.load(html);
     const images = [];
+    const imageExtensionByUrl = new Map();
     $('img').each(function () {
       const src = $(this).attr('src');
       if (src && !src.startsWith('data:') && !src.startsWith('blob:')) {
         try {
           const imgUrl = new URL(src, absoluteUrl).href;
           images.push(imgUrl);
+          const hintedExtension = sanitizeImageExtension(
+            $(this).attr('data-web-capture-extension')
+          );
+          if (hintedExtension && !imageExtensionByUrl.has(imgUrl)) {
+            imageExtensionByUrl.set(imgUrl, hintedExtension);
+          }
         } catch {
           /* skip invalid URLs */
         }
@@ -89,7 +96,8 @@ export async function archiveHandler(req, res) {
     if (localImages && uniqueImages.length > 0) {
       let idx = 1;
       for (const imgUrl of uniqueImages) {
-        const ext = guessImageExtension(imgUrl);
+        const ext =
+          imageExtensionByUrl.get(imgUrl) || guessImageExtension(imgUrl);
         const filename = `image-${idx}.${ext}`;
         imageMap.set(imgUrl, `images/${filename}`);
         idx++;
@@ -277,3 +285,14 @@ function guessImageExtension(url) {
   }
   return 'png';
 }
+
+function sanitizeImageExtension(extension) {
+  if (!extension) {
+    return null;
+  }
+
+  const normalized = extension.toLowerCase().replace(/^\./, '');
+  return ['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg'].includes(normalized)
+    ? normalized
+    : null;
+}

package/src/browser.js

@@ -23,7 +23,7 @@ const SERVER_CHROME_ARGS = [
  * Unified page interface wrapping browser-commander's makeBrowserCommander.
  *
  * Exposes:
- * - setExtraHTTPHeaders / setUserAgent / setViewport / goto / content / screenshot / close
+ * - setExtraHTTPHeaders / setUserAgent / setViewport / goto / setContent / content / screenshot / close
  *   (via the underlying raw page for cross-engine compatibility)
  * - commander.pdf()           – PDF generation (browser-commander v0.8.0)
  * - commander.emulateMedia()  – Color scheme emulation (browser-commander v0.7.0)
@@ -37,6 +37,7 @@ const SERVER_CHROME_ARGS = [
  * @property {Function} setUserAgent - Set user agent
  * @property {Function} setViewport - Set viewport size
  * @property {Function} goto - Navigate to URL
+ * @property {Function} setContent - Set page HTML content
  * @property {Function} content - Get page HTML content
  * @property {Function} screenshot - Take screenshot
  * @property {Function} close - Close the page
@@ -162,6 +163,16 @@ function createPageAdapter(rawPage, commander, engineType) {
         await rawPage.goto(url, options);
       }
     },
+    async setContent(html, options = {}) {
+      const contentOptions = { ...options };
+      if (
+        engineType === 'playwright' &&
+        contentOptions.waitUntil === 'networkidle0'
+      ) {
+        contentOptions.waitUntil = 'networkidle';
+      }
+      await rawPage.setContent(html, contentOptions);
+    },
     async content() {
       return await rawPage.content();
     },

package/src/docx.js

@@ -76,13 +76,14 @@ export async function docxHandler(req, res) {
             const imgResp = await fetch(imgUrl);
             if (imgResp.ok) {
               const buffer = await imgResp.buffer();
+              const contentType = imgResp.headers.get('content-type') || '';
               children.push(
                 new Paragraph({
                   children: [
                     new ImageRun({
                       data: buffer,
                       transformation: { width: 600, height: 400 },
-                      type: guessImageType(imgUrl),
+                      type: guessImageType(imgUrl, contentType),
                     }),
                   ],
                 })
@@ -170,7 +171,24 @@ export async function docxHandler(req, res) {
   }
 }
 
-function guessImageType(url) {
+function guessImageType(url, contentType = '') {
+  const normalizedContentType = contentType.toLowerCase().split(';')[0].trim();
+  if (normalizedContentType === 'image/jpeg') {
+    return 'jpg';
+  }
+  if (normalizedContentType === 'image/png') {
+    return 'png';
+  }
+  if (normalizedContentType === 'image/gif') {
+    return 'gif';
+  }
+  if (normalizedContentType === 'image/bmp') {
+    return 'bmp';
+  }
+  if (normalizedContentType === 'image/svg+xml') {
+    return 'svg';
+  }
+
   const pathname = new URL(url).pathname.toLowerCase();
   if (pathname.endsWith('.jpg') || pathname.endsWith('.jpeg')) {
     return 'jpg';

package/src/fetch.js

@@ -1,4 +1,5 @@
 import fetch from 'node-fetch';
+import { convertGoogleDriveUrl } from './lib.js';
 
 export async function fetchHandler(req, res) {
   const url = req.query.url;
@@ -6,7 +7,7 @@ export async function fetchHandler(req, res) {
     return res.status(400).send('Missing `url` parameter');
   }
   try {
-    const response = await fetch(url);
+    const response = await fetch(convertGoogleDriveUrl(url));
     // Copy status and headers
     res.status(response.status);
 

package/src/image.js

@@ -1,5 +1,5 @@
 import { createBrowser, getBrowserEngine } from './browser.js';
-import { isStackOverflowQuestionUrl } from './lib.js';
+import { fetchGoogleDriveImage, isStackOverflowQuestionUrl } from './lib.js';
 import { dismissPopups, scrollToLoadContent } from './popups.js';
 
 /**
@@ -39,6 +39,17 @@ export async function imageHandler(req, res) {
 
   try {
     const absoluteUrl = url.startsWith('http') ? url : `https://${url}`;
+    const googleDriveImage = await fetchGoogleDriveImage(absoluteUrl);
+    if (googleDriveImage) {
+      res.set('Content-Type', googleDriveImage.contentType);
+      res.set(
+        'Content-Disposition',
+        `inline; filename="${googleDriveImage.filename}"`
+      );
+      res.end(googleDriveImage.buffer);
+      return;
+    }
+
     const engine = getBrowserEngine(req);
     const waitUntil =
       engine === 'playwright' && isStackOverflowQuestionUrl(absoluteUrl)

package/src/lib.js

@@ -14,11 +14,17 @@ import { retry } from './retry.js';
 
 const STACKPRINTER_RETRIES = 3;
 const STACKPRINTER_RETRY_BASE_DELAY_MS = 1000;
+const GOOGLE_DRIVE_FILE_ID_RE = /^[A-Za-z0-9_-]+$/;
 
 export async function fetchHtml(url) {
   if (!url) {
     throw new Error('Missing URL parameter');
   }
+  const googleDriveImageHtml = await fetchGoogleDriveImageHtml(url);
+  if (googleDriveImageHtml) {
+    return googleDriveImageHtml;
+  }
+
   const stackPrinterUrl = stackPrinterUrlForQuestion(url);
   if (stackPrinterUrl) {
     return await fetchStackPrinterHtml(stackPrinterUrl);
@@ -28,6 +34,163 @@ export async function fetchHtml(url) {
   return response.text();
 }
 
+export function getGoogleDriveFileId(url) {
+  if (!url) {
+    return null;
+  }
+
+  try {
+    const parsed = new URL(url);
+    const hostname = parsed.hostname.toLowerCase();
+    const pathnameParts = parsed.pathname.split('/').filter(Boolean);
+    let fileId = null;
+
+    if (
+      hostname === 'drive.google.com' ||
+      hostname === 'www.drive.google.com'
+    ) {
+      if (pathnameParts[0] === 'file' && pathnameParts[1] === 'd') {
+        fileId = pathnameParts[2] || null;
+      } else if (pathnameParts[0] === 'open' || pathnameParts[0] === 'uc') {
+        fileId = parsed.searchParams.get('id');
+      }
+    } else if (
+      hostname === 'drive.usercontent.google.com' &&
+      pathnameParts[0] === 'download'
+    ) {
+      fileId = parsed.searchParams.get('id');
+    }
+
+    return fileId && GOOGLE_DRIVE_FILE_ID_RE.test(fileId) ? fileId : null;
+  } catch {
+    return null;
+  }
+}
+
+export function isGoogleDriveFileUrl(url) {
+  return Boolean(getGoogleDriveFileId(url));
+}
+
+export function convertGoogleDriveUrl(url) {
+  const fileId = getGoogleDriveFileId(url);
+  if (!fileId) {
+    return url;
+  }
+
+  return `https://drive.google.com/uc?export=download&id=${fileId}`;
+}
+
+export function googleDriveImageHtmlForUrl(url, options = {}) {
+  const fileId = getGoogleDriveFileId(url);
+  if (!fileId) {
+    return null;
+  }
+
+  const imageUrl = options.imageSrc || convertGoogleDriveUrl(url);
+  const escapedImageUrl = he.escape(imageUrl);
+  const escapedSourceUrl = he.escape(url);
+  const extensionAttribute = options.imageExtension
+    ? ` data-web-capture-extension="${he.escape(options.imageExtension)}"`
+    : '';
+
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Google Drive image</title>
+</head>
+<body>
+  <h1>Google Drive image</h1>
+  <p><a href="${escapedSourceUrl}">Original Google Drive file</a></p>
+  <img src="${escapedImageUrl}" alt="Google Drive image"${extensionAttribute}>
+</body>
+</html>`;
+}
+
+export function googleDriveImageTextForUrl(url) {
+  if (!isGoogleDriveFileUrl(url)) {
+    return null;
+  }
+
+  return [
+    'Google Drive image',
+    '',
+    `Original Google Drive file: ${url}`,
+    `Image: ${convertGoogleDriveUrl(url)}`,
+    '',
+  ].join('\n');
+}
+
+export async function fetchGoogleDriveImage(url) {
+  const fileId = getGoogleDriveFileId(url);
+  if (!fileId) {
+    return null;
+  }
+
+  const downloadUrl = convertGoogleDriveUrl(url);
+  const response = await fetch(downloadUrl);
+  if (!response.ok) {
+    throw new Error(`Google Drive returned HTTP ${response.status}`);
+  }
+
+  const contentType = response.headers.get('content-type') || '';
+  if (!isImageContentType(contentType)) {
+    throw new Error(`Google Drive file is not an image (${contentType})`);
+  }
+
+  return {
+    buffer: await response.buffer(),
+    contentType,
+    downloadUrl,
+    filename: `google-drive-${fileId}.${imageExtensionForContentType(contentType)}`,
+  };
+}
+
+export async function fetchGoogleDriveImageHtml(url) {
+  if (!isGoogleDriveFileUrl(url)) {
+    return null;
+  }
+
+  const downloadUrl = convertGoogleDriveUrl(url);
+  let imageExtension = null;
+  try {
+    const response = await fetch(downloadUrl, { method: 'HEAD' });
+    if (response.ok) {
+      const contentType = response.headers.get('content-type');
+      if (!isImageContentType(contentType)) {
+        return null;
+      }
+      imageExtension = imageExtensionForContentType(contentType);
+    }
+  } catch {
+    // Some public Drive responses reject HEAD even though GET works. In that
+    // case still render the direct image document and let consumers fetch it.
+  }
+
+  return googleDriveImageHtmlForUrl(url, { imageExtension });
+}
+
+function isImageContentType(contentType) {
+  return (contentType || '').toLowerCase().startsWith('image/');
+}
+
+function imageExtensionForContentType(contentType) {
+  const normalized = (contentType || '').toLowerCase().split(';')[0].trim();
+  if (normalized === 'image/jpeg' || normalized === 'image/jpg') {
+    return 'jpg';
+  }
+  if (normalized === 'image/gif') {
+    return 'gif';
+  }
+  if (normalized === 'image/webp') {
+    return 'webp';
+  }
+  if (normalized === 'image/svg+xml') {
+    return 'svg';
+  }
+  return 'png';
+}
+
 async function fetchStackPrinterHtml(url) {
   return await retry(
     async () => {

package/src/pdf.js

@@ -15,6 +15,7 @@
 
 import { createBrowser, getBrowserEngine } from './browser.js';
 import { dismissPopups, scrollToLoadContent } from './popups.js';
+import { fetchGoogleDriveImage, googleDriveImageHtmlForUrl } from './lib.js';
 
 export async function pdfHandler(req, res) {
   const url = req.query.url;
@@ -29,6 +30,12 @@ export async function pdfHandler(req, res) {
 
   try {
     const absoluteUrl = url.startsWith('http') ? url : `https://${url}`;
+    const googleDriveImage = await fetchGoogleDriveImage(absoluteUrl);
+    const googleDriveHtml = googleDriveImage
+      ? googleDriveImageHtmlForUrl(absoluteUrl, {
+          imageSrc: `data:${googleDriveImage.contentType};base64,${googleDriveImage.buffer.toString('base64')}`,
+        })
+      : null;
     const engine = getBrowserEngine(req);
     const browserOpts = theme ? { colorScheme: theme } : {};
     const browser = await createBrowser(engine, browserOpts);
@@ -42,16 +49,23 @@ export async function pdfHandler(req, res) {
         'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
       );
       await page.setViewport({ width, height });
-      await page.goto(absoluteUrl, {
-        waitUntil: 'networkidle0',
-        timeout: 30000,
-      });
+      if (googleDriveHtml) {
+        await page.setContent(googleDriveHtml, {
+          waitUntil: 'networkidle0',
+          timeout: 30000,
+        });
+      } else {
+        await page.goto(absoluteUrl, {
+          waitUntil: 'networkidle0',
+          timeout: 30000,
+        });
 
-      await new Promise((resolve) => setTimeout(resolve, 5000));
-      await scrollToLoadContent(page);
+        await new Promise((resolve) => setTimeout(resolve, 5000));
+        await scrollToLoadContent(page);
 
-      if (shouldDismissPopups) {
-        await dismissPopups(page);
+        if (shouldDismissPopups) {
+          await dismissPopups(page);
+        }
       }
 
       // Generate PDF using browser-commander's unified pdf() API (v0.8.0+)

package/src/stream.js

@@ -1,5 +1,6 @@
 import fetch from 'node-fetch';
 import { pipeline } from 'stream';
+import { convertGoogleDriveUrl } from './lib.js';
 
 export async function streamHandler(req, res) {
   const url = req.query.url;
@@ -7,7 +8,7 @@ export async function streamHandler(req, res) {
     return res.status(400).send('Missing `url` parameter');
   }
   try {
-    const response = await fetch(url);
+    const response = await fetch(convertGoogleDriveUrl(url));
     // Copy status and headers
     res.status(response.status);
 

package/src/txt.js

@@ -2,7 +2,10 @@ import fetch from 'node-fetch';
 import { URL } from 'node:url';
 import {
   fetchHtml,
+  fetchGoogleDriveImageHtml,
+  googleDriveImageTextForUrl,
   getTextPasteFilename,
+  isGoogleDriveFileUrl,
   isStackOverflowQuestionUrl,
   normalizeUrlForTextContent,
 } from './lib.js';
@@ -31,6 +34,13 @@ export async function txtHandler(req, res) {
       return sendTextResponse(res, url, text);
     }
 
+    if (isGoogleDriveFileUrl(url)) {
+      const googleDriveImageHtml = await fetchGoogleDriveImageHtml(url);
+      if (googleDriveImageHtml) {
+        return sendTextResponse(res, url, googleDriveImageTextForUrl(url));
+      }
+    }
+
     // Normalize URL to get text content (e.g., xpaste.pro -> xpaste.pro/raw)
     const textUrl = normalizeUrlForTextContent(url);
 

package/tests/integration/google-drive-image.test.js

@@ -0,0 +1,246 @@
+import request from 'supertest';
+import nock from 'nock';
+import unzipper from 'unzipper';
+import { app } from '../../src/index.js';
+
+const FIRST_FILE_ID = '1Cxkx6-428EQAX0-eiaq66H829ohnPp7q';
+const SECOND_FILE_ID = '1fgJaftjv53xCN7vgiJOaQlbfWkUqPgyd';
+const JPEG_BYTES = Buffer.from(
+  '/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAP//////////////////////////////////////////////////////////////////////////////////////2wBDAf//////////////////////////////////////////////////////////////////////////////////////wAARCAABAAEDASIAAhEBAxEB/8QAFQABAQAAAAAAAAAAAAAAAAAAAAX/xAAUEAEAAAAAAAAAAAAAAAAAAAAA/9oADAMBAAIQAxAAAAH/xAAUEAEAAAAAAAAAAAAAAAAAAAAA/9oACAEBAAEFAqf/xAAUEQEAAAAAAAAAAAAAAAAAAAAA/9oACAEDAQE/ASP/xAAUEQEAAAAAAAAAAAAAAAAAAAAA/9oACAECAQE/ASP/xAAUEAEAAAAAAAAAAAAAAAAAAAAA/9oACAEBAAY/Ap//xAAUEAEAAAAAAAAAAAAAAAAAAAAA/9oACAEBAAE/IV//2gAMAwEAAgADAAAAEP/EFBQRAQAAAAAAAAAAAAAAAAAAARD/2gAIAQMBAT8QH//EFBQRAQAAAAAAAAAAAAAAAAAAARD/2gAIAQIBAT8QH//EFBABAQAAAAAAAAAAAAAAAAAAARD/2gAIAQEAAT8QH//Z',
+  'base64'
+);
+
+const DRIVE_URLS = [
+  {
+    name: 'first issue URL with /view',
+    fileId: FIRST_FILE_ID,
+    url: `https://drive.google.com/file/d/${FIRST_FILE_ID}/view`,
+  },
+  {
+    name: 'first issue URL without /view',
+    fileId: FIRST_FILE_ID,
+    url: `https://drive.google.com/file/d/${FIRST_FILE_ID}`,
+  },
+  {
+    name: 'second issue URL with /view',
+    fileId: SECOND_FILE_ID,
+    url: `https://drive.google.com/file/d/${SECOND_FILE_ID}/view`,
+  },
+  {
+    name: 'second issue URL without /view',
+    fileId: SECOND_FILE_ID,
+    url: `https://drive.google.com/file/d/${SECOND_FILE_ID}`,
+  },
+];
+
+function directDownloadUrl(fileId) {
+  return `https://drive.google.com/uc?export=download&id=${fileId}`;
+}
+
+function mockDriveHead(fileId) {
+  return nock('https://drive.google.com')
+    .head('/uc')
+    .query({ export: 'download', id: fileId })
+    .reply(200, '', { 'content-type': 'image/jpeg' });
+}
+
+function mockDriveGet(fileId) {
+  return nock('https://drive.google.com')
+    .get('/uc')
+    .query({ export: 'download', id: fileId })
+    .reply(200, JPEG_BYTES, {
+      'content-type': 'image/jpeg',
+      'content-length': String(JPEG_BYTES.length),
+    });
+}
+
+function bufferParser(res, callback) {
+  const chunks = [];
+  res.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
+  res.on('end', () => callback(null, Buffer.concat(chunks)));
+}
+
+afterEach(() => {
+  nock.cleanAll();
+});
+
+describe('Google Drive public image links', () => {
+  it.each(DRIVE_URLS)(
+    '/image downloads image bytes for $name',
+    async (item) => {
+      mockDriveGet(item.fileId);
+
+      const res = await request(app)
+        .get('/image')
+        .query({ url: item.url })
+        .buffer(true)
+        .parse(bufferParser)
+        .expect(200);
+
+      expect(res.headers['content-type']).toMatch(/^image\/jpeg/);
+      expect(res.body.subarray(0, 3)).toEqual(Buffer.from([0xff, 0xd8, 0xff]));
+      expect(nock.isDone()).toBe(true);
+    }
+  );
+
+  it.each(DRIVE_URLS)(
+    '/fetch proxies direct image bytes for $name',
+    async (item) => {
+      mockDriveGet(item.fileId);
+
+      const res = await request(app)
+        .get('/fetch')
+        .query({ url: item.url })
+        .buffer(true)
+        .parse(bufferParser)
+        .expect(200);
+
+      expect(res.headers['content-type']).toMatch(/^image\/jpeg/);
+      expect(res.body.subarray(0, 3)).toEqual(Buffer.from([0xff, 0xd8, 0xff]));
+      expect(nock.isDone()).toBe(true);
+    }
+  );
+
+  it.each(DRIVE_URLS)(
+    '/stream proxies direct image bytes for $name',
+    async (item) => {
+      mockDriveGet(item.fileId);
+
+      const res = await request(app)
+        .get('/stream')
+        .query({ url: item.url })
+        .buffer(true)
+        .parse(bufferParser)
+        .expect(200);
+
+      expect(res.headers['content-type']).toMatch(/^image\/jpeg/);
+      expect(res.body.subarray(0, 3)).toEqual(Buffer.from([0xff, 0xd8, 0xff]));
+      expect(nock.isDone()).toBe(true);
+    }
+  );
+
+  it.each(DRIVE_URLS)(
+    '/markdown includes a direct image link for $name',
+    async (item) => {
+      mockDriveHead(item.fileId);
+
+      const res = await request(app)
+        .get('/markdown')
+        .query({ url: item.url })
+        .expect(200);
+
+      expect(res.headers['content-type']).toMatch(/text\/markdown/);
+      expect(res.text).toContain(
+        `![Google Drive image](${directDownloadUrl(item.fileId)})`
+      );
+      expect(nock.isDone()).toBe(true);
+    }
+  );
+
+  it.each(DRIVE_URLS)(
+    '/txt includes the original and direct image links for $name',
+    async (item) => {
+      mockDriveHead(item.fileId);
+
+      const res = await request(app)
+        .get('/txt')
+        .query({ url: item.url })
+        .expect(200);
+
+      expect(res.headers['content-type']).toMatch(/text\/plain/);
+      expect(res.text).toContain('Google Drive image');
+      expect(res.text).toContain(`Original Google Drive file: ${item.url}`);
+      expect(res.text).toContain(`Image: ${directDownloadUrl(item.fileId)}`);
+      expect(nock.isDone()).toBe(true);
+    }
+  );
+
+  it.each(DRIVE_URLS)(
+    '/html includes a direct image tag for $name',
+    async (item) => {
+      mockDriveHead(item.fileId);
+
+      const res = await request(app)
+        .get('/html')
+        .query({ url: item.url })
+        .expect(200);
+
+      expect(res.headers['content-type']).toMatch(/text\/html/);
+      expect(res.text).toContain(
+        `src="${directDownloadUrl(item.fileId).replace('&', '&')}"`
+      );
+      expect(nock.isDone()).toBe(true);
+    }
+  );
+
+  it('archive includes markdown and the downloaded Drive image', async () => {
+    const item = DRIVE_URLS[0];
+    mockDriveHead(item.fileId);
+    mockDriveGet(item.fileId);
+
+    const res = await request(app)
+      .get('/archive')
+      .query({ url: item.url })
+      .buffer(true)
+      .parse(bufferParser)
+      .expect(200);
+
+    const zip = await unzipper.Open.buffer(res.body);
+    const document = zip.files.find((file) => file.path === 'document.md');
+    const image = zip.files.find((file) => file.path.startsWith('images/'));
+
+    expect(document).toBeDefined();
+    expect(image).toBeDefined();
+    expect((await document.buffer()).toString('utf8')).toContain(
+      '![Google Drive image](images/image-1.jpg)'
+    );
+    expect((await image.buffer()).subarray(0, 3)).toEqual(
+      Buffer.from([0xff, 0xd8, 0xff])
+    );
+    expect(nock.isDone()).toBe(true);
+  });
+
+  it('docx includes the downloaded Drive image', async () => {
+    const item = DRIVE_URLS[0];
+    mockDriveHead(item.fileId);
+    mockDriveGet(item.fileId);
+
+    const res = await request(app)
+      .get('/docx')
+      .query({ url: item.url })
+      .buffer(true)
+      .parse(bufferParser)
+      .expect(200);
+
+    expect(res.headers['content-type']).toMatch(
+      /application\/vnd\.openxmlformats-officedocument\.wordprocessingml\.document/
+    );
+    expect(res.body.subarray(0, 2)).toEqual(Buffer.from('PK'));
+
+    const docx = await unzipper.Open.buffer(res.body);
+    const mediaEntry = docx.files.find(
+      (file) => file.path.startsWith('word/media/') && !file.path.endsWith('/')
+    );
+    expect(mediaEntry).toBeDefined();
+    expect((await mediaEntry.buffer()).subarray(0, 3)).toEqual(
+      Buffer.from([0xff, 0xd8, 0xff])
+    );
+    expect(nock.isDone()).toBe(true);
+  });
+
+  it('pdf renders the downloaded Drive image document', async () => {
+    const item = DRIVE_URLS[0];
+    mockDriveGet(item.fileId);
+
+    const res = await request(app)
+      .get('/pdf')
+      .query({ url: item.url })
+      .buffer(true)
+      .parse(bufferParser)
+      .expect(200);
+
+    expect(res.headers['content-type']).toMatch(/application\/pdf/);
+    expect(res.body.subarray(0, 4).toString('utf8')).toBe('%PDF');
+    expect(nock.isDone()).toBe(true);
+  });
+});

package/tests/unit/convertGoogleDriveUrl.test.js

@@ -0,0 +1,89 @@
+import {
+  convertGoogleDriveUrl,
+  getGoogleDriveFileId,
+  googleDriveImageTextForUrl,
+  isGoogleDriveFileUrl,
+} from '../../src/lib.js';
+
+const FIRST_FILE_ID = '1Cxkx6-428EQAX0-eiaq66H829ohnPp7q';
+const SECOND_FILE_ID = '1fgJaftjv53xCN7vgiJOaQlbfWkUqPgyd';
+
+function directDownloadUrl(fileId) {
+  return `https://drive.google.com/uc?export=download&id=${fileId}`;
+}
+
+describe('Google Drive URL helpers', () => {
+  it.each([
+    [
+      'issue URL with /view',
+      `https://drive.google.com/file/d/${FIRST_FILE_ID}/view`,
+      FIRST_FILE_ID,
+    ],
+    [
+      'issue URL without /view',
+      `https://drive.google.com/file/d/${FIRST_FILE_ID}`,
+      FIRST_FILE_ID,
+    ],
+    [
+      'second issue URL with /view',
+      `https://drive.google.com/file/d/${SECOND_FILE_ID}/view`,
+      SECOND_FILE_ID,
+    ],
+    [
+      'second issue URL without /view',
+      `https://drive.google.com/file/d/${SECOND_FILE_ID}`,
+      SECOND_FILE_ID,
+    ],
+    [
+      'open?id URL',
+      `https://drive.google.com/open?id=${FIRST_FILE_ID}`,
+      FIRST_FILE_ID,
+    ],
+    [
+      'direct uc URL',
+      `https://drive.google.com/uc?export=download&id=${FIRST_FILE_ID}`,
+      FIRST_FILE_ID,
+    ],
+    [
+      'redirected usercontent URL',
+      `https://drive.usercontent.google.com/download?id=${FIRST_FILE_ID}&export=download`,
+      FIRST_FILE_ID,
+    ],
+  ])('extracts and converts %s', (_name, input, fileId) => {
+    expect(getGoogleDriveFileId(input)).toBe(fileId);
+    expect(isGoogleDriveFileUrl(input)).toBe(true);
+    expect(convertGoogleDriveUrl(input)).toBe(directDownloadUrl(fileId));
+  });
+
+  it('ignores non-Google Drive URLs and malformed Drive IDs', () => {
+    const example = 'https://example.com/image.jpg';
+    const malformed = 'https://drive.google.com/file/d/not%20valid/view';
+
+    expect(getGoogleDriveFileId(example)).toBeNull();
+    expect(isGoogleDriveFileUrl(example)).toBe(false);
+    expect(convertGoogleDriveUrl(example)).toBe(example);
+    expect(getGoogleDriveFileId(malformed)).toBeNull();
+    expect(isGoogleDriveFileUrl(malformed)).toBe(false);
+    expect(convertGoogleDriveUrl(malformed)).toBe(malformed);
+  });
+
+  it('keeps empty or missing inputs unchanged when converting', () => {
+    expect(convertGoogleDriveUrl(null)).toBeNull();
+    expect(convertGoogleDriveUrl(undefined)).toBeUndefined();
+    expect(convertGoogleDriveUrl('')).toBe('');
+  });
+
+  it('renders text output with the original file URL and direct image URL', () => {
+    const input = `https://drive.google.com/file/d/${FIRST_FILE_ID}/view`;
+
+    expect(googleDriveImageTextForUrl(input)).toContain(
+      `Original Google Drive file: ${input}`
+    );
+    expect(googleDriveImageTextForUrl(input)).toContain(
+      `Image: ${directDownloadUrl(FIRST_FILE_ID)}`
+    );
+    expect(
+      googleDriveImageTextForUrl('https://example.com/image.jpg')
+    ).toBeNull();
+  });
+});