viruagent-cli 0.3.2 → 0.3.4

package/src/providers/tistory/imageNormalization.js

@@ -0,0 +1,301 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const normalizeKageFromUrl = (value) => {
+  const trimmed = String(value || '').trim();
+  if (!trimmed) return null;
+
+  if (trimmed.startsWith('kage@')) {
+    return trimmed.replace(/["'`> )\]]+$/u, '');
+  }
+
+  try {
+    const parsed = new URL(trimmed);
+    const urlPath = parsed.pathname || '';
+    const dnaIndex = urlPath.indexOf('/dna/');
+    if (dnaIndex >= 0) {
+      const keyPath = urlPath.slice(dnaIndex + '/dna/'.length).replace(/^\/+/, '');
+      if (keyPath) {
+        return `kage@${keyPath}`;
+      }
+    }
+  } catch {
+    // URL 파싱이 실패하면 기존 정규식 경로로 폴백
+  }
+
+  const directKageMatch = trimmed.match(/kage@([^|\s\]>"']+)/u);
+  if (directKageMatch?.[1]) {
+    return `kage@${directKageMatch[1]}`;
+  }
+
+  const dnaMatch = trimmed.match(/\/dna\/([^?#\s]+)/u);
+  if (dnaMatch?.[1]) {
+    return `kage@${dnaMatch[1].replace(/["'`> )\]]+$/u, '')}`;
+  }
+
+  if (/^[A-Za-z0-9_-]{10,}$/u.test(trimmed)) {
+    return `kage@${trimmed}`;
+  }
+
+  const rawPathMatch = trimmed.match(/([^/?#\s]+\.[A-Za-z0-9]+)$/u);
+  if (rawPathMatch?.[0] && !trimmed.includes('://') && trimmed.includes('/')) {
+    return `kage@${trimmed}`;
+  }
+
+  if (!trimmed.includes('://') && !trimmed.includes(' ')) {
+    if (trimmed.startsWith('kage@') || trimmed.includes('/')) {
+      return `kage@${trimmed}`;
+    }
+  }
+
+  return null;
+};
+
+const normalizeImageUrlForThumbnail = (value) => {
+  const trimmed = String(value || '').trim();
+  if (!trimmed) return null;
+  if (!/^https?:\/\//i.test(trimmed)) {
+    return null;
+  }
+  if (trimmed.includes('data:image')) {
+    return null;
+  }
+  if (trimmed.includes(' ') || trimmed.length < 10) {
+    return null;
+  }
+  const imageExtensionMatch = trimmed.match(/\.(?:jpg|jpeg|png|gif|webp|bmp|avif|svg)(?:$|\?|#)/i);
+  return imageExtensionMatch ? trimmed : null;
+};
+
+const normalizeThumbnailForPublish = (value) => {
+  const normalized = normalizeKageFromUrl(value);
+  if (!normalized) {
+    return normalizeImageUrlForThumbnail(value);
+  }
+
+  const body = normalized.replace(/^kage@/i, '').split(/[?#]/)[0];
+  const pathPart = body?.trim();
+  if (!pathPart) return null;
+  const hasImageFile = /\/[^/]+\.[A-Za-z0-9]+$/u.test(pathPart);
+  if (hasImageFile) {
+    return `kage@${pathPart}`;
+  }
+  const suffix = pathPart.endsWith('/') ? 'img.jpg' : '/img.jpg';
+  return `kage@${pathPart}${suffix}`;
+};
+
+const extractKageFromCandidate = (value) => {
+  const normalized = normalizeThumbnailForPublish(value);
+  if (normalized) {
+    return normalized;
+  }
+
+  if (typeof value !== 'string') {
+    return null;
+  }
+
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+
+  const imageTagMatch = trimmed.match(/\[##_Image\|([^|]+)\|/);
+  if (imageTagMatch?.[1]) {
+    return normalizeKageFromUrl(imageTagMatch[1]);
+  }
+
+  if (!trimmed.includes('://') && trimmed.includes('|')) {
+    const match = trimmed.match(/kage@[^\s|]+/);
+    if (match?.[0]) {
+      return match[0];
+    }
+  }
+
+  return null;
+};
+
+const normalizeUploadedImageThumbnail = (uploadedImage) => {
+  const candidates = [
+    uploadedImage?.uploadedKage,
+    uploadedImage?.raw?.kage,
+    uploadedImage?.raw?.uploadedKage,
+    uploadedImage?.uploadedKey,
+    uploadedImage?.raw?.key,
+    uploadedImage?.raw?.attachmentKey,
+    uploadedImage?.raw?.imageKey,
+    uploadedImage?.raw?.id,
+    uploadedImage?.raw?.url,
+    uploadedImage?.raw?.attachmentUrl,
+    uploadedImage?.raw?.thumbnail,
+    uploadedImage?.url,
+    uploadedImage?.uploadedUrl,
+  ];
+
+  for (const candidate of candidates) {
+    const normalized = extractKageFromCandidate(candidate);
+    if (normalized) {
+      const final = normalizeThumbnailForPublish(normalized);
+      if (final) {
+        return final;
+      }
+    }
+  }
+
+  return null;
+};
+
+const buildTistoryImageTag = (uploadedImage, keyword) => {
+  const alt = String(keyword || '').replace(/"/g, '&quot;');
+  const normalizedKage = normalizeUploadedImageThumbnail(uploadedImage);
+  if (normalizedKage) {
+    return `<p data-ke-size="size16">[##_Image|${normalizedKage}|CDM|1.3|{"originWidth":0,"originHeight":0,"style":"alignCenter"}_##]</p>`;
+  }
+  if (uploadedImage?.uploadedKage) {
+    return `<p data-ke-size="size16">[##_Image|${uploadedImage.uploadedKage}|CDM|1.3|{"originWidth":0,"originHeight":0,"style":"alignCenter"}_##]</p>`;
+  }
+  if (uploadedImage?.uploadedUrl) {
+    return `<p data-ke-size="size16"><img src="${uploadedImage.uploadedUrl}" alt="${alt}" /></p>`;
+  }
+
+  return `<p data-ke-size="size16"><img src="${uploadedImage.uploadedUrl}" alt="${alt}" /></p>`;
+};
+
+const guessExtensionFromContentType = (contentType = '') => {
+  const normalized = contentType.toLowerCase();
+  if (normalized.includes('png')) return 'png';
+  if (normalized.includes('webp')) return 'webp';
+  if (normalized.includes('gif')) return 'gif';
+  if (normalized.includes('bmp')) return 'bmp';
+  if (normalized.includes('jpeg') || normalized.includes('jpg')) return 'jpg';
+  return 'jpg';
+};
+
+const isImageContentType = (contentType = '') => {
+  const normalized = contentType.toLowerCase();
+  return normalized.startsWith('image/') || normalized.includes('application/octet-stream') || normalized.includes('binary/octet-stream');
+};
+
+const guessExtensionFromUrl = (rawUrl) => {
+  try {
+    const parsed = new URL(rawUrl);
+    const match = parsed.pathname.match(/\.([a-zA-Z0-9]+)(?:$|\?)/);
+    if (!match) return null;
+    const ext = match[1].toLowerCase();
+    if (['jpg', 'jpeg', 'png', 'gif', 'webp', 'bmp', 'svg', 'avif', 'heic', 'heif', 'ico'].includes(ext)) {
+      return ext === 'jpeg' ? 'jpg' : ext;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+};
+
+const getImageSignatureExtension = (buffer) => {
+  if (!Buffer.isBuffer(buffer) || buffer.length < 12) return null;
+  const magic4 = buffer.slice(0, 4).toString('hex');
+  const magic2 = buffer.slice(0, 2).toString('hex');
+  const magic8 = buffer.slice(8, 12).toString('hex');
+  if (magic2 === 'ffd8') return 'jpg';
+  if (magic4 === '89504e47') return 'png';
+  if (magic4 === '47494638') return 'gif';
+  if (magic4 === '52494646' && magic8 === '57454250') return 'webp';
+  if (magic2 === '424d') return 'bmp';
+  return null;
+};
+
+const resolveLocalImagePath = (value) => {
+  if (typeof value !== 'string') {
+    return null;
+  }
+
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+
+  if (trimmed.startsWith('file://')) {
+    try {
+      const filePath = decodeURIComponent(new URL(trimmed).pathname);
+      if (fs.existsSync(filePath)) {
+        const stat = fs.statSync(filePath);
+        if (stat.isFile()) return filePath;
+      }
+    } catch {}
+    return null;
+  }
+
+  const expanded = trimmed.startsWith('~')
+    ? path.join(os.homedir(), trimmed.slice(1))
+    : trimmed;
+  const candidate = path.isAbsolute(expanded) ? expanded : path.resolve(process.cwd(), expanded);
+  if (!fs.existsSync(candidate)) return null;
+
+  try {
+    const stat = fs.statSync(candidate);
+    return stat.isFile() ? candidate : null;
+  } catch {
+    return null;
+  }
+};
+
+const normalizeImageInput = (value) => {
+  if (typeof value !== 'string') {
+    return null;
+  }
+  const text = value.trim();
+  if (!text) {
+    return null;
+  }
+  const localPath = resolveLocalImagePath(text);
+  if (localPath) {
+    return localPath;
+  }
+
+  try {
+    const parsed = new URL(text);
+    if (!['http:', 'https:'].includes(parsed.protocol)) {
+      return null;
+    }
+    return parsed.toString();
+  } catch (error) {
+    return null;
+  }
+};
+
+const normalizeImageInputs = (inputs) => {
+  if (typeof inputs === 'string') {
+    return inputs.split(',').map((item) => normalizeImageInput(item)).filter(Boolean);
+  }
+
+  if (!Array.isArray(inputs)) {
+    return [];
+  }
+
+  return inputs.map(normalizeImageInput).filter(Boolean);
+};
+
+const extractThumbnailFromContent = (content = '') => {
+  const match = String(content).match(/\[##_Image\|([^|]+)\|/);
+  if (!match?.[1]) {
+    const imgMatch = String(content).match(/<img[^>]+src=["']([^"']+)["'][^>]*>/i);
+    if (!imgMatch?.[1]) {
+      return null;
+    }
+    return normalizeImageUrlForThumbnail(imgMatch[1]);
+  }
+  return extractKageFromCandidate(match[1]);
+};
+
+module.exports = {
+  normalizeKageFromUrl,
+  normalizeImageUrlForThumbnail,
+  normalizeThumbnailForPublish,
+  extractKageFromCandidate,
+  normalizeUploadedImageThumbnail,
+  buildTistoryImageTag,
+  guessExtensionFromContentType,
+  isImageContentType,
+  guessExtensionFromUrl,
+  getImageSignatureExtension,
+  resolveLocalImagePath,
+  normalizeImageInput,
+  normalizeImageInputs,
+  extractThumbnailFromContent,
+};

package/src/providers/tistory/imageSources.js

@@ -0,0 +1,270 @@
+const crypto = require('crypto');
+const { imageTrace } = require('./utils');
+const { fetchText, fetchTextWithHeaders, normalizeAbsoluteUrl, extractDuckDuckGoVqd } = require('./fetchLayer');
+
+const sanitizeImageQueryForProvider = (value = '') => {
+  return String(value || '')
+    .trim()
+    .replace(/[^a-z0-9가-힣\s]/gi, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+};
+
+const buildLoremFlickrImageCandidates = (keyword = '') => {
+  const safeKeyword = sanitizeImageQueryForProvider(keyword);
+  if (!safeKeyword) {
+    return [];
+  }
+  const encoded = encodeURIComponent(safeKeyword.replace(/\s+/g, ','));
+  return [
+    `https://loremflickr.com/1200/800/${encoded}`,
+    `https://loremflickr.com/g/1200/800/${encoded}`,
+  ];
+};
+
+const buildPicsumImageCandidates = (keyword = '') => {
+  const safeKeyword = sanitizeImageQueryForProvider(keyword);
+  const hash = safeKeyword
+    ? crypto.createHash('md5').update(safeKeyword).digest('hex').slice(0, 10)
+    : 'default';
+  return [
+    `https://picsum.photos/seed/${hash}/1200/800`,
+    `https://picsum.photos/1200/800`,
+  ];
+};
+
+const buildPlaceholderImageCandidates = () => {
+  return [
+    'https://placehold.co/1200x800.png',
+    'https://via.placeholder.com/1200x800.jpg',
+    'https://dummyimage.com/1200x800/000/fff.png&text=thumbnail',
+  ];
+};
+
+const buildWikimediaImageCandidates = async (keyword = '') => {
+  const safeKeyword = sanitizeImageQueryForProvider(keyword);
+  if (!safeKeyword) {
+    return [];
+  }
+  try {
+    const query = encodeURIComponent(`${safeKeyword} file`);
+    const apiUrl = `https://commons.wikimedia.org/w/api.php?action=query&generator=search&gsrsearch=${query}&gsrnamespace=6&gsrlimit=8&prop=imageinfo&iiprop=url&iiurlwidth=1200&format=json&origin=*`;
+    imageTrace('wikimedia.request', { keyword: safeKeyword, apiUrl });
+    const raw = await fetchText(apiUrl);
+    const parsed = JSON.parse(raw || '{}');
+    const pages = parsed?.query?.pages || {};
+    const candidates = [];
+    for (const page of Object.values(pages)) {
+      const imageInfo = Array.isArray(page?.imageinfo) ? page.imageinfo : [];
+      if (imageInfo.length === 0) {
+        continue;
+      }
+      const first = imageInfo[0];
+      if (first?.thumburl) {
+        candidates.push(first.thumburl);
+      } else if (first?.url) {
+        candidates.push(first.url);
+      }
+    }
+    imageTrace('wikimedia.response', { keyword: safeKeyword, count: candidates.length });
+    return candidates;
+  } catch {
+    imageTrace('wikimedia.error', { keyword: safeKeyword });
+    return [];
+  }
+};
+
+const fetchDuckDuckGoImageResults = async (query = '') => {
+  try {
+    const safeKeyword = String(query || '').trim();
+    if (!safeKeyword) return [];
+    const searchUrl = `https://duckduckgo.com/?ia=images&origin=funnel_home_google&t=h_&q=${encodeURIComponent(safeKeyword)}&chip-select=search&iax=images`;
+    imageTrace('duckduckgo.searchPage', { query: safeKeyword, searchUrl });
+    const searchText = await fetchTextWithHeaders(searchUrl, {
+      Accept: 'text/html,application/xhtml+xml',
+      Referer: 'https://duckduckgo.com/',
+    });
+    const vqd = extractDuckDuckGoVqd(searchText);
+    if (!vqd) return [];
+
+    const apiCandidates = [
+      `https://duckduckgo.com/i.js?l=wt-wt&o=json&q=${encodeURIComponent(safeKeyword)}&vqd=${encodeURIComponent(vqd)}&ia=images&iax=images`,
+      `https://duckduckgo.com/i.js?l=wt-wt&o=json&q=${encodeURIComponent(safeKeyword)}&ia=images&iax=images&vqd=${encodeURIComponent(vqd)}&s=0`,
+      `https://duckduckgo.com/i.js?o=json&q=${encodeURIComponent(safeKeyword)}&ia=images&iax=images&vqd=${encodeURIComponent(vqd)}&p=1`,
+      `https://duckduckgo.com/i.js?l=en-gb&o=json&q=${encodeURIComponent(safeKeyword)}&ia=images&iax=images&vqd=${encodeURIComponent(vqd)}`,
+    ];
+
+    const jsonHeaders = {
+      Accept: 'application/json, text/javascript, */*; q=0.01',
+      'Referer': `https://duckduckgo.com/?q=${encodeURIComponent(safeKeyword)}&ia=images&iax=images`,
+      'Origin': 'https://duckduckgo.com',
+    };
+
+    let parsed = null;
+    let apiUrl = null;
+    for (const candidate of apiCandidates) {
+      try {
+        imageTrace('duckduckgo.apiUrl', { query: safeKeyword, apiUrl: candidate });
+        const apiText = await fetchTextWithHeaders(candidate, jsonHeaders);
+        const safeText = String(apiText || '').trim();
+        if (!safeText) {
+          continue;
+        }
+        if (!safeText.startsWith('{') && !safeText.startsWith('[')) {
+          imageTrace('duckduckgo.apiParseSkipped', { query: safeKeyword, apiUrl: candidate, reason: 'nonJsonStart' });
+          continue;
+        }
+        parsed = JSON.parse(safeText);
+        if (Array.isArray(parsed.results) && parsed.results.length > 0) {
+          apiUrl = candidate;
+          break;
+        }
+      } catch {
+        imageTrace('duckduckgo.apiParseError', { query: safeKeyword, apiUrl: candidate });
+      }
+    }
+
+    if (!parsed) return [];
+    if (apiUrl) {
+      imageTrace('duckduckgo.apiUsed', { query: safeKeyword, apiUrl });
+    }
+
+    imageTrace('duckduckgo.apiResult', {
+      query: safeKeyword,
+      resultCount: Array.isArray(parsed?.results) ? parsed.results.length : 0,
+    });
+    const results = Array.isArray(parsed.results) ? parsed.results : [];
+
+    const images = [];
+    for (const item of results) {
+      if (typeof item !== 'object' || !item) continue;
+      const candidates = [
+        item.image,
+        item.thumbnail,
+        item.image_thumb,
+        item.url,
+        item.original,
+      ];
+      for (const candidate of candidates) {
+        const candidateUrl = normalizeAbsoluteUrl(candidate);
+        if (candidateUrl && !/favicon|logo|sprite|pixel/i.test(candidateUrl)) {
+          images.push(candidateUrl);
+          break;
+        }
+      }
+    }
+
+    return images;
+  } catch {
+    return [];
+  }
+};
+
+const buildKeywordImageCandidates = async (keyword = '') => {
+  const cleaned = String(keyword || '').trim().toLowerCase();
+  const compacted = cleaned
+    .replace(/[^a-z0-9가-힣\s]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+  const safeKeyword = compacted;
+  if (!safeKeyword) {
+    return [];
+  }
+  imageTrace('buildKeywordImageCandidates.start', { safeKeyword });
+
+  const duckduckgoQueries = [
+    safeKeyword,
+    `${safeKeyword} 이미지`,
+    `${safeKeyword} 뉴스`,
+  ];
+  const searchCandidates = [];
+  const seen = new Set();
+
+  const collectIfImage = (imageUrl) => {
+    const resolved = normalizeAbsoluteUrl(imageUrl);
+    if (resolved && !seen.has(resolved)) {
+      seen.add(resolved);
+      searchCandidates.push(resolved);
+    }
+  };
+
+  for (const query of duckduckgoQueries) {
+    if (searchCandidates.length >= 6) {
+      break;
+    }
+    imageTrace('buildKeywordImageCandidates.ddgQuery', { query, currentCount: searchCandidates.length });
+    const duckImages = await fetchDuckDuckGoImageResults(query);
+    imageTrace('buildKeywordImageCandidates.ddgResult', { query, count: duckImages.length });
+    for (const duckImage of duckImages.slice(0, 6)) {
+      if (searchCandidates.length >= 6) break;
+      collectIfImage(duckImage);
+    }
+  }
+
+  const fallbackQueries = [
+    safeKeyword,
+    `${safeKeyword} 이미지`,
+    `${safeKeyword} news`,
+    '뉴스',
+    '세계 뉴스',
+  ];
+  for (const query of fallbackQueries) {
+    if (searchCandidates.length >= 6) {
+      break;
+    }
+    imageTrace('buildKeywordImageCandidates.fallbackQuery', { query, currentCount: searchCandidates.length });
+    const wikiImages = await buildWikimediaImageCandidates(query);
+    imageTrace('buildKeywordImageCandidates.wikimediaResult', { query, count: wikiImages.length });
+    for (const candidate of wikiImages) {
+      if (searchCandidates.length >= 6) {
+        break;
+      }
+      collectIfImage(candidate);
+    }
+    for (const candidate of buildLoremFlickrImageCandidates(query)) {
+      imageTrace('buildKeywordImageCandidates.loremflickrCandidate', { query, candidate });
+      if (searchCandidates.length >= 6) {
+        break;
+      }
+      collectIfImage(candidate);
+    }
+    for (const candidate of buildPicsumImageCandidates(query)) {
+      imageTrace('buildKeywordImageCandidates.picsumCandidate', { query, candidate });
+      if (searchCandidates.length >= 6) {
+        break;
+      }
+      collectIfImage(candidate);
+    }
+    for (const candidate of buildPlaceholderImageCandidates()) {
+      imageTrace('buildKeywordImageCandidates.placeholderCandidate', { candidate });
+      if (searchCandidates.length >= 6) {
+        break;
+      }
+      collectIfImage(candidate);
+    }
+  }
+
+  return searchCandidates.slice(0, 6);
+};
+
+const buildFallbackImageSources = async (keyword = '') => {
+  const trimmedKeyword = String(keyword || '').trim();
+  if (!trimmedKeyword) {
+    return [];
+  }
+  if (trimmedKeyword.startsWith('image-')) {
+    return [];
+  }
+  return buildKeywordImageCandidates(trimmedKeyword);
+};
+
+module.exports = {
+  sanitizeImageQueryForProvider,
+  buildLoremFlickrImageCandidates,
+  buildPicsumImageCandidates,
+  buildPlaceholderImageCandidates,
+  buildWikimediaImageCandidates,
+  fetchDuckDuckGoImageResults,
+  buildKeywordImageCandidates,
+  buildFallbackImageSources,
+};