@mkterswingman/5mghost-yonder 0.0.38 → 0.0.40

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 { YtMcpConfig } from "../utils/config.js";
 import type { TokenManager } from "@mkterswingman/5mghost-shared-client/auth";
-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 type { YtMcpConfig } from "../utils/config.js";
+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;