neoagent 2.3.1-beta.85 → 2.3.1-beta.87

package/server/services/social_video/captions.js

@@ -0,0 +1,187 @@
+'use strict';
+
+const MAX_VTT_BYTES = 2 * 1024 * 1024;
+const MAX_INPUT_BYTES = MAX_VTT_BYTES;
+
+function normalizeLanguageCode(value) {
+  return String(value || '').trim().toLowerCase();
+}
+
+function pickCaptionTrack(captionGroups = {}, preferredLanguages = []) {
+  const tracks = [];
+  for (const [language, items] of Object.entries(captionGroups || {})) {
+    if (!Array.isArray(items)) continue;
+    for (const item of items) {
+      if (!item || typeof item !== 'object') continue;
+      const url = String(item.url || '').trim();
+      if (!url) continue;
+      tracks.push({
+        language: normalizeLanguageCode(language),
+        url,
+        ext: normalizeLanguageCode(item.ext || ''),
+        name: String(item.name || '').trim(),
+      });
+    }
+  }
+  if (tracks.length === 0) return null;
+
+  const preferred = preferredLanguages.map(normalizeLanguageCode).filter(Boolean);
+  const preferredOrder = preferred.length > 0 ? preferred : ['en', 'en-us', 'en-gb'];
+  const preferredExt = ['vtt', 'webvtt', 'srt', 'json3'];
+
+  const scoreTrack = (track) => {
+    const langIdx = preferredOrder.findIndex((code) => track.language === code || track.language.startsWith(`${code}-`));
+    const langScore = langIdx === -1 ? 999 : langIdx;
+    const extIdx = preferredExt.findIndex((ext) => track.ext === ext);
+    const extScore = extIdx === -1 ? 999 : extIdx;
+    return (langScore * 100) + extScore;
+  };
+
+  return tracks
+    .map((track) => ({ track, score: scoreTrack(track) }))
+    .sort((left, right) => left.score - right.score)[0]?.track || null;
+}
+
+function stripTags(text) {
+  return String(text || '')
+    .replace(/<[^>]+>/g, ' ')
+    .replace(/\{\\an\d+\}/g, ' ')
+    .replace(/\[[^\]]+\]/g, ' ')
+    .replace(/&nbsp;/g, ' ')
+    .replace(/&amp;/g, '&')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function inputByteLength(value) {
+  if (Buffer.isBuffer(value)) return value.byteLength;
+  return Buffer.byteLength(String(value || ''), 'utf8');
+}
+
+function stripXml(value) {
+  return String(value || '')
+    .replace(/<[^>]+>/g, ' ')
+    .replace(/&nbsp;/gi, ' ')
+    .replace(/&amp;/gi, '&')
+    .replace(/&lt;/gi, '<')
+    .replace(/&gt;/gi, '>')
+    .replace(/&quot;/gi, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function parseWebVttToText(vtt) {
+  if (inputByteLength(vtt) > MAX_VTT_BYTES) {
+    throw new Error(`parseWebVttToText input exceeds MAX_VTT_BYTES (${MAX_VTT_BYTES}).`);
+  }
+  const lines = String(vtt || '').split(/\r?\n/);
+  const chunks = [];
+  for (const line of lines) {
+    const clean = line.trim();
+    if (!clean) continue;
+    if (/^WEBVTT/i.test(clean)) continue;
+    if (/^NOTE\b/i.test(clean)) continue;
+    if (/^\d+$/.test(clean)) continue;
+    if (/^\d{2}:\d{2}:\d{2}[.,]\d{3}\s+-->/.test(clean) || /^\d{2}:\d{2}[.,]\d{3}\s+-->/.test(clean)) continue;
+    const normalized = stripTags(clean);
+    if (!normalized) continue;
+    if (chunks[chunks.length - 1] === normalized) continue;
+    chunks.push(normalized);
+  }
+  return chunks.join(' ').trim();
+}
+
+function parseSrtToText(srt) {
+  return parseWebVttToText(String(srt || '').replace(/,/g, '.'));
+}
+
+function parseJson3ToText(raw) {
+  if (inputByteLength(raw) > MAX_INPUT_BYTES) {
+    return '';
+  }
+  let payload;
+  try {
+    payload = JSON.parse(String(raw || ''));
+  } catch {
+    return '';
+  }
+  const events = Array.isArray(payload?.events) ? payload.events : [];
+  const parts = [];
+  for (const event of events) {
+    const segs = Array.isArray(event?.segs) ? event.segs : [];
+    const text = segs
+      .map((segment) => String(segment?.utf8 || '').trim())
+      .filter(Boolean)
+      .join(' ');
+    const normalized = stripTags(text);
+    if (!normalized) continue;
+    if (parts[parts.length - 1] === normalized) continue;
+    parts.push(normalized);
+  }
+  return parts.join(' ').trim();
+}
+
+function parseTtmlToText(raw) {
+  if (inputByteLength(raw) > MAX_INPUT_BYTES) {
+    return '';
+  }
+  const text = String(raw || '');
+  const parts = [];
+  const paragraphRe = /<p\b[^>]*>([\s\S]*?)<\/p>/gi;
+  let match = paragraphRe.exec(text);
+  while (match) {
+    const parsed = stripXml(match[1]);
+    if (parsed && parts[parts.length - 1] !== parsed) {
+      parts.push(parsed);
+    }
+    match = paragraphRe.exec(text);
+  }
+  if (parts.length > 0) {
+    return parts.join(' ').trim();
+  }
+  return stripXml(text);
+}
+
+function parseCaptionText(raw, extension = '') {
+  const ext = normalizeLanguageCode(extension);
+  if (ext === 'vtt' || ext === 'webvtt') {
+    return parseWebVttToText(raw);
+  }
+  if (ext === 'ttml') {
+    return parseTtmlToText(raw);
+  }
+  if (ext === 'srt') {
+    return parseSrtToText(raw);
+  }
+  if (ext === 'json3' || ext === 'json') {
+    return parseJson3ToText(raw);
+  }
+  if (/^\s*<tt\b/i.test(String(raw || '')) || /xmlns\s*=\s*["'][^"']*ttml/i.test(String(raw || ''))) {
+    return parseTtmlToText(raw);
+  }
+  return parseWebVttToText(raw);
+}
+
+function decideTranscriptPath(options = {}) {
+  if (options.forceStt) {
+    return { mode: 'stt', reason: 'forced' };
+  }
+  if (options.captionTrack) {
+    return { mode: 'captions', reason: 'captions_present' };
+  }
+  return { mode: 'stt', reason: 'captions_missing' };
+}
+
+module.exports = {
+  decideTranscriptPath,
+  normalizeLanguageCode,
+  parseCaptionText,
+  parseJson3ToText,
+  parseSrtToText,
+  parseTtmlToText,
+  parseWebVttToText,
+  pickCaptionTrack,
+  MAX_INPUT_BYTES,
+  MAX_VTT_BYTES,
+};

package/server/services/social_video/frame.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const path = require('path');
+
+function pickDeterministicFrameSecond(durationSeconds) {
+  const duration = Number(durationSeconds);
+  if (!Number.isFinite(duration) || duration <= 0) {
+    return 2;
+  }
+  const target = Math.round(duration * 0.33);
+  return Math.max(1, Math.min(target, 120));
+}
+
+function inferImageContentType(filePath) {
+  const ext = path.extname(String(filePath || '')).toLowerCase();
+  if (ext === '.jpg' || ext === '.jpeg') return 'image/jpeg';
+  if (ext === '.webp') return 'image/webp';
+  if (ext === '.png') return 'image/png';
+  return 'application/octet-stream';
+}
+
+function normalizeFrameReference(input = {}) {
+  if (!input || typeof input !== 'object') {
+    return null;
+  }
+  if (!input.url) {
+    return null;
+  }
+  return {
+    url: input.url,
+    artifactId: input.artifactId || null,
+    mimeType: input.mimeType || null,
+    byteSize: Number.isFinite(Number(input.byteSize)) ? Number(input.byteSize) : null,
+    source: input.source || 'frame',
+  };
+}
+
+module.exports = {
+  inferImageContentType,
+  normalizeFrameReference,
+  pickDeterministicFrameSecond,
+};

package/server/services/social_video/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const { SocialVideoService } = require('./service');
+
+module.exports = {
+  SocialVideoService,
+};

package/server/services/social_video/metadata.js

@@ -0,0 +1,63 @@
+'use strict';
+
+function decodeHtmlEntities(text) {
+  return String(text || '')
+    .replace(/&/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/&#x27;/gi, "'")
+    .trim();
+}
+
+function collapseWhitespace(text) {
+  return String(text || '').replace(/\s+/g, ' ').trim();
+}
+
+function readHtmlTitle(html) {
+  const match = String(html || '').match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+  return match ? collapseWhitespace(decodeHtmlEntities(match[1])) : '';
+}
+
+function readCanonicalUrl(html) {
+  const match = String(html || '').match(
+    /<link\b(?=[^>]*\brel=["'][^"']*canonical[^"']*["'])(?=[^>]*\bhref=["']([^"']+)["'])[^>]*>/i,
+  );
+  return match ? match[1].trim() : '';
+}
+
+function readMetaTagContent(html, key, attr = 'name') {
+  const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const pattern = new RegExp(
+    `<meta[^>]+${attr}=["']${escaped}["'][^>]*content=["']([\\s\\S]*?)["'][^>]*>|<meta[^>]+content=["']([\\s\\S]*?)["'][^>]*${attr}=["']${escaped}["'][^>]*>`,
+    'i',
+  );
+  const match = String(html || '').match(pattern);
+  const content = match ? match[1] || match[2] || '' : '';
+  return collapseWhitespace(decodeHtmlEntities(content));
+}
+
+function extractPublicMetadataFromHtml(html, fallbackUrl = '') {
+  const title = readMetaTagContent(html, 'og:title', 'property')
+    || readMetaTagContent(html, 'twitter:title', 'name')
+    || readHtmlTitle(html);
+  const description = readMetaTagContent(html, 'description', 'name')
+    || readMetaTagContent(html, 'og:description', 'property')
+    || readMetaTagContent(html, 'twitter:description', 'name');
+  const canonicalUrl = readCanonicalUrl(html) || fallbackUrl;
+  return {
+    title,
+    description,
+    canonicalUrl,
+  };
+}
+
+module.exports = {
+  collapseWhitespace,
+  decodeHtmlEntities,
+  extractPublicMetadataFromHtml,
+  readCanonicalUrl,
+  readHtmlTitle,
+  readMetaTagContent,
+};

package/server/services/social_video/result.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const { normalizeFrameReference } = require('./frame');
+
+function isPlainObject(obj) {
+  return !!obj
+    && typeof obj === 'object'
+    && !Array.isArray(obj)
+    && obj.constructor === Object;
+}
+
+function normalizeWarningList(items) {
+  return (Array.isArray(items) ? items : [])
+    .map((item) => String(item || '').trim())
+    .filter(Boolean);
+}
+
+function normalizeErrorList(items) {
+  return (Array.isArray(items) ? items : [])
+    .map((item) => {
+      if (typeof item === 'string') return { message: item };
+      if (!item || typeof item !== 'object') return null;
+      const message = String(item.message || '').trim();
+      if (!message) return null;
+      return {
+        code: item.code ? String(item.code) : undefined,
+        message,
+      };
+    })
+    .filter(Boolean);
+}
+
+function shapeSocialVideoResult(input = {}) {
+  const errors = normalizeErrorList(input.errors);
+  const warnings = normalizeWarningList(input.warnings);
+  return {
+    sourceUrl: String(input.sourceUrl || '').trim(),
+    resolvedUrl: String(input.resolvedUrl || '').trim(),
+    canonicalUrl: String(input.canonicalUrl || '').trim() || null,
+    platform: String(input.platform || 'unknown').trim(),
+    title: String(input.title || '').trim(),
+    description: String(input.description || '').trim(),
+    transcript: String(input.transcript || '').trim(),
+    transcriptSource: String(input.transcriptSource || '').trim() || 'unavailable',
+    frameImage: normalizeFrameReference(input.frameImage),
+    metadata: isPlainObject(input.metadata)
+      ? input.metadata
+      : {},
+    setup: isPlainObject(input.setup)
+      ? input.setup
+      : null,
+    warnings,
+    errors,
+    partial: warnings.length > 0 || errors.length > 0,
+  };
+}
+
+module.exports = {
+  normalizeErrorList,
+  isPlainObject,
+  normalizeWarningList,
+  shapeSocialVideoResult,
+};