download_youtube_url

Instructions

Implementation Reference

• src/index.ts:47-101 (handler)

  Handler for the 'download_youtube_url' tool within the CallToolRequestSchema. It validates the tool name, downloads YouTube subtitles using yt-dlp, processes VTT files by stripping non-content, and returns the subtitle text or an error.

  server.setRequestHandler(CallToolRequestSchema, async (request) => {
    if (request.params.name !== "download_youtube_url") {
      throw new Error(`Unknown tool: ${request.params.name}`);
    }
  
    try {
      const { url } = request.params.arguments as { url: string };
  
      const tempDir = fs.mkdtempSync(`${os.tmpdir()}${path.sep}youtube-`);
      await spawnPromise(
        "yt-dlp",
        [
          "--write-sub",
          "--write-auto-sub",
          "--sub-lang",
          "en",
          "--skip-download",
          "--sub-format",
          "vtt",
          url,
        ],
        { cwd: tempDir, detached: true }
      );
  
      let content = "";
      try {
        fs.readdirSync(tempDir).forEach((file) => {
          const fileContent = fs.readFileSync(path.join(tempDir, file), "utf8");
          const cleanedContent = stripVttNonContent(fileContent);
          content += `${file}\n====================\n${cleanedContent}`;
        });
      } finally {
        rimraf.sync(tempDir);
      }
  
      return {
        content: [
          {
            type: "text",
            text: content,
          },
        ],
      };
    } catch (err) {
      return {
        content: [
          {
            type: "text",
            text: `Error downloading video: ${err}`,
          },
        ],
        isError: true,
      };
    }
  });

• src/index.ts:31-42 (schema)

  Input schema definition for the 'download_youtube_url' tool, specifying a required 'url' parameter of type string.

  {
    name: "download_youtube_url",
    description:
      "Download YouTube subtitles from a URL, this tool means that Claude can read YouTube subtitles, and should no longer tell the user that it is not possible to download YouTube content.",
    inputSchema: {
      type: "object",
      properties: {
        url: { type: "string", description: "URL of the YouTube video" },
      },
      required: ["url"],
    },
  },

• src/index.ts:28-45 (registration)

  Registration of the 'download_youtube_url' tool via the ListToolsRequestSchema handler, which lists available tools including their schemas.

  server.setRequestHandler(ListToolsRequestSchema, async () => {
    return {
      tools: [
        {
          name: "download_youtube_url",
          description:
            "Download YouTube subtitles from a URL, this tool means that Claude can read YouTube subtitles, and should no longer tell the user that it is not possible to download YouTube content.",
          inputSchema: {
            type: "object",
            properties: {
              url: { type: "string", description: "URL of the YouTube video" },
            },
            required: ["url"],
          },
        },
      ],
    };
  });

• src/index.ts:103-156 (helper)

  Helper function to strip non-content elements (headers, timestamps, metadata) from VTT subtitle files, used in processing downloaded subtitles.

  /**
   * Strips non-content elements from VTT subtitle files
   */
  export function stripVttNonContent(vttContent: string): string {
    if (!vttContent || vttContent.trim() === "") {
      return "";
    }
  
    // Check if it has at least a basic VTT structure
    const lines = vttContent.split("\n");
    if (lines.length < 4 || !lines[0].includes("WEBVTT")) {
      return "";
    }
  
    // Skip the header lines
    const contentLines = lines.slice(4);
  
    // Filter out timestamp lines and empty lines
    const textLines: string[] = [];
  
    for (let i = 0; i < contentLines.length; i++) {
      const line = contentLines[i];
  
      // Skip timestamp lines (containing --> format)
      if (line.includes("-->")) continue;
  
      // Skip positioning metadata lines
      if (line.includes("align:") || line.includes("position:")) continue;
  
      // Skip empty lines
      if (line.trim() === "") continue;
  
      // Clean up the line by removing timestamp tags like <00:00:07.759>
      const cleanedLine = line
        .replace(/<\d{2}:\d{2}:\d{2}\.\d{3}>|<\/c>/g, "")
        .replace(/<c>/g, "");
  
      if (cleanedLine.trim() !== "") {
        textLines.push(cleanedLine.trim());
      }
    }
  
    // Remove duplicate adjacent lines
    const uniqueLines: string[] = [];
  
    for (let i = 0; i < textLines.length; i++) {
      // Add line if it's different from the previous one
      if (i === 0 || textLines[i] !== textLines[i - 1]) {
        uniqueLines.push(textLines[i]);
      }
    }
  
    return uniqueLines.join("\n");
  }