@aitofy/youtube 0.1.0

package/dist/mcp.js

@@ -0,0 +1,1008 @@
+#!/usr/bin/env node
+"use strict";
+
+// src/mcp.ts
+var import_server = require("@modelcontextprotocol/sdk/server/index.js");
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+var import_types7 = require("@modelcontextprotocol/sdk/types.js");
+
+// src/channel/get-videos.ts
+var import_fast_xml_parser = require("fast-xml-parser");
+
+// src/types.ts
+var YouTubeToolsError = class extends Error {
+  constructor(message, code, statusCode) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.name = "YouTubeToolsError";
+  }
+};
+var ErrorCodes = {
+  CHANNEL_NOT_FOUND: "CHANNEL_NOT_FOUND",
+  VIDEO_NOT_FOUND: "VIDEO_NOT_FOUND",
+  TRANSCRIPT_NOT_AVAILABLE: "TRANSCRIPT_NOT_AVAILABLE",
+  RATE_LIMITED: "RATE_LIMITED",
+  PARSING_ERROR: "PARSING_ERROR",
+  NETWORK_ERROR: "NETWORK_ERROR"
+};
+
+// src/utils/fetcher.ts
+var CACHE_TTL = 5 * 60 * 1e3;
+function parseChannelId(input) {
+  if (/^UC[a-zA-Z0-9_-]{22}$/.test(input)) {
+    return { type: "id", value: input };
+  }
+  if (input.startsWith("@")) {
+    return { type: "handle", value: input };
+  }
+  const patterns = [
+    { regex: /youtube\.com\/channel\/(UC[a-zA-Z0-9_-]{22})/, type: "id" },
+    { regex: /youtube\.com\/@([a-zA-Z0-9_-]+)/, type: "handle" },
+    { regex: /youtube\.com\/c\/([a-zA-Z0-9_-]+)/, type: "custom" },
+    { regex: /youtube\.com\/user\/([a-zA-Z0-9_-]+)/, type: "custom" }
+  ];
+  for (const { regex, type } of patterns) {
+    const match = input.match(regex);
+    if (match) {
+      return { type, value: type === "handle" ? `@${match[1]}` : match[1] };
+    }
+  }
+  return { type: "custom", value: input };
+}
+
+// src/channel/get-videos.ts
+var USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
+async function getChannelVideos(options) {
+  const opts = typeof options === "string" ? { channel: options } : options;
+  const { channel, limit = 15, sortBy = "newest", contentType = "videos" } = opts;
+  const channelInfo = parseChannelId(channel);
+  if (limit <= 15 && sortBy === "newest" && contentType === "videos") {
+    try {
+      const channelId = await resolveChannelId(channelInfo);
+      return getVideosFromRSS(channelId, limit);
+    } catch {
+    }
+  }
+  return getVideosFromScraping(channelInfo, limit, sortBy, contentType);
+}
+async function getVideosFromRSS(channelId, limit) {
+  const url = `https://www.youtube.com/feeds/videos.xml?channel_id=${channelId}`;
+  const response = await fetch(url, {
+    headers: { "User-Agent": USER_AGENT }
+  });
+  if (!response.ok) {
+    throw new YouTubeToolsError(
+      `Failed to fetch RSS: ${response.status}`,
+      ErrorCodes.NETWORK_ERROR,
+      response.status
+    );
+  }
+  const xml = await response.text();
+  const parser = new import_fast_xml_parser.XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: "@_"
+  });
+  const data = parser.parse(xml);
+  const entries = data?.feed?.entry || [];
+  const videos = [];
+  for (const entry of entries.slice(0, limit)) {
+    videos.push({
+      videoId: entry["yt:videoId"],
+      title: entry.title,
+      description: entry["media:group"]?.["media:description"] || "",
+      publishedAt: entry.published,
+      url: entry.link?.["@_href"] || `https://youtube.com/watch?v=${entry["yt:videoId"]}`,
+      thumbnails: {
+        default: entry["media:group"]?.["media:thumbnail"]?.["@_url"],
+        medium: entry["media:group"]?.["media:thumbnail"]?.["@_url"]?.replace(
+          "default",
+          "mqdefault"
+        ),
+        high: entry["media:group"]?.["media:thumbnail"]?.["@_url"]?.replace(
+          "default",
+          "hqdefault"
+        )
+      },
+      channelId: entry["yt:channelId"],
+      channelTitle: entry.author?.name
+    });
+  }
+  return videos;
+}
+async function getVideosFromScraping(channelInfo, limit, sortBy, contentType) {
+  let baseUrl;
+  if (channelInfo.type === "id") {
+    baseUrl = `https://www.youtube.com/channel/${channelInfo.value}`;
+  } else if (channelInfo.type === "handle") {
+    baseUrl = `https://www.youtube.com/${channelInfo.value}`;
+  } else {
+    baseUrl = `https://www.youtube.com/c/${channelInfo.value}`;
+  }
+  const contentPath = contentType === "shorts" ? "/shorts" : contentType === "streams" ? "/streams" : "/videos";
+  const url = baseUrl + contentPath;
+  const sortParam = sortBy === "popular" ? "?sort=p" : sortBy === "oldest" ? "?sort=da" : "";
+  const fullUrl = url + sortParam;
+  const response = await fetch(fullUrl, {
+    headers: {
+      "User-Agent": USER_AGENT,
+      "Accept-Language": "en-US,en;q=0.9"
+    }
+  });
+  if (!response.ok) {
+    throw new YouTubeToolsError(
+      `Failed to fetch channel page: ${response.status}`,
+      ErrorCodes.NETWORK_ERROR,
+      response.status
+    );
+  }
+  const html = await response.text();
+  return extractVideosFromHTML(html, limit);
+}
+function extractVideosFromHTML(html, limit) {
+  const dataMatch = html.match(/var ytInitialData = (.+?);<\/script>/s);
+  if (!dataMatch) {
+    return [];
+  }
+  try {
+    const data = JSON.parse(dataMatch[1]);
+    const videos = [];
+    const tabs = data?.contents?.twoColumnBrowseResultsRenderer?.tabs || [];
+    for (const tab of tabs) {
+      const tabContent = tab?.tabRenderer?.content;
+      if (!tabContent) continue;
+      const items = tabContent?.richGridRenderer?.contents || tabContent?.sectionListRenderer?.contents?.[0]?.itemSectionRenderer?.contents || [];
+      for (const item of items) {
+        if (videos.length >= limit) break;
+        const videoRenderer = item?.richItemRenderer?.content?.videoRenderer || item?.gridVideoRenderer || item?.videoRenderer;
+        if (videoRenderer?.videoId) {
+          videos.push(parseVideoRenderer(videoRenderer));
+        }
+      }
+      if (videos.length > 0) break;
+    }
+    return videos;
+  } catch {
+    return [];
+  }
+}
+function parseVideoRenderer(renderer) {
+  const videoId = renderer.videoId;
+  return {
+    videoId,
+    title: renderer.title?.runs?.[0]?.text || renderer.title?.simpleText || "",
+    description: renderer.descriptionSnippet?.runs?.map((r) => r.text).join("") || "",
+    publishedAt: renderer.publishedTimeText?.simpleText || "",
+    duration: renderer.lengthText?.simpleText || "",
+    durationSeconds: parseDuration(renderer.lengthText?.simpleText),
+    viewCount: parseViewCount(renderer.viewCountText?.simpleText),
+    url: `https://youtube.com/watch?v=${videoId}`,
+    thumbnails: {
+      default: `https://i.ytimg.com/vi/${videoId}/default.jpg`,
+      medium: `https://i.ytimg.com/vi/${videoId}/mqdefault.jpg`,
+      high: `https://i.ytimg.com/vi/${videoId}/hqdefault.jpg`,
+      maxres: `https://i.ytimg.com/vi/${videoId}/maxresdefault.jpg`
+    }
+  };
+}
+function parseDuration(duration) {
+  if (!duration) return void 0;
+  const parts = duration.split(":").map(Number);
+  if (parts.length === 3) {
+    return parts[0] * 3600 + parts[1] * 60 + parts[2];
+  } else if (parts.length === 2) {
+    return parts[0] * 60 + parts[1];
+  }
+  return parts[0];
+}
+function parseViewCount(viewText) {
+  if (!viewText) return void 0;
+  const match = viewText.match(/[\d,]+/);
+  if (match) {
+    return parseInt(match[0].replace(/,/g, ""), 10);
+  }
+  return void 0;
+}
+async function resolveChannelId(channelInfo) {
+  if (channelInfo.type === "id") {
+    return channelInfo.value;
+  }
+  let url;
+  if (channelInfo.type === "handle") {
+    url = `https://www.youtube.com/${channelInfo.value}`;
+  } else {
+    url = `https://www.youtube.com/c/${channelInfo.value}`;
+  }
+  const response = await fetch(url, {
+    headers: { "User-Agent": USER_AGENT }
+  });
+  const html = await response.text();
+  const match = html.match(/"channelId":"(UC[a-zA-Z0-9_-]{22})"/);
+  if (match) {
+    return match[1];
+  }
+  throw new YouTubeToolsError(
+    `Could not resolve channel ID for: ${channelInfo.value}`,
+    ErrorCodes.CHANNEL_NOT_FOUND
+  );
+}
+
+// src/channel/get-info.ts
+var USER_AGENT2 = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
+async function getChannelInfo(channel) {
+  const channelInfo = parseChannelId(channel);
+  let url;
+  if (channelInfo.type === "id") {
+    url = `https://www.youtube.com/channel/${channelInfo.value}`;
+  } else if (channelInfo.type === "handle") {
+    url = `https://www.youtube.com/${channelInfo.value}`;
+  } else {
+    url = `https://www.youtube.com/c/${channelInfo.value}`;
+  }
+  const response = await fetch(url, {
+    headers: {
+      "User-Agent": USER_AGENT2,
+      "Accept-Language": "en-US,en;q=0.9"
+    }
+  });
+  if (!response.ok) {
+    throw new YouTubeToolsError(
+      `Channel not found: ${channel}`,
+      ErrorCodes.CHANNEL_NOT_FOUND,
+      response.status
+    );
+  }
+  const html = await response.text();
+  return extractChannelInfo(html);
+}
+function extractChannelInfo(html) {
+  const dataMatch = html.match(/var ytInitialData = (.+?);<\/script>/s);
+  if (!dataMatch) {
+    throw new YouTubeToolsError(
+      "Could not parse channel data",
+      ErrorCodes.PARSING_ERROR
+    );
+  }
+  try {
+    const data = JSON.parse(dataMatch[1]);
+    const metadata = data?.metadata?.channelMetadataRenderer || {};
+    const header = data?.header?.c4TabbedHeaderRenderer || data?.header?.pageHeaderRenderer?.pageHeaderViewModel || {};
+    const channelIdMatch = html.match(/"channelId":"(UC[a-zA-Z0-9_-]{22})"/);
+    const channelId = channelIdMatch?.[1] || metadata.externalId || "";
+    let subscriberCount;
+    const subText = header?.subscriberCountText?.simpleText || header?.metadata?.contentMetadataViewModel?.metadataRows?.[1]?.metadataParts?.[0]?.text?.content;
+    if (subText) {
+      subscriberCount = parseCount(subText);
+    }
+    let videoCount;
+    const videoText = header?.videosCountText?.runs?.[0]?.text;
+    if (videoText) {
+      videoCount = parseInt(videoText.replace(/,/g, ""), 10);
+    }
+    return {
+      channelId,
+      title: metadata.title || header?.title || "",
+      description: metadata.description || "",
+      customUrl: metadata.vanityChannelUrl?.split("/").pop() || "",
+      subscriberCount,
+      videoCount,
+      url: `https://youtube.com/channel/${channelId}`,
+      thumbnails: {
+        default: metadata.avatar?.thumbnails?.[0]?.url,
+        high: metadata.avatar?.thumbnails?.slice(-1)[0]?.url
+      }
+    };
+  } catch (error) {
+    throw new YouTubeToolsError(
+      "Failed to parse channel info",
+      ErrorCodes.PARSING_ERROR
+    );
+  }
+}
+function parseCount(text) {
+  const match = text.match(/([\d.]+)\s*([KMB])?/i);
+  if (!match) return 0;
+  let num = parseFloat(match[1]);
+  const suffix = match[2]?.toUpperCase();
+  if (suffix === "K") num *= 1e3;
+  else if (suffix === "M") num *= 1e6;
+  else if (suffix === "B") num *= 1e9;
+  return Math.round(num);
+}
+
+// src/video/get-transcript.ts
+var USER_AGENT3 = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
+var WATCH_URL = "https://www.youtube.com/watch?v=";
+var INNERTUBE_API_URL = "https://www.youtube.com/youtubei/v1/player?key=";
+var INNERTUBE_CONTEXT = {
+  client: {
+    hl: "en",
+    gl: "US",
+    clientName: "WEB",
+    clientVersion: "2.20240101.00.00"
+  }
+};
+async function listTranscripts(videoId) {
+  const captionsData = await fetchCaptionsData(videoId);
+  return captionsData.tracks;
+}
+async function getTranscript(videoId, options = {}) {
+  const { languages = ["en"], preferGenerated = false } = options;
+  const captionsData = await fetchCaptionsData(videoId);
+  const tracks = captionsData.tracks;
+  if (tracks.length === 0) {
+    throw new YouTubeToolsError(
+      `No transcripts available for video: ${videoId}`,
+      ErrorCodes.TRANSCRIPT_NOT_AVAILABLE
+    );
+  }
+  const track = findBestTrack(tracks, languages, preferGenerated);
+  if (!track) {
+    throw new YouTubeToolsError(
+      `No transcript found for languages: ${languages.join(", ")}`,
+      ErrorCodes.TRANSCRIPT_NOT_AVAILABLE
+    );
+  }
+  const url = track.baseUrl.replace("&fmt=srv3", "");
+  return fetchTranscriptXML(url);
+}
+async function getTranscriptText(videoId, options = {}) {
+  const segments = await getTranscript(videoId, options);
+  return segments.map((s) => s.text).join("\n");
+}
+async function fetchCaptionsData(videoId) {
+  const html = await fetchVideoHtml(videoId);
+  const apiKey = extractInnertubeApiKey(html);
+  const data = await fetchInnertubeData(videoId, apiKey);
+  return extractCaptionsData(data, videoId);
+}
+async function fetchVideoHtml(videoId) {
+  const url = WATCH_URL + videoId;
+  const response = await fetch(url, {
+    headers: {
+      "User-Agent": USER_AGENT3,
+      "Accept-Language": "en-US,en;q=0.9",
+      Accept: "text/html,application/xhtml+xml"
+    }
+  });
+  if (!response.ok) {
+    throw new YouTubeToolsError(
+      `Failed to fetch video page: ${response.status}`,
+      ErrorCodes.NETWORK_ERROR,
+      response.status
+    );
+  }
+  const html = await response.text();
+  return decodeHtmlEntities(html);
+}
+function extractInnertubeApiKey(html) {
+  const match = html.match(/"INNERTUBE_API_KEY":\s*"([a-zA-Z0-9_-]+)"/);
+  if (match && match[1]) {
+    return match[1];
+  }
+  if (html.includes('class="g-recaptcha"')) {
+    throw new YouTubeToolsError(
+      "IP blocked by YouTube (reCAPTCHA required)",
+      ErrorCodes.RATE_LIMITED
+    );
+  }
+  throw new YouTubeToolsError(
+    "Could not extract Innertube API key",
+    ErrorCodes.PARSING_ERROR
+  );
+}
+async function fetchInnertubeData(videoId, apiKey) {
+  const url = INNERTUBE_API_URL + apiKey;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "User-Agent": USER_AGENT3,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      context: INNERTUBE_CONTEXT,
+      videoId
+    })
+  });
+  if (!response.ok) {
+    throw new YouTubeToolsError(
+      `Innertube API failed: ${response.status}`,
+      ErrorCodes.NETWORK_ERROR,
+      response.status
+    );
+  }
+  return response.json();
+}
+function extractCaptionsData(data, videoId) {
+  const playabilityStatus = data?.playabilityStatus?.status;
+  if (playabilityStatus && playabilityStatus !== "OK") {
+    const reason = data?.playabilityStatus?.reason || "Video unavailable";
+    throw new YouTubeToolsError(
+      `Video not playable: ${reason}`,
+      ErrorCodes.VIDEO_NOT_FOUND
+    );
+  }
+  const captionsData = data?.captions?.playerCaptionsTracklistRenderer;
+  if (!captionsData || !captionsData.captionTracks) {
+    throw new YouTubeToolsError(
+      `No transcripts available for video: ${videoId}`,
+      ErrorCodes.TRANSCRIPT_NOT_AVAILABLE
+    );
+  }
+  const tracks = captionsData.captionTracks.map((track) => ({
+    languageCode: track.languageCode,
+    language: track.name?.runs?.[0]?.text || track.name?.simpleText || track.languageCode,
+    baseUrl: track.baseUrl,
+    isGenerated: track.kind === "asr",
+    isTranslatable: track.isTranslatable || false
+  }));
+  const translationLanguages = (captionsData.translationLanguages || []).map(
+    (lang) => lang.languageCode
+  );
+  return { tracks, translationLanguages };
+}
+async function fetchTranscriptXML(url) {
+  const response = await fetch(url, {
+    headers: {
+      "User-Agent": USER_AGENT3,
+      "Accept-Language": "en-US,en;q=0.9"
+    }
+  });
+  if (!response.ok) {
+    throw new YouTubeToolsError(
+      `Failed to fetch transcript: ${response.status}`,
+      ErrorCodes.NETWORK_ERROR,
+      response.status
+    );
+  }
+  const xml = await response.text();
+  return parseTranscriptXML(xml);
+}
+function parseTranscriptXML(xml) {
+  const segments = [];
+  const regex = /<text\s+start="([^"]+)"\s+dur="([^"]*)"[^>]*>([^<]*)<\/text>/g;
+  let match;
+  while ((match = regex.exec(xml)) !== null) {
+    const text = decodeHtmlEntities(match[3]).trim();
+    if (text) {
+      segments.push({
+        start: parseFloat(match[1]),
+        duration: parseFloat(match[2] || "0"),
+        text
+      });
+    }
+  }
+  if (segments.length === 0) {
+    const altRegex = /<text\s+start="([^"]+)"[^>]*>([^<]*)<\/text>/g;
+    while ((match = altRegex.exec(xml)) !== null) {
+      const text = decodeHtmlEntities(match[2]).trim();
+      if (text) {
+        segments.push({
+          start: parseFloat(match[1]),
+          duration: 0,
+          text
+        });
+      }
+    }
+  }
+  return segments;
+}
+function findBestTrack(tracks, languages, preferGenerated) {
+  const sortedTracks = [...tracks].sort((a, b) => {
+    if (a.isGenerated !== b.isGenerated) {
+      if (preferGenerated) {
+        return a.isGenerated ? -1 : 1;
+      }
+      return a.isGenerated ? 1 : -1;
+    }
+    return 0;
+  });
+  for (const lang of languages) {
+    const track = sortedTracks.find(
+      (t) => t.languageCode === lang || t.languageCode.startsWith(lang + "-")
+    );
+    if (track) {
+      return track;
+    }
+  }
+  return sortedTracks[0] || null;
+}
+function decodeHtmlEntities(text) {
+  return text.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&#39;/g, "'").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&#x27;/g, "'").replace(/&#x2F;/g, "/").replace(/\n/g, " ").replace(/\\n/g, " ");
+}
+
+// src/video/get-info.ts
+var USER_AGENT4 = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
+async function getVideoInfo(videoIdOrUrl) {
+  const videoId = parseVideoId(videoIdOrUrl);
+  const html = await fetchVideoPage(videoId);
+  return extractVideoInfo(html, videoId);
+}
+function parseVideoId(input) {
+  if (/^[a-zA-Z0-9_-]{11}$/.test(input)) {
+    return input;
+  }
+  const patterns = [
+    /(?:youtube\.com\/watch\?v=|youtu\.be\/)([a-zA-Z0-9_-]{11})/,
+    /youtube\.com\/embed\/([a-zA-Z0-9_-]{11})/,
+    /youtube\.com\/v\/([a-zA-Z0-9_-]{11})/,
+    /youtube\.com\/shorts\/([a-zA-Z0-9_-]{11})/
+  ];
+  for (const pattern of patterns) {
+    const match = input.match(pattern);
+    if (match) {
+      return match[1];
+    }
+  }
+  throw new YouTubeToolsError(
+    `Invalid video ID or URL: ${input}`,
+    ErrorCodes.VIDEO_NOT_FOUND
+  );
+}
+async function fetchVideoPage(videoId) {
+  const url = `https://www.youtube.com/watch?v=${videoId}`;
+  const response = await fetch(url, {
+    headers: {
+      "User-Agent": USER_AGENT4,
+      "Accept-Language": "en-US,en;q=0.9",
+      Cookie: "CONSENT=YES+"
+    }
+  });
+  if (!response.ok) {
+    throw new YouTubeToolsError(
+      `Failed to fetch video page: ${response.status}`,
+      ErrorCodes.NETWORK_ERROR,
+      response.status
+    );
+  }
+  return response.text();
+}
+function extractVideoInfo(html, videoId) {
+  const playerMatch = html.match(
+    /ytInitialPlayerResponse\s*=\s*({.+?});(?:var|<\/script>)/s
+  );
+  const dataMatch = html.match(/var ytInitialData = (.+?);<\/script>/s);
+  let playerData = {};
+  let pageData = {};
+  try {
+    if (playerMatch) {
+      playerData = JSON.parse(playerMatch[1]);
+    }
+    if (dataMatch) {
+      pageData = JSON.parse(dataMatch[1]);
+    }
+  } catch {
+  }
+  const videoDetails = playerData?.videoDetails || {};
+  const microformat = playerData?.microformat?.playerMicroformatRenderer || {};
+  return {
+    videoId,
+    title: videoDetails.title || "",
+    description: videoDetails.shortDescription || "",
+    publishedAt: microformat.publishDate || "",
+    duration: formatDuration(parseInt(videoDetails.lengthSeconds || "0", 10)),
+    durationSeconds: parseInt(videoDetails.lengthSeconds || "0", 10),
+    viewCount: parseInt(videoDetails.viewCount || "0", 10),
+    likeCount: extractLikeCount(pageData),
+    commentCount: extractCommentCount(pageData),
+    url: `https://youtube.com/watch?v=${videoId}`,
+    thumbnails: {
+      default: `https://i.ytimg.com/vi/${videoId}/default.jpg`,
+      medium: `https://i.ytimg.com/vi/${videoId}/mqdefault.jpg`,
+      high: `https://i.ytimg.com/vi/${videoId}/hqdefault.jpg`,
+      maxres: `https://i.ytimg.com/vi/${videoId}/maxresdefault.jpg`
+    },
+    channelId: videoDetails.channelId,
+    channelTitle: videoDetails.author,
+    category: microformat.category,
+    tags: videoDetails.keywords,
+    keywords: videoDetails.keywords,
+    chapters: extractChapters(pageData),
+    isLive: videoDetails.isLiveContent,
+    isUpcoming: videoDetails.isUpcoming
+  };
+}
+function formatDuration(seconds) {
+  const hours = Math.floor(seconds / 3600);
+  const mins = Math.floor(seconds % 3600 / 60);
+  const secs = seconds % 60;
+  if (hours > 0) {
+    return `${hours}:${mins.toString().padStart(2, "0")}:${secs.toString().padStart(2, "0")}`;
+  }
+  return `${mins}:${secs.toString().padStart(2, "0")}`;
+}
+function extractLikeCount(pageData) {
+  try {
+    const contents = pageData?.contents?.twoColumnWatchNextResults?.results?.results?.contents || [];
+    for (const content of contents) {
+      const buttons = content?.videoPrimaryInfoRenderer?.videoActions?.menuRenderer?.topLevelButtons || [];
+      for (const button of buttons) {
+        const likeButton = button?.segmentedLikeDislikeButtonViewModel?.likeButtonViewModel;
+        if (likeButton?.likeButtonViewModel?.toggleButtonViewModel) {
+          const countText = likeButton.likeButtonViewModel.toggleButtonViewModel.toggleButtonViewModel?.defaultButtonViewModel?.buttonViewModel?.title;
+          if (countText) {
+            return parseCount2(countText);
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+function extractCommentCount(pageData) {
+  try {
+    const contents = pageData?.contents?.twoColumnWatchNextResults?.results?.results?.contents || [];
+    for (const content of contents) {
+      const header = content?.itemSectionRenderer?.contents?.[0]?.commentsEntryPointHeaderRenderer;
+      if (header?.commentCount?.simpleText) {
+        return parseCount2(header.commentCount.simpleText);
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+function extractChapters(pageData) {
+  try {
+    const panels = pageData?.playerOverlays?.playerOverlayRenderer?.decoratedPlayerBarRenderer?.decoratedPlayerBarRenderer?.playerBar?.multiMarkersPlayerBarRenderer?.markersMap || [];
+    for (const panel of panels) {
+      if (panel?.key === "AUTO_CHAPTERS" || panel?.key === "DESCRIPTION_CHAPTERS") {
+        const markers = panel?.value?.chapters || [];
+        return markers.map((m) => ({
+          title: m.chapterRenderer?.title?.simpleText || "",
+          startTime: m.chapterRenderer?.timeRangeStartMillis / 1e3 || 0
+        }));
+      }
+    }
+  } catch {
+  }
+  return [];
+}
+function parseCount2(text) {
+  const match = text.match(/([\d.]+)\s*([KMB])?/i);
+  if (!match) return 0;
+  let num = parseFloat(match[1]);
+  const suffix = match[2]?.toUpperCase();
+  if (suffix === "K") num *= 1e3;
+  else if (suffix === "M") num *= 1e6;
+  else if (suffix === "B") num *= 1e9;
+  return Math.round(num);
+}
+
+// src/video/search.ts
+var USER_AGENT5 = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
+async function searchVideos(queryOrOptions) {
+  const options = typeof queryOrOptions === "string" ? { query: queryOrOptions } : queryOrOptions;
+  const { query, limit = 20, sortBy = "relevance" } = options;
+  const searchUrl = buildSearchUrl(query, options);
+  const response = await fetch(searchUrl, {
+    headers: {
+      "User-Agent": USER_AGENT5,
+      "Accept-Language": "en-US,en;q=0.9"
+    }
+  });
+  if (!response.ok) {
+    throw new YouTubeToolsError(
+      `Search failed: ${response.status}`,
+      ErrorCodes.NETWORK_ERROR,
+      response.status
+    );
+  }
+  const html = await response.text();
+  return extractSearchResults(html, limit);
+}
+function buildSearchUrl(query, options) {
+  const params = new URLSearchParams({
+    search_query: query
+  });
+  if (options.sortBy === "date") {
+    params.set("sp", "CAI%3D");
+  } else if (options.sortBy === "viewCount") {
+    params.set("sp", "CAM%3D");
+  } else if (options.sortBy === "rating") {
+    params.set("sp", "CAE%3D");
+  }
+  return `https://www.youtube.com/results?${params.toString()}`;
+}
+function extractSearchResults(html, limit) {
+  const dataMatch = html.match(/var ytInitialData = (.+?);<\/script>/s);
+  if (!dataMatch) {
+    return [];
+  }
+  try {
+    const data = JSON.parse(dataMatch[1]);
+    const videos = [];
+    const contents = data?.contents?.twoColumnSearchResultsRenderer?.primaryContents?.sectionListRenderer?.contents || [];
+    for (const section of contents) {
+      const items = section?.itemSectionRenderer?.contents || [];
+      for (const item of items) {
+        if (videos.length >= limit) break;
+        const videoRenderer = item?.videoRenderer;
+        if (videoRenderer?.videoId) {
+          videos.push(parseVideoRenderer2(videoRenderer));
+        }
+      }
+    }
+    return videos;
+  } catch {
+    return [];
+  }
+}
+function parseVideoRenderer2(renderer) {
+  const videoId = renderer.videoId;
+  return {
+    videoId,
+    title: renderer.title?.runs?.[0]?.text || "",
+    description: renderer.detailedMetadataSnippets?.[0]?.snippetText?.runs?.map((r) => r.text).join("") || "",
+    publishedAt: renderer.publishedTimeText?.simpleText || "",
+    duration: renderer.lengthText?.simpleText || "",
+    durationSeconds: parseDuration2(renderer.lengthText?.simpleText),
+    viewCount: parseViewCount2(renderer.viewCountText?.simpleText),
+    url: `https://youtube.com/watch?v=${videoId}`,
+    thumbnails: {
+      default: `https://i.ytimg.com/vi/${videoId}/default.jpg`,
+      medium: `https://i.ytimg.com/vi/${videoId}/mqdefault.jpg`,
+      high: `https://i.ytimg.com/vi/${videoId}/hqdefault.jpg`,
+      maxres: `https://i.ytimg.com/vi/${videoId}/maxresdefault.jpg`
+    },
+    channelId: renderer.ownerText?.runs?.[0]?.navigationEndpoint?.browseEndpoint?.browseId,
+    channelTitle: renderer.ownerText?.runs?.[0]?.text
+  };
+}
+function parseDuration2(duration) {
+  if (!duration) return void 0;
+  const parts = duration.split(":").map(Number);
+  if (parts.length === 3) {
+    return parts[0] * 3600 + parts[1] * 60 + parts[2];
+  } else if (parts.length === 2) {
+    return parts[0] * 60 + parts[1];
+  }
+  return parts[0];
+}
+function parseViewCount2(viewText) {
+  if (!viewText) return void 0;
+  const match = viewText.match(/([\d,.]+)\s*([KMB])?/i);
+  if (!match) return void 0;
+  let num = parseFloat(match[1].replace(/,/g, ""));
+  const suffix = match[2]?.toUpperCase();
+  if (suffix === "K") num *= 1e3;
+  else if (suffix === "M") num *= 1e6;
+  else if (suffix === "B") num *= 1e9;
+  return Math.round(num);
+}
+
+// src/mcp.ts
+var server = new import_server.Server(
+  {
+    name: "youtube-tools",
+    version: "0.1.0"
+  },
+  {
+    capabilities: {
+      tools: {}
+    }
+  }
+);
+server.setRequestHandler(import_types7.ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: "get_youtube_transcript",
+      description: "Get the transcript/subtitles of a YouTube video. Returns timestamped segments.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          video_id: {
+            type: "string",
+            description: "YouTube video ID or URL (e.g., dQw4w9WgXcQ)"
+          },
+          language: {
+            type: "string",
+            description: "Preferred language code (e.g., en, vi). Default: en"
+          }
+        },
+        required: ["video_id"]
+      }
+    },
+    {
+      name: "get_youtube_transcript_text",
+      description: "Get the transcript of a YouTube video as plain text (no timestamps).",
+      inputSchema: {
+        type: "object",
+        properties: {
+          video_id: {
+            type: "string",
+            description: "YouTube video ID or URL"
+          }
+        },
+        required: ["video_id"]
+      }
+    },
+    {
+      name: "list_youtube_transcripts",
+      description: "List available transcript languages for a YouTube video.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          video_id: {
+            type: "string",
+            description: "YouTube video ID or URL"
+          }
+        },
+        required: ["video_id"]
+      }
+    },
+    {
+      name: "get_youtube_video_info",
+      description: "Get detailed information about a YouTube video (title, views, duration, etc).",
+      inputSchema: {
+        type: "object",
+        properties: {
+          video_id: {
+            type: "string",
+            description: "YouTube video ID or URL"
+          }
+        },
+        required: ["video_id"]
+      }
+    },
+    {
+      name: "get_youtube_channel_videos",
+      description: "Get a list of videos from a YouTube channel.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          channel: {
+            type: "string",
+            description: "Channel ID, URL, or @handle (e.g., @Fireship)"
+          },
+          limit: {
+            type: "number",
+            description: "Maximum number of videos to return. Default: 15"
+          }
+        },
+        required: ["channel"]
+      }
+    },
+    {
+      name: "get_youtube_channel_info",
+      description: "Get information about a YouTube channel.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          channel: {
+            type: "string",
+            description: "Channel ID, URL, or @handle"
+          }
+        },
+        required: ["channel"]
+      }
+    },
+    {
+      name: "search_youtube_videos",
+      description: "Search for YouTube videos.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: "Search query"
+          },
+          limit: {
+            type: "number",
+            description: "Maximum number of results. Default: 10"
+          }
+        },
+        required: ["query"]
+      }
+    }
+  ]
+}));
+server.setRequestHandler(import_types7.CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  try {
+    switch (name) {
+      case "get_youtube_transcript": {
+        const videoId = args?.video_id;
+        const language = args?.language || "en";
+        const segments = await getTranscript(videoId, { languages: [language] });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(segments, null, 2)
+            }
+          ]
+        };
+      }
+      case "get_youtube_transcript_text": {
+        const videoId = args?.video_id;
+        const text = await getTranscriptText(videoId);
+        return {
+          content: [{ type: "text", text }]
+        };
+      }
+      case "list_youtube_transcripts": {
+        const videoId = args?.video_id;
+        const tracks = await listTranscripts(videoId);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(tracks, null, 2)
+            }
+          ]
+        };
+      }
+      case "get_youtube_video_info": {
+        const videoId = args?.video_id;
+        const info = await getVideoInfo(videoId);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(info, null, 2)
+            }
+          ]
+        };
+      }
+      case "get_youtube_channel_videos": {
+        const channel = args?.channel;
+        const limit = args?.limit || 15;
+        const videos = await getChannelVideos({ channel, limit });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(videos, null, 2)
+            }
+          ]
+        };
+      }
+      case "get_youtube_channel_info": {
+        const channel = args?.channel;
+        const info = await getChannelInfo(channel);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(info, null, 2)
+            }
+          ]
+        };
+      }
+      case "search_youtube_videos": {
+        const query = args?.query;
+        const limit = args?.limit || 10;
+        const results = await searchVideos({ query, limit });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(results, null, 2)
+            }
+          ]
+        };
+      }
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${message}`
+        }
+      ],
+      isError: true
+    };
+  }
+});
+async function main() {
+  const transport = new import_stdio.StdioServerTransport();
+  await server.connect(transport);
+  console.error("YouTube Tools MCP Server running on stdio");
+}
+main().catch(console.error);