Update server.js

server.js

@@ -1,58 +1,324 @@
-'use strict';
-
 import express from 'express';
-import fetch from 'node-fetch';
-import sharp from 'sharp';
-import Lens from 'chrome-lens-ocr';
-
-// Constants
-const PORT = 7860;
-const HOST = '0.0.0.0';
+import axios from 'axios';
+import cheerio from 'cheerio';
+import cors from 'cors';
 
-// App
 const app = express();
-const lens = new Lens();
+const PORT = process.env.PORT || 3000;
 
-app.get('/', (req, res) => {
-  res.send('Hello World from ExpressJS! This example is from the NodeJS Docs: https://nodejs.org/en/docs/guides/nodejs-docker-webapp/');
-});
 
-app.get('/scanByUrl', async (req, res) => {
-  const { url } = req.query;
+app.use(cors());
+app.use(express.json());
 
-  if (!url) {
-    return res.status(400).json({ error: 'Image URL is required' });
+
+function extractPixivId(url) {
+  const patterns = [
+    /pixiv\.net\/(?:en\/)?artworks\/(\d+)/,
+    /pixiv\.net\/member_illust\.php\?.*illust_id=(\d+)/,
+    /pixiv\.net\/(?:en\/)?users\/\d+\/artworks\/(\d+)/
+  ];
+
+  for (let pattern of patterns) {
+    const match = url.match(pattern);
+    if (match) return match[1];
   }
+  return null;
+}
+
 
+async function getPixivMetadata(artworkId, req) {
   try {
-    // Fetch the image
-    const response = await fetch(url);
-    if (!response.ok) throw new Error('Failed to fetch image');
+    const apiUrl = `https://www.pixiv.net/ajax/illust/${artworkId}`;
+    const pageUrl = `https://www.pixiv.net/en/artworks/${artworkId}`;
+
+    // Set headers to mimic a browser request
+    const headers = {
+      'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+      'Accept': 'application/json',
+      'Accept-Language': 'en-US,en;q=0.9',
+      'Referer': 'https://www.pixiv.net/'
+    };
+
+
+    try {
+      const response = await axios.get(apiUrl, { headers });
+      if (response.data && response.data.body) {
+        const data = response.data.body;
+        const baseUrl = req.protocol + '://' + req.get('host');
+        return {
+          id: data.id,
+          title: data.title,
+          description: data.description,
+          artist: {
+            id: data.userId,
+            name: data.userName,
+            account: data.userAccount
+          },
+          tags: data.tags ? data.tags.tags.map(tag => ({
+            tag: tag.tag,
+            translation: tag.translation ? tag.translation.en : null
+          })) : [],
+          images: {
+            thumbnail: data.urls ? data.urls.thumb : null,
+            small: data.urls ? data.urls.small : null,
+            regular: data.urls ? data.urls.regular : null,
+            original: data.urls ? data.urls.original : null
+          },
+          proxiedImages: {
+            thumbnail: data.urls?.thumb ? `${baseUrl}/api/image-proxy?url=${encodeURIComponent(data.urls.thumb)}` : null,
+            small: data.urls?.small ? `${baseUrl}/api/image-proxy?url=${encodeURIComponent(data.urls.small)}` : null,
+            regular: data.urls?.regular ? `${baseUrl}/api/image-proxy?url=${encodeURIComponent(data.urls.regular)}` : null,
+            original: data.urls?.original ? `${baseUrl}/api/image-proxy?url=${encodeURIComponent(data.urls.original)}` : null
+          },
+          stats: {
+            views: data.viewCount,
+            bookmarks: data.bookmarkCount,
+            likes: data.likeCount,
+            comments: data.commentCount
+          },
+          pageCount: data.pageCount,
+          width: data.width,
+          height: data.height,
+          createDate: data.createDate,
+          uploadDate: data.uploadDate,
+          type: data.illustType === 0 ? 'illustration' : data.illustType === 1 ? 'manga' : 'ugoira',
+          isR18: data.xRestrict === 1,
+          isAI: data.aiType === 2
+        };
+      }
+    } catch (apiError) {
+      console.log('API endpoint failed, trying page scraping...');
+    }
+
+
+    const pageResponse = await axios.get(pageUrl, { headers });
+    const $ = cheerio.load(pageResponse.data);
+
 
-    const buffer = await response.arrayBuffer();
-    const imageBuffer = Buffer.from(buffer);
+    let metadata = null;
+    $('script').each((i, elem) => {
+      const text = $(elem).html();
+      if (text && text.includes('meta-preload-data')) {
+        try {
+          const match = text.match(/{"timestamp".*?}(?=<\/script>)/);
+          if (match) {
+            const data = JSON.parse(match[0]);
+            if (data.illust && data.illust[artworkId]) {
+              const illust = data.illust[artworkId];
+              const baseUrl = req.protocol + '://' + req.get('host');
+              metadata = {
+                id: illust.id,
+                title: illust.title,
+                description: illust.description,
+                artist: {
+                  id: illust.userId,
+                  name: illust.userName,
+                  account: illust.userAccount || null
+                },
+                tags: illust.tags ? illust.tags.tags.map(tag => ({
+                  tag: tag.tag,
+                  translation: tag.translation ? tag.translation.en : null
+                })) : [],
+                images: {
+                  thumbnail: illust.urls ? illust.urls.thumb : null,
+                  small: illust.urls ? illust.urls.small : null,
+                  regular: illust.urls ? illust.urls.regular : null,
+                  original: illust.urls ? illust.urls.original : null
+                },
+                proxiedImages: {
+                  thumbnail: illust.urls?.thumb ? `${baseUrl}/api/image-proxy?url=${encodeURIComponent(illust.urls.thumb)}` : null,
+                  small: illust.urls?.small ? `${baseUrl}/api/image-proxy?url=${encodeURIComponent(illust.urls.small)}` : null,
+                  regular: illust.urls?.regular ? `${baseUrl}/api/image-proxy?url=${encodeURIComponent(illust.urls.regular)}` : null,
+                  original: illust.urls?.original ? `${baseUrl}/api/image-proxy?url=${encodeURIComponent(illust.urls.original)}` : null
+                },
+                stats: {
+                  views: illust.viewCount || 0,
+                  bookmarks: illust.bookmarkCount || 0,
+                  likes: illust.likeCount || 0,
+                  comments: illust.commentCount || 0
+                },
+                pageCount: illust.pageCount || 1,
+                width: illust.width,
+                height: illust.height,
+                createDate: illust.createDate,
+                uploadDate: illust.uploadDate,
+                type: illust.illustType === 0 ? 'illustration' : illust.illustType === 1 ? 'manga' : 'ugoira',
+                isR18: illust.xRestrict === 1,
+                isAI: illust.aiType === 2
+              };
+            }
+          }
+        } catch (e) {
 
-    // Get image metadata
-    const metadata = await sharp(imageBuffer).metadata();
+        }
+      }
+    });
 
-    // Resize if necessary
-    let processedImage = imageBuffer;
-    if (metadata.width > 1000 || metadata.height > 1000) {
-      processedImage = await sharp(imageBuffer)
-        .resize(1000, 1000, { fit: 'inside' })
-        .toBuffer();
+    if (metadata) {
+      return metadata;
     }
 
-    // Scan with Chrome Lens OCR
-    const data = await lens.scanByBuffer(processedImage);
-    const combinedText = data.segments.map(segment => segment.text).join('\n\n');
 
-    res.json({ combinedText, detailedData: data });
+    const baseUrl = req.protocol + '://' + req.get('host');
+    const ogImage = $('meta[property="og:image"]').attr('content');
+    return {
+      id: artworkId,
+      title: $('meta[property="og:title"]').attr('content') || 'Unknown',
+      description: $('meta[property="og:description"]').attr('content') || '',
+      artist: {
+        name: $('meta[name="twitter:creator"]').attr('content') || 'Unknown'
+      },
+      images: {
+        thumbnail: ogImage || null
+      },
+      proxiedImages: {
+        thumbnail: ogImage ? `${baseUrl}/api/image-proxy?url=${encodeURIComponent(ogImage)}` : null
+      },
+      tags: [],
+      stats: {},
+      pageCount: 1,
+      type: 'illustration'
+    };
+
   } catch (error) {
-    res.status(500).json({ error: error.message });
+    throw new Error(`Failed to fetch metadata: ${error.message}`);
+  }
+}
+
+
+app.get('/api/image-proxy', async (req, res) => {
+  try {
+    const { url } = req.query;
+
+    if (!url) {
+      return res.status(400).json({
+        error: 'Please provide an image URL',
+        example: '/api/image-proxy?url=https://i.pximg.net/...'
+      });
+    }
+
+
+    if (!url.includes('pximg.net')) {
+      return res.status(400).json({
+        error: 'Only Pixiv image URLs are supported'
+      });
+    }
+
+    const headers = {
+      'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+      'Referer': 'https://www.pixiv.net/',
+      'Accept': 'image/webp,image/apng,image/*,*/*;q=0.8',
+      'Accept-Language': 'en-US,en;q=0.9'
+    };
+
+    const response = await axios.get(url, { 
+      headers,
+      responseType: 'stream',
+      timeout: 30000
+    });
+
+
+    const contentType = response.headers['content-type'] || 'image/jpeg';
+    res.setHeader('Content-Type', contentType);
+    res.setHeader('Cache-Control', 'public, max-age=3600'); // Cache for 1 hour
+
+
+    response.data.pipe(res);
+
+  } catch (error) {
+    if (error.response && error.response.status === 403) {
+      res.status(403).json({
+        error: 'Access forbidden - image may be restricted or URL invalid'
+      });
+    } else {
+      res.status(500).json({
+        error: `Failed to fetch image: ${error.message}`
+      });
+    }
   }
 });
 
-app.listen(PORT, HOST, () => {
-  console.log(`Running on http://${HOST}:${PORT}`);
+
+app.get('/api/pixiv', async (req, res) => {
+  try {
+    const { url, id } = req.query;
+
+    if (!url && !id) {
+      return res.status(400).json({
+        error: 'Please provide either a Pixiv URL or artwork ID',
+        example: '/api/pixiv?url=https://www.pixiv.net/en/artworks/123456789'
+      });
+    }
+
+    let artworkId = id;
+    if (url) {
+      artworkId = extractPixivId(url);
+      if (!artworkId) {
+        return res.status(400).json({
+          error: 'Invalid Pixiv URL format',
+          supportedFormats: [
+            'https://www.pixiv.net/en/artworks/{id}',
+            'https://www.pixiv.net/artworks/{id}',
+            'https://www.pixiv.net/member_illust.php?illust_id={id}'
+          ]
+        });
+      }
+    }
+
+    const metadata = await getPixivMetadata(artworkId, req);
+
+    res.json({
+      success: true,
+      data: metadata
+    });
+
+  } catch (error) {
+    res.status(500).json({
+      error: error.message,
+      success: false
+    });
+  }
 });
+
+
+app.get('/health', (req, res) => {
+  res.json({ status: 'OK', timestamp: new Date().toISOString() });
+});
+
+
+app.get('/', (req, res) => {
+  res.json({
+    name: 'Pixiv Metadata API',
+    version: '1.0.0',
+    endpoints: {
+      '/api/pixiv': {
+        method: 'GET',
+        description: 'Get metadata for a Pixiv artwork',
+        parameters: {
+          url: 'Pixiv artwork URL (optional if id is provided)',
+          id: 'Pixiv artwork ID (optional if url is provided)'
+        },
+        example: '/api/pixiv?url=https://www.pixiv.net/en/artworks/123456789'
+      },
+      '/api/image-proxy': {
+        method: 'GET',
+        description: 'Proxy Pixiv images to bypass hotlink protection',
+        parameters: {
+          url: 'Pixiv image URL (pximg.net)'
+        },
+        example: '/api/image-proxy?url=https://i.pximg.net/...'
+      },
+      '/health': {
+        method: 'GET',
+        description: 'Health check endpoint'
+      }
+    }
+  });
+});
+
+app.listen(PORT, () => {
+  console.log(`Pixiv Metadata API running on port ${PORT}`);
+  console.log(`Access the API at: http://localhost:${PORT}/api/pixiv`);
+});
+
+module.exports = app;