@mkterswingman/5mghost-yonder 0.0.37 → 0.0.39

package/dist/tools/remote.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { YOUTUBE_TOOL_CONTRACTS } from "../contracts/youtubeToolContracts.js";
 function toolErr(code, message) {
     const payload = { status: "failed", error: { code, message } };
     return {
@@ -69,9 +70,8 @@ function createRemoteTool(server, def, tokenManager, apiUrl) {
         }
     });
 }
-const REMOTE_TOOLS = [
-    {
-        name: "search_videos",
+const REMOTE_TOOL_META = {
+    search_videos: {
         description: "Search YouTube videos by keyword. Supports up to 300 results.",
         schema: {
             query: z.string().min(1),
@@ -87,42 +87,32 @@ const REMOTE_TOOLS = [
             ])
                 .optional(),
         },
-        remotePath: "api/search",
     },
-    {
-        name: "get_video_stats",
+    get_video_stats: {
         description: "Get YouTube video stats in one request. Accepts up to 1000 video IDs/URLs.",
         schema: {
             videos: z.array(z.string().min(1)).min(1).max(1000),
         },
-        remotePath: "api/video-stats/bulk",
     },
-    {
-        name: "start_video_stats_job",
+    start_video_stats_job: {
         description: "Start an async YouTube video stats job. Accepts up to 1000 items.",
         schema: {
             videos: z.array(z.string().min(1)).min(1).max(1000),
         },
-        remotePath: "api/video-stats/job/start",
     },
-    {
-        name: "poll_video_stats_job",
+    poll_video_stats_job: {
         description: "Poll job progress and get partial/final results for a job_id.",
         schema: {
             job_id: z.string().min(1),
         },
-        remotePath: "api/video-stats/job/poll",
     },
-    {
-        name: "resume_video_stats_job",
+    resume_video_stats_job: {
         description: "Resume a previously partial job with a resume_token.",
         schema: {
             resume_token: z.string().min(1),
         },
-        remotePath: "api/video-stats/job/resume",
     },
-    {
-        name: "get_trending",
+    get_trending: {
         description: "Get official YouTube mostPopular videos. Supports region/category filters.",
         schema: {
             region_code: z
@@ -132,38 +122,30 @@ const REMOTE_TOOLS = [
             category_id: z.string().min(1).max(64).optional(),
             max_results: z.number().int().min(1).max(300).optional(),
         },
-        remotePath: "api/trending",
     },
-    {
-        name: "search_channels",
+    search_channels: {
         description: "Search YouTube channels by keyword for candidate discovery.",
         schema: {
             query: z.string().min(1).max(200),
             max_results: z.number().int().min(1).max(50).optional(),
         },
-        remotePath: "api/channel/search",
     },
-    {
-        name: "get_channel_stats",
+    get_channel_stats: {
         description: "Get YouTube channel statistics for up to 50 channel inputs.",
         schema: {
             channels: z.array(z.string().min(1)).min(1).max(50).optional(),
             channel_ids: z.array(z.string().min(1)).min(1).max(50).optional(),
         },
-        remotePath: "api/channel/stats",
     },
-    {
-        name: "list_channel_uploads",
+    list_channel_uploads: {
         description: "List videos uploaded by a YouTube channel. Supports up to 1000 results.",
         schema: {
             channel: z.string().min(1).optional(),
             channel_id: z.string().min(1).optional(),
             max_results: z.number().int().min(1).max(1000).optional(),
         },
-        remotePath: "api/channel/uploads",
     },
-    {
-        name: "get_comments",
+    get_comments: {
         description: "Get comments for one YouTube video. max_comments up to 1000.",
         schema: {
             video: z.string().min(1),
@@ -173,46 +155,36 @@ const REMOTE_TOOLS = [
             replies_preview_per_comment: z.number().int().min(1).max(5).optional(),
             replies_preview_parent_limit: z.number().int().min(1).max(25).optional(),
         },
-        remotePath: "api/comments/sync",
     },
-    {
-        name: "start_comments_job",
+    start_comments_job: {
         description: "Start a comments export job for one YouTube video.",
         schema: {
             video: z.string().min(1),
             max_comments: z.number().int().min(1).max(1000).optional(),
             order: z.enum(["time", "relevance"]).optional(),
         },
-        remotePath: "api/comments/start",
     },
-    {
-        name: "poll_comments_job",
+    poll_comments_job: {
         description: "Check comments export job progress by job_id.",
         schema: {
             job_id: z.string().min(1),
         },
-        remotePath: "api/comments/poll",
     },
-    {
-        name: "resume_comments_job",
+    resume_comments_job: {
         description: "Resume an unfinished comments export job.",
         schema: {
             resume_token: z.string().min(1),
         },
-        remotePath: "api/comments/resume",
     },
-    {
-        name: "get_comment_replies",
+    get_comment_replies: {
         description: "Get 2nd-level replies for one top-level comment.",
         schema: {
             parent_comment_id: z.string().min(1),
             max_results: z.number().int().min(1).max(1000).optional(),
             page_token: z.string().min(1).optional(),
         },
-        remotePath: "api/comments/replies",
     },
-    {
-        name: "get_quota_usage",
+    get_quota_usage: {
         description: "Get YouTube API quota usage for today or a specific date.",
         schema: {
             date: z
@@ -220,18 +192,27 @@ const REMOTE_TOOLS = [
                 .regex(/^\d{4}-\d{2}-\d{2}$/)
                 .optional(),
         },
-        remotePath: "api/quota",
     },
-    {
-        name: "get_patch_notes",
+    get_patch_notes: {
         description: "Read server patch notes for latest MCP/API updates.",
         schema: {
             max_chars: z.number().int().min(500).max(50_000).optional(),
         },
-        remotePath: "api/patch-notes",
-        method: "GET",
     },
-];
+};
+const REMOTE_TOOLS = YOUTUBE_TOOL_CONTRACTS.map((contract) => {
+    const meta = REMOTE_TOOL_META[contract.id];
+    if (!meta) {
+        throw new Error(`Missing remote tool metadata for contract id: ${contract.id}`);
+    }
+    return {
+        name: contract.remote_tool_name,
+        description: meta.description,
+        schema: meta.schema,
+        remotePath: contract.http_path.replace(/^\//, ""),
+        method: contract.http_method,
+    };
+});
 export function registerRemoteTools(server, config, tokenManager) {
     for (const def of REMOTE_TOOLS) {
         createRemoteTool(server, def, tokenManager, config.api_url);

package/dist/tools/subtitles/cookieSession.d.ts

@@ -0,0 +1,22 @@
+export declare const COOKIE_MISSING_MESSAGE = "No valid YouTube cookies found.\nPlease run in your terminal: yt-mcp setup-cookies";
+export declare const COOKIE_EXPIRED_MESSAGE = "YouTube cookies have expired and auto-refresh failed.\nPlease run in your terminal: yt-mcp setup-cookies";
+export declare const COOKIE_INVALID_MESSAGE = "YouTube rejected the current cookies and auto-refresh failed.\nPlease run in your terminal: yt-mcp setup-cookies";
+export declare const SIGN_IN_REQUIRED_MESSAGE = "YouTube requested an additional sign-in confirmation and auto-refresh failed.\nPlease run in your terminal: yt-mcp setup-cookies";
+export declare const RATE_LIMITED_MESSAGE = "The current YouTube session has been rate-limited. Wait and retry later.";
+export declare const COOKIE_JOB_MESSAGE = "YouTube cookies are missing, expired, or invalid.\nPlease run in your terminal: yt-mcp setup-cookies";
+export type CookieFailureCode = "COOKIES_INVALID" | "COOKIES_EXPIRED" | "SIGN_IN_REQUIRED" | "RATE_LIMITED";
+export declare function tryRefreshSubtitleCookies(): Promise<boolean>;
+export declare function isCookieFailureText(error?: string): boolean;
+export declare function classifyYtDlpCookieFailure(stderr: string): {
+    code: CookieFailureCode;
+    message: string;
+} | null;
+export declare function toReadableSubtitleJobError(error: unknown): string;
+export declare function ensureSubtitleCookiesReady(): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    code: "COOKIES_MISSING" | "COOKIES_EXPIRED";
+    toolMessage: string;
+    jobMessage: string;
+}>;

package/dist/tools/subtitles/cookieSession.js

@@ -0,0 +1,66 @@
+import { PATHS } from "../../utils/config.js";
+import { hasSIDCookies, areCookiesExpired } from "../../utils/cookies.js";
+import { tryHeadlessRefresh } from "../../utils/cookieRefresh.js";
+import { appendDiagnosticLog, classifyYtDlpFailure } from "../../utils/ytdlpFailures.js";
+const COOKIE_SETUP_COMMAND = "yt-mcp setup-cookies";
+export const COOKIE_MISSING_MESSAGE = `No valid YouTube cookies found.\nPlease run in your terminal: ${COOKIE_SETUP_COMMAND}`;
+export const COOKIE_EXPIRED_MESSAGE = `YouTube cookies have expired and auto-refresh failed.\nPlease run in your terminal: ${COOKIE_SETUP_COMMAND}`;
+export const COOKIE_INVALID_MESSAGE = `YouTube rejected the current cookies and auto-refresh failed.\nPlease run in your terminal: ${COOKIE_SETUP_COMMAND}`;
+export const SIGN_IN_REQUIRED_MESSAGE = `YouTube requested an additional sign-in confirmation and auto-refresh failed.\nPlease run in your terminal: ${COOKIE_SETUP_COMMAND}`;
+export const RATE_LIMITED_MESSAGE = "The current YouTube session has been rate-limited. Wait and retry later.";
+export const COOKIE_JOB_MESSAGE = `YouTube cookies are missing, expired, or invalid.\nPlease run in your terminal: ${COOKIE_SETUP_COMMAND}`;
+export async function tryRefreshSubtitleCookies() {
+    try {
+        return await tryHeadlessRefresh();
+    }
+    catch {
+        return false;
+    }
+}
+export function isCookieFailureText(error) {
+    if (!error) {
+        return false;
+    }
+    const normalized = error.toLowerCase();
+    return (normalized.includes("cookies_expired") ||
+        normalized.includes("cookie") ||
+        normalized.includes("sign in") ||
+        normalized.includes("login") ||
+        normalized.includes("not a bot"));
+}
+export function classifyYtDlpCookieFailure(stderr) {
+    const kind = classifyYtDlpFailure(stderr);
+    switch (kind) {
+        case "COOKIES_EXPIRED":
+            return { code: kind, message: COOKIE_EXPIRED_MESSAGE };
+        case "COOKIES_INVALID":
+            return { code: kind, message: COOKIE_INVALID_MESSAGE };
+        case "SIGN_IN_REQUIRED":
+            return { code: kind, message: SIGN_IN_REQUIRED_MESSAGE };
+        case "RATE_LIMITED":
+            return { code: kind, message: RATE_LIMITED_MESSAGE };
+        default:
+            return null;
+    }
+}
+export function toReadableSubtitleJobError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return isCookieFailureText(message) ? COOKIE_JOB_MESSAGE : message;
+}
+export async function ensureSubtitleCookiesReady() {
+    const hasSession = hasSIDCookies(PATHS.cookiesTxt);
+    const expired = areCookiesExpired(PATHS.cookiesTxt);
+    if (hasSession && !expired) {
+        return { ok: true };
+    }
+    const refreshed = await tryRefreshSubtitleCookies();
+    if (refreshed && hasSIDCookies(PATHS.cookiesTxt) && !areCookiesExpired(PATHS.cookiesTxt)) {
+        return { ok: true };
+    }
+    return {
+        ok: false,
+        code: hasSession && expired ? "COOKIES_EXPIRED" : "COOKIES_MISSING",
+        toolMessage: hasSession && expired ? COOKIE_EXPIRED_MESSAGE : COOKIE_MISSING_MESSAGE,
+        jobMessage: appendDiagnosticLog(COOKIE_JOB_MESSAGE, undefined),
+    };
+}

package/dist/tools/subtitles/download.d.ts

@@ -0,0 +1,24 @@
+import { COOKIE_EXPIRED_MESSAGE, COOKIE_INVALID_MESSAGE, RATE_LIMITED_MESSAGE, SIGN_IN_REQUIRED_MESSAGE, type CookieFailureCode } from "./cookieSession.js";
+export declare function downloadSubtitle(videoId: string, lang: string, format: string, options?: {
+    sourceUrl?: string;
+    outputDir?: string;
+    outputStem?: string;
+    targetFile?: string;
+}): Promise<{
+    ok: boolean;
+    filePath?: string;
+    text?: string;
+    error?: string;
+    cookieFailureCode?: CookieFailureCode;
+    diagnosticLogPath?: string;
+}>;
+export declare function downloadSubtitlesForLanguages(input: {
+    videoId: string;
+    sourceUrl?: string;
+    languages: string[];
+    formats: string[];
+    subtitlesDir: string;
+    skipMissingLanguages?: boolean;
+    onProgress?: (completed: number, total: number) => void;
+}): Promise<Record<string, string[]>>;
+export { COOKIE_EXPIRED_MESSAGE, COOKIE_INVALID_MESSAGE, SIGN_IN_REQUIRED_MESSAGE, RATE_LIMITED_MESSAGE };

package/dist/tools/subtitles/download.js

@@ -0,0 +1,169 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { PATHS } from "../../utils/config.js";
+import { runYtDlp } from "../../utils/ytdlp.js";
+import { appendDiagnosticLog } from "../../utils/ytdlpFailures.js";
+import { classifyYtDlpCookieFailure, COOKIE_EXPIRED_MESSAGE, COOKIE_INVALID_MESSAGE, COOKIE_JOB_MESSAGE, RATE_LIMITED_MESSAGE, SIGN_IN_REQUIRED_MESSAGE, ensureSubtitleCookiesReady, isCookieFailureText, tryRefreshSubtitleCookies } from "./cookieSession.js";
+import { vttToCsv } from "./parse.js";
+function todayDateStr() {
+    const d = new Date();
+    const yyyy = d.getFullYear();
+    const mm = String(d.getMonth() + 1).padStart(2, "0");
+    const dd = String(d.getDate()).padStart(2, "0");
+    return `${yyyy}-${mm}-${dd}`;
+}
+export async function downloadSubtitle(videoId, lang, format, options = {}) {
+    const outputDir = options.outputDir ?? PATHS.subtitlesDir;
+    mkdirSync(outputDir, { recursive: true });
+    if (options.targetFile) {
+        mkdirSync(dirname(options.targetFile), { recursive: true });
+    }
+    const outTemplate = join(outputDir, options.outputStem ?? `${todayDateStr()}_${videoId}_${lang}`);
+    const dlFormat = format === "csv" ? "vtt" : format;
+    const result = await runYtDlp([
+        "--skip-download",
+        "-f", "mhtml",
+        "--write-sub",
+        "--write-auto-sub",
+        "--sub-langs",
+        lang,
+        "--sub-format",
+        dlFormat,
+        "--output",
+        outTemplate,
+        options.sourceUrl ?? `https://www.youtube.com/watch?v=${videoId}`,
+    ]);
+    const cookieFailure = result.exitCode !== 0 ? classifyYtDlpCookieFailure(result.stderr) : null;
+    if (cookieFailure) {
+        return {
+            ok: false,
+            cookieFailureCode: cookieFailure.code,
+            diagnosticLogPath: result.failureLogPath,
+            error: appendDiagnosticLog(cookieFailure.message, result.failureLogPath),
+        };
+    }
+    if (result.exitCode !== 0) {
+        return {
+            ok: false,
+            diagnosticLogPath: result.failureLogPath,
+            error: appendDiagnosticLog(result.stderr.slice(0, 500) || `yt-dlp exited with ${result.exitCode}`, result.failureLogPath),
+        };
+    }
+    const searchFormat = format === "csv" ? "vtt" : format;
+    const possibleExts = [`${lang}.${searchFormat}`, `${lang}.vtt`, `${lang}.srt`, `${lang}.ttml`, `${lang}.srv3`];
+    let foundFile;
+    for (const ext of possibleExts) {
+        const candidate = `${outTemplate}.${ext}`;
+        if (existsSync(candidate)) {
+            foundFile = candidate;
+            break;
+        }
+    }
+    if (!foundFile) {
+        try {
+            const files = readdirSync(outputDir);
+            const prefix = options.outputStem ?? `${todayDateStr()}_${videoId}_${lang}`;
+            const match = files.find((f) => f.startsWith(prefix));
+            if (match) {
+                foundFile = join(outputDir, match);
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    if (!foundFile) {
+        return {
+            ok: false,
+            error: `No subtitle file found for language '${lang}'`,
+        };
+    }
+    if (format === "csv") {
+        const vttPath = foundFile;
+        const vttContent = readFileSync(foundFile, "utf8");
+        const csvContent = vttToCsv(vttContent);
+        const csvPath = foundFile.replace(/\.vtt$/, ".csv");
+        writeFileSync(csvPath, csvContent, "utf8");
+        foundFile = csvPath;
+        if (vttPath !== csvPath) {
+            try {
+                unlinkSync(vttPath);
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+    if (options.targetFile && foundFile !== options.targetFile) {
+        renameSync(foundFile, options.targetFile);
+        foundFile = options.targetFile;
+    }
+    const stat = statSync(foundFile);
+    if (stat.size <= 100 * 1024) {
+        const text = readFileSync(foundFile, "utf8");
+        return { ok: true, text, filePath: foundFile };
+    }
+    return { ok: true, filePath: foundFile };
+}
+function isUnavailableSubtitleError(error) {
+    if (!error) {
+        return false;
+    }
+    const normalized = error.toLowerCase();
+    return (normalized.includes("no subtitle file found") ||
+        normalized.includes("no subtitles") ||
+        normalized.includes("subtitle is not available") ||
+        normalized.includes("requested subtitles are not available"));
+}
+export async function downloadSubtitlesForLanguages(input) {
+    const cookieCheck = await ensureSubtitleCookiesReady();
+    if (!cookieCheck.ok) {
+        throw new Error(cookieCheck.jobMessage);
+    }
+    const filesByFormat = {};
+    const total = input.formats.length * input.languages.length;
+    let completed = 0;
+    for (const format of input.formats) {
+        filesByFormat[format] = [];
+        for (const lang of input.languages) {
+            const targetFile = join(input.subtitlesDir, `${lang}.${format}`);
+            let result = await downloadSubtitle(input.videoId, lang, format, {
+                sourceUrl: input.sourceUrl,
+                outputDir: input.subtitlesDir,
+                outputStem: `${lang}`,
+                targetFile,
+            });
+            if (result.cookieFailureCode && result.cookieFailureCode !== "RATE_LIMITED") {
+                const refreshed = await tryRefreshSubtitleCookies();
+                if (refreshed) {
+                    result = await downloadSubtitle(input.videoId, lang, format, {
+                        sourceUrl: input.sourceUrl,
+                        outputDir: input.subtitlesDir,
+                        outputStem: `${lang}`,
+                        targetFile,
+                    });
+                }
+            }
+            if (!result.ok || !result.filePath) {
+                if (isCookieFailureText(result.error)) {
+                    throw new Error(COOKIE_JOB_MESSAGE);
+                }
+                if (input.skipMissingLanguages && isUnavailableSubtitleError(result.error)) {
+                    completed += 1;
+                    input.onProgress?.(completed, total);
+                    continue;
+                }
+                throw new Error(result.error ?? `Failed to download ${format} subtitle for ${lang}`);
+            }
+            filesByFormat[format].push(result.filePath);
+            completed += 1;
+            input.onProgress?.(completed, total);
+        }
+    }
+    const hasAnySubtitleFiles = Object.values(filesByFormat).some((files) => files.length > 0);
+    if (!hasAnySubtitleFiles) {
+        throw new Error(`No subtitles found for requested languages: ${input.languages.join(", ")}`);
+    }
+    return filesByFormat;
+}
+export { COOKIE_EXPIRED_MESSAGE, COOKIE_INVALID_MESSAGE, SIGN_IN_REQUIRED_MESSAGE, RATE_LIMITED_MESSAGE };

package/dist/tools/subtitles/parse.d.ts

@@ -0,0 +1 @@
+export declare function vttToCsv(vtt: string): string;

package/dist/tools/subtitles/parse.js

@@ -0,0 +1,106 @@
+function decodeHtmlEntities(text) {
+    return text
+        .replace(/>/g, ">")
+        .replace(/&lt;/g, "<")
+        .replace(/&amp;/g, "&")
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&nbsp;/g, " ");
+}
+function parseTimestamp(line) {
+    const match = line.match(/(\d{1,2}:\d{2}:\d{2}\.\d{3})\s*-->\s*(\d{1,2}:\d{2}:\d{2}\.\d{3})/);
+    if (!match)
+        return null;
+    const toSec = (t) => {
+        const parts = t.split(":");
+        return Number(parts[0]) * 3600 + Number(parts[1]) * 60 + Number(parts[2]);
+    };
+    return {
+        startStr: match[1],
+        endStr: match[2],
+        startSec: toSec(match[1]),
+        endSec: toSec(match[2]),
+    };
+}
+function csvEscapeField(value) {
+    if (/[",\n\r]/.test(value)) {
+        return `"${value.replace(/"/g, '""')}"`;
+    }
+    return value;
+}
+export function vttToCsv(vtt) {
+    const lines = vtt.split("\n");
+    const isAutoCaption = /<\d{2}:\d{2}:\d{2}\.\d{3}><c>/.test(vtt);
+    const rawCues = [];
+    let currentTs = null;
+    let currentTextLines = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.includes(" --> ")) {
+            if (currentTs && currentTextLines.length > 0) {
+                let text;
+                if (isAutoCaption && currentTextLines.length >= 2) {
+                    text = decodeHtmlEntities(currentTextLines[currentTextLines.length - 1]
+                        .replace(/<[^>]*>/g, "")
+                        .trim());
+                }
+                else {
+                    text = decodeHtmlEntities(currentTextLines
+                        .map((l) => l.replace(/<[^>]*>/g, "").trim())
+                        .filter(Boolean)
+                        .join(" "));
+                }
+                if (text) {
+                    rawCues.push({ ...currentTs, text });
+                }
+            }
+            currentTs = parseTimestamp(trimmed);
+            currentTextLines = [];
+        }
+        else if (trimmed &&
+            !trimmed.startsWith("WEBVTT") &&
+            !trimmed.startsWith("Kind:") &&
+            !trimmed.startsWith("Language:") &&
+            !/^\d+$/.test(trimmed)) {
+            currentTextLines.push(trimmed);
+        }
+    }
+    if (currentTs && currentTextLines.length > 0) {
+        let text;
+        if (isAutoCaption && currentTextLines.length >= 2) {
+            text = decodeHtmlEntities(currentTextLines[currentTextLines.length - 1]
+                .replace(/<[^>]*>/g, "")
+                .trim());
+        }
+        else {
+            text = decodeHtmlEntities(currentTextLines
+                .map((l) => l.replace(/<[^>]*>/g, "").trim())
+                .filter(Boolean)
+                .join(" "));
+        }
+        if (text) {
+            rawCues.push({ ...currentTs, text });
+        }
+    }
+    if (rawCues.length === 0) {
+        return "start_time,end_time,text\n";
+    }
+    const deduped = [];
+    for (let i = 0; i < rawCues.length; i++) {
+        const cur = rawCues[i];
+        const duration = cur.endSec - cur.startSec;
+        if (duration < 0.05)
+            continue;
+        if (deduped.length > 0 && deduped[deduped.length - 1].text === cur.text) {
+            deduped[deduped.length - 1].endSec = cur.endSec;
+            deduped[deduped.length - 1].endStr = cur.endStr;
+            continue;
+        }
+        deduped.push({ ...cur });
+    }
+    const csvRows = ["start_time,end_time,text"];
+    for (const cue of deduped) {
+        csvRows.push(`${cue.startStr},${cue.endStr},${csvEscapeField(cue.text)}`);
+    }
+    return csvRows.join("\n") + "\n";
+}

package/dist/tools/subtitles.d.ts

@@ -1,29 +1,8 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { TokenManager } from "@mkterswingman/5mghost-shared-client/auth";
 import type { YtMcpConfig } from "../utils/config.js";
-import type { TokenManager } from "../auth/tokenManager.js";
-export declare function toReadableSubtitleJobError(error: unknown): string;
-/**
- * Convert VTT subtitle content to clean, human-readable CSV.
- *
- * YouTube auto-captions use a "rolling" VTT format where each cue has two
- * lines: the first line repeats the previous cue's text, and the second line
- * contains new words (marked with <c> tags for word-level timing). This
- * function detects and handles this pattern:
- *
- * 1. Detects auto-caption format (presence of <c> word-timing tags)
- * 2. For auto-captions: extracts only the NEW text from each cue's second
- *    line, skips transition cues, and concatenates into clean sentences
- * 3. For manual subtitles: passes through cleanly with no data loss
- * 4. Outputs: start_time, end_time, text
- */
-export declare function vttToCsv(vtt: string): string;
-export declare function downloadSubtitlesForLanguages(input: {
-    videoId: string;
-    sourceUrl?: string;
-    languages: string[];
-    formats: string[];
-    subtitlesDir: string;
-    skipMissingLanguages?: boolean;
-    onProgress?: (completed: number, total: number) => void;
-}): Promise<Record<string, string[]>>;
+import { toReadableSubtitleJobError } from "./subtitles/cookieSession.js";
+import { downloadSubtitlesForLanguages } from "./subtitles/download.js";
+import { vttToCsv } from "./subtitles/parse.js";
+export { vttToCsv, downloadSubtitlesForLanguages, toReadableSubtitleJobError };
 export declare function registerSubtitleTools(server: McpServer, config: YtMcpConfig, tokenManager: TokenManager): void;