1import type { ExtractedDocument } from "../../extract/document";
2import { detectInteractionGate } from "../../browser/interaction-gates";
3import {
4  buildYouTubeThumbnailCandidates,
5  parseYouTubeDescriptionChapters,
6  renderYouTubeTranscriptMarkdown,
7  type YouTubeChapter,
8  type YouTubeTranscriptSegment,
9} from "./utils";
10 
11interface CaptionInfo {
12  captionUrl: string;
13  language: string;
14  kind: string;
15  available: string[];
16  title?: string;
17  author?: string;
18  authorUrl?: string;
19  channelId?: string;
20  description?: string;
21  publishedAt?: string;
22  viewCount?: number;
23  durationSeconds?: number;
24  keywords: string[];
25  category?: string;
26  isLiveContent?: boolean;
27  coverImages: string[];
28}
29 
30function normalizeUrl(url: string | undefined): string | undefined {
31  if (!url) {
32    return undefined;
33  }
34 
35  try {
36    const parsed = new URL(url);
37    if (parsed.protocol === "http:") {
38      parsed.protocol = "https:";
39    }
40    return parsed.toString();
41  } catch {
42    return url;
43  }
44}
45 
46function buildSummary(description: string | undefined, segments: YouTubeTranscriptSegment[]): string | undefined {
47  const descriptionSummary = description
48    ?.replace(/\r\n/g, "\n")
49    .split("\n")
50    .map((line) => line.trim())
51    .find((line) => line && !/^https?:\/\//i.test(line));
52 
53  if (descriptionSummary) {
54    return descriptionSummary.slice(0, 240);
55  }
56 
57  const transcriptSummary = segments
58    .slice(0, 8)
59    .map((segment) => segment.text)
60    .join(" ")
61    .slice(0, 240)
62    .trim();
63 
64  return transcriptSummary || undefined;
65}
66 
67async function canFetchThumbnail(url: string): Promise<boolean> {
68  try {
69    const response = await fetch(url, { method: "HEAD", redirect: "follow" });
70    if (response.ok) {
71      return true;
72    }
73 
74    if (response.status === 405) {
75      const fallbackResponse = await fetch(url, {
76        method: "GET",
77        headers: { Range: "bytes=0-0" },
78        redirect: "follow",
79      });
80      return fallbackResponse.ok;
81    }
82  } catch {
83    return false;
84  }
85 
86  return false;
87}
88 
89async function resolveBestCoverImage(videoId: string, coverImages: string[]): Promise<string | undefined> {
90  const candidates = buildYouTubeThumbnailCandidates(videoId, coverImages);
91 
92  for (const candidate of candidates) {
93    if (await canFetchThumbnail(candidate)) {
94      return candidate;
95    }
96  }
97 
98  return candidates[0];
99}
100 
101export async function extractYouTubeTranscriptDocument(
102  context: Parameters<import("../types").Adapter["process"]>[0],
103  videoId: string,
104): Promise<ExtractedDocument | null> {
105  const videoUrl = `https://www.youtube.com/watch?v=${videoId}`;
106  await context.browser.goto(videoUrl, context.timeoutMs);
107 
108  const interaction = await detectInteractionGate(context.browser);
109  if (interaction) {
110    context.log.debug(`Interaction gate detected on YouTube: ${interaction.provider}`);
111    return null;
112  }
113 
114  try {
115    await context.network.waitForIdle({
116      idleMs: 1_000,
117      timeoutMs: Math.min(context.timeoutMs, 8_000),
118    });
119  } catch {
120    context.log.debug("Network idle timed out on YouTube load.");
121  }
122 
123  const captionInfo = await context.browser.evaluate<CaptionInfo | { error: string }>(`
124    (async () => {
125      function readText(value) {
126        if (!value) return undefined;
127        if (typeof value === 'string') {
128          const text = value.trim();
129          return text || undefined;
130        }
131        if (typeof value.simpleText === 'string') {
132          const text = value.simpleText.trim();
133          return text || undefined;
134        }
135        if (Array.isArray(value.runs)) {
136          const text = value.runs
137            .map((run) => typeof run?.text === 'string' ? run.text : '')
138            .join('')
139            .trim();
140          return text || undefined;
141        }
142        return undefined;
143      }
144 
145      function parsePositiveInteger(value) {
146        if (typeof value === 'number' && Number.isFinite(value) && value >= 0) {
147          return Math.floor(value);
148        }
149        if (typeof value !== 'string') {
150          return undefined;
151        }
152        const normalized = value.replace(/[^\\d]/g, '');
153        if (!normalized) {
154          return undefined;
155        }
156        const parsed = Number.parseInt(normalized, 10);
157        return Number.isFinite(parsed) ? parsed : undefined;
158      }
159 
160      const apiKey = window.ytcfg?.data_?.INNERTUBE_API_KEY;
161      const playerResponse = window.ytInitialPlayerResponse;
162      const videoDetails = playerResponse?.videoDetails || {};
163      const microformat = playerResponse?.microformat?.playerMicroformatRenderer || {};
164      const title =
165        videoDetails.title ||
166        readText(microformat.title) ||
167        document.title.replace(/ - YouTube$/, '').trim();
168      const author =
169        videoDetails.author ||
170        microformat.ownerChannelName ||
171        document.querySelector('link[itemprop="name"]')?.getAttribute('content') ||
172        undefined;
173      const authorUrl =
174        microformat.ownerProfileUrl ||
175        (typeof videoDetails.channelId === 'string' && videoDetails.channelId
176          ? 'https://www.youtube.com/channel/' + videoDetails.channelId
177          : undefined);
178      const description =
179        readText(microformat.description) ||
180        (typeof videoDetails.shortDescription === 'string' ? videoDetails.shortDescription.trim() : undefined);
181      const keywords = Array.isArray(videoDetails.keywords)
182        ? videoDetails.keywords.filter((keyword) => typeof keyword === 'string' && keyword.trim())
183        : [];
184      const thumbnails = [
185        ...(Array.isArray(videoDetails.thumbnail?.thumbnails) ? videoDetails.thumbnail.thumbnails : []),
186        ...(Array.isArray(microformat.thumbnail?.thumbnails) ? microformat.thumbnail.thumbnails : []),
187      ]
188        .filter((thumbnail) => typeof thumbnail?.url === 'string' && thumbnail.url)
189        .sort((left, right) => ((right?.width || 0) * (right?.height || 0)) - ((left?.width || 0) * (left?.height || 0)))
190        .map((thumbnail) => thumbnail.url);
191 
192      if (!apiKey) {
193        return { error: 'INNERTUBE_API_KEY not found on page' };
194      }
195 
196      const response = await fetch('/youtubei/v1/player?key=' + apiKey + '&prettyPrint=false', {
197        method: 'POST',
198        credentials: 'include',
199        headers: { 'Content-Type': 'application/json' },
200        body: JSON.stringify({
201          context: { client: { clientName: 'ANDROID', clientVersion: '20.10.38' } },
202          videoId: ${JSON.stringify(videoId)}
203        })
204      });
205 
206      if (!response.ok) {
207        return { error: 'InnerTube player API returned HTTP ' + response.status };
208      }
209 
210      const data = await response.json();
211      const renderer = data.captions?.playerCaptionsTracklistRenderer;
212      if (!renderer?.captionTracks?.length) {
213        return { error: 'No captions available for this video' };
214      }
215 
216      const tracks = renderer.captionTracks;
217      const track = tracks.find((item) => item.kind !== 'asr') || tracks[0];
218 
219      return {
220        captionUrl: track.baseUrl,
221        language: track.languageCode,
222        kind: track.kind || 'manual',
223        available: tracks.map((item) => {
224          const languageLabel = readText(item.name) || item.languageCode;
225          return item.kind === 'asr'
226            ? languageLabel + ' [' + item.languageCode + ', auto]'
227            : languageLabel + ' [' + item.languageCode + ']';
228        }),
229        title,
230        author,
231        authorUrl,
232        channelId: typeof videoDetails.channelId === 'string' ? videoDetails.channelId : undefined,
233        description,
234        publishedAt:
235          (typeof microformat.publishDate === 'string' && microformat.publishDate) ||
236          (typeof microformat.uploadDate === 'string' && microformat.uploadDate) ||
237          document.querySelector('meta[itemprop="datePublished"]')?.getAttribute('content') ||
238          undefined,
239        viewCount: parsePositiveInteger(videoDetails.viewCount) ?? parsePositiveInteger(microformat.viewCount),
240        durationSeconds: parsePositiveInteger(videoDetails.lengthSeconds),
241        keywords,
242        category: typeof microformat.category === 'string' ? microformat.category : undefined,
243        isLiveContent: Boolean(videoDetails.isLiveContent || microformat.isLiveContent),
244        coverImages: thumbnails,
245      };
246    })()
247  `);
248 
249  if ("error" in captionInfo) {
250    context.log.debug(`YouTube transcript unavailable: ${captionInfo.error}`);
251    return null;
252  }
253 
254  const segments = await context.browser.evaluate<YouTubeTranscriptSegment[] | { error: string }>(`
255    (async () => {
256      const response = await fetch(${JSON.stringify(captionInfo.captionUrl)});
257      const xml = await response.text();
258      if (!xml) {
259        return { error: 'Caption XML is empty' };
260      }
261 
262      function getAttr(tag, name) {
263        const needle = name + '="';
264        const index = tag.indexOf(needle);
265        if (index === -1) return '';
266        const valueStart = index + needle.length;
267        const valueEnd = tag.indexOf('"', valueStart);
268        if (valueEnd === -1) return '';
269        return tag.substring(valueStart, valueEnd);
270      }
271 
272      function decodeEntities(value) {
273        return value
274          .replaceAll('&amp;', '&')
275          .replaceAll('&lt;', '<')
276          .replaceAll('&gt;', '>')
277          .replaceAll('&quot;', '"')
278          .replaceAll('&#39;', "'");
279      }
280 
281      const marker = xml.includes('<p t="') ? '<p ' : '<text ';
282      const endMarker = marker === '<p ' ? '</p>' : '</text>';
283      const results = [];
284      let position = 0;
285 
286      while (true) {
287        const tagStart = xml.indexOf(marker, position);
288        if (tagStart === -1) break;
289        let contentStart = xml.indexOf('>', tagStart);
290        if (contentStart === -1) break;
291        contentStart += 1;
292        const tagEnd = xml.indexOf(endMarker, contentStart);
293        if (tagEnd === -1) break;
294 
295        const attrString = xml.substring(tagStart + marker.length, contentStart - 1);
296        const content = xml.substring(contentStart, tagEnd);
297        const start = marker === '<p '
298          ? (parseFloat(getAttr(attrString, 't')) || 0) / 1000
299          : (parseFloat(getAttr(attrString, 'start')) || 0);
300        const duration = marker === '<p '
301          ? (parseFloat(getAttr(attrString, 'd')) || 0) / 1000
302          : (parseFloat(getAttr(attrString, 'dur')) || 0);
303        const text = decodeEntities(content.replace(/<[^>]+>/g, '')).split('\\n').join(' ').trim();
304        if (text) {
305          results.push({ start, end: start + duration, text });
306        }
307 
308        position = tagEnd + endMarker.length;
309      }
310 
311      if (results.length === 0) {
312        return { error: 'Parsed 0 transcript segments' };
313      }
314      return results;
315    })()
316  `);
317 
318  if (!Array.isArray(segments) || segments.length === 0) {
319    context.log.debug("Parsed no YouTube transcript segments.");
320    return null;
321  }
322 
323  const extractedChapters = await context.browser.evaluate<YouTubeChapter[]>(`
324    (() => {
325      const data = window.ytInitialData;
326      const markers = data?.playerOverlays?.playerOverlayRenderer
327        ?.decoratedPlayerBarRenderer?.decoratedPlayerBarRenderer
328        ?.playerBar?.multiMarkersPlayerBarRenderer?.markersMap || [];
329      const results = [];
330 
331      for (const marker of markers) {
332        const chapters = marker?.value?.chapters;
333        if (!Array.isArray(chapters)) continue;
334        for (const chapter of chapters) {
335          const renderer = chapter?.chapterRenderer;
336          const title = renderer?.title?.simpleText;
337          const timeRangeStartMillis = renderer?.timeRangeStartMillis;
338          if (title && typeof timeRangeStartMillis === 'number') {
339            results.push({ title, time: Math.floor(timeRangeStartMillis / 1000) });
340          }
341        }
342      }
343 
344      return results;
345    })()
346  `).catch(() => []);
347 
348  const descriptionChapters = parseYouTubeDescriptionChapters(captionInfo.description);
349  const chapters = extractedChapters.length > 0 ? extractedChapters : descriptionChapters;
350  const markdown = renderYouTubeTranscriptMarkdown({
351    description: captionInfo.description,
352    segments,
353    chapters,
354  });
355 
356  if (!markdown) {
357    return null;
358  }
359 
360  const pageUrl = await context.browser.getURL();
361  const coverImage = await resolveBestCoverImage(videoId, captionInfo.coverImages);
362  const summary = buildSummary(captionInfo.description, segments);
363 
364  return {
365    url: pageUrl,
366    canonicalUrl: pageUrl,
367    title: captionInfo.title || "YouTube Transcript",
368    author: captionInfo.author,
369    publishedAt: captionInfo.publishedAt,
370    siteName: "YouTube",
371    summary,
372    adapter: "youtube",
373    metadata: {
374      kind: "youtube/transcript",
375      videoId,
376      authorUrl: normalizeUrl(captionInfo.authorUrl),
377      channelId: captionInfo.channelId,
378      coverImage,
379      description: captionInfo.description,
380      durationSeconds: captionInfo.durationSeconds,
381      language: captionInfo.language,
382      captionKind: captionInfo.kind,
383      availableLanguages: captionInfo.available,
384      viewCount: captionInfo.viewCount,
385      keywords: captionInfo.keywords,
386      category: captionInfo.category,
387      isLiveContent: captionInfo.isLiveContent,
388      chapterCount: chapters.length,
389    },
390    content: [{ type: "markdown", markdown }],
391  };
392}
393