yt2text 0.1.0

package/dist/logger.js

@@ -0,0 +1,32 @@
+import { mkdir } from "node:fs/promises";
+import { createWriteStream } from "node:fs";
+import { dirname } from "node:path";
+let stream;
+function serialize(value) {
+    if (typeof value === "string")
+        return value;
+    if (value instanceof Error)
+        return value.stack ?? value.message;
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+export async function installLogger(path) {
+    if (!path || stream)
+        return;
+    await mkdir(dirname(path), { recursive: true });
+    stream = createWriteStream(path, { flags: "a" });
+    const originalError = console.error.bind(console);
+    const originalLog = console.log.bind(console);
+    console.error = (...args) => {
+        stream?.write(`[${new Date().toISOString()}] ${args.map(serialize).join(" ")}\n`);
+        originalError(...args);
+    };
+    console.log = (...args) => {
+        stream?.write(`[${new Date().toISOString()}] ${args.map(serialize).join(" ")}\n`);
+        originalLog(...args);
+    };
+}

package/dist/media.js

@@ -0,0 +1,224 @@
+import { basename, join } from "node:path";
+import { access, copyFile } from "node:fs/promises";
+import { detectCookieBrowsers } from "./cookies.js";
+import { ensureYtDlp, getFfmpegPath } from "./deps.js";
+import { asError, Yt2TextError } from "./errors.js";
+import { ProgressBar } from "./progress.js";
+import { runCommand } from "./process.js";
+function sanitizeName(value) {
+    return value.replace(/[\\/:*?"<>|]+/g, " ").replace(/\s+/g, " ").trim().slice(0, 160) || "audio";
+}
+function timeoutMs(seconds) {
+    return seconds > 0 ? seconds * 1000 : undefined;
+}
+function audioFormatSelector(quality) {
+    if (quality === "small")
+        return "bestaudio[abr<=64]/bestaudio[abr<=96]/bestaudio/best";
+    if (quality === "balanced")
+        return "bestaudio[abr<=160]/bestaudio[abr<=192]/bestaudio/best";
+    return "bestaudio/best";
+}
+async function assertReadable(path, kind) {
+    try {
+        await access(path);
+    }
+    catch {
+        if (kind === "media") {
+            throw new Yt2TextError(`Input media file not found or not readable: ${path}\n\nHint: 检查文件路径是否正确；如果路径里有空格，请用引号包起来。`, "INPUT_FILE_NOT_FOUND");
+        }
+        throw new Yt2TextError(`Cookies file not found: ${path}\n\nHint: 用浏览器 cookies 时可以省略 --cookies，改用 --cookies-from-browser chrome/safari/firefox；手动 cookies 文件需要是 Netscape cookies.txt 格式。`, "COOKIE_FILE_NOT_FOUND");
+    }
+}
+function explainYtDlpFailure(error, context) {
+    const message = asError(error).message;
+    const lower = message.toLowerCase();
+    const hints = [];
+    if (context.noDetectedBrowsers) {
+        hints.push("没有检测到可用浏览器 cookies。请确认 Chrome/Safari/Firefox 已安装并登录 YouTube，或用 --cookies <cookies.txt>。");
+    }
+    if (context.browser) {
+        hints.push(`刚才尝试读取 ${context.browser} cookies 失败。可以关闭浏览器后重试，或换 --cookies-from-browser safari/firefox。`);
+    }
+    if (lower.includes("sign in to confirm") || lower.includes("not a bot")) {
+        hints.push("YouTube 要求登录验证。请使用浏览器 cookies，或在交互模式里选择已登录 YouTube 的浏览器。");
+    }
+    if (lower.includes("could not find") && lower.includes("cookies")) {
+        hints.push("yt-dlp 没找到该浏览器的 cookies 数据库。确认浏览器已安装，或手动导出 cookies.txt 后用 --cookies 指定。");
+    }
+    if (lower.includes("database is locked") || lower.includes("permission")) {
+        hints.push("浏览器 cookies 可能被锁定或无权限读取。完全退出浏览器后重试。");
+    }
+    if (lower.includes("http error 403") || lower.includes("forbidden")) {
+        hints.push("403 通常是 cookies/yt-dlp 过期或地区/网络限制。可试 --update-ytdlp，或设置 --proxy。");
+    }
+    return new Yt2TextError(`Failed to download audio with yt-dlp.\n\n${message}${hints.length ? `\n\n${hints.map((hint) => `Hint: ${hint}`).join("\n")}` : ""}`, "YTDLP_FAILED");
+}
+function createYtdlpProgressHandler(progress) {
+    let buffer = "";
+    return (text) => {
+        buffer += text;
+        const lines = buffer.split(/\r?\n/);
+        buffer = lines.pop() ?? "";
+        for (const raw of lines) {
+            const line = raw.trim();
+            if (!line.startsWith("YT2TEXT_PROGRESS:"))
+                continue;
+            const [percentText, downloaded, total, speed, eta] = line.replace("YT2TEXT_PROGRESS:", "").split("|");
+            const match = percentText.match(/(\d+(?:\.\d+)?)%/);
+            if (!match)
+                continue;
+            const details = [downloaded, total && total !== "N/A" ? `of ${total}` : "", speed && speed !== "N/A" ? `at ${speed}` : "", eta && eta !== "N/A" ? `ETA ${eta}` : ""]
+                .filter(Boolean)
+                .join(" ");
+            progress.updatePercent(Number(match[1]), details);
+        }
+    };
+}
+export async function downloadMedia(url, paths, options) {
+    const ytdlp = await ensureYtDlp(paths, options);
+    if (options.cookies) {
+        await assertReadable(options.cookies, "cookies");
+    }
+    const template = join(paths.workDir, "%(title).160B [%(id)s].%(ext)s");
+    const baseArgs = [
+        "--no-playlist",
+        "--no-warnings",
+        "--quiet",
+        "--progress",
+        "--newline",
+        "--progress-delta",
+        "0.5",
+        "--progress-template",
+        "download:YT2TEXT_PROGRESS:%(progress._percent_str)s|%(progress._downloaded_bytes_str)s|%(progress._total_bytes_str)s|%(progress._speed_str)s|%(progress._eta_str)s",
+        "--remote-components",
+        "ejs:github",
+        "--js-runtimes",
+        "node",
+        "-f",
+        audioFormatSelector(options.audioQuality),
+        "-N",
+        String(options.concurrentFragments),
+        "--retries",
+        String(options.retries),
+        "--fragment-retries",
+        String(options.fragmentRetries),
+        "--socket-timeout",
+        String(options.socketTimeout),
+        "-o",
+        template,
+        "--print",
+        "after_move:filepath",
+    ];
+    if (options.proxy) {
+        baseArgs.push("--proxy", options.proxy);
+    }
+    if (options.rateLimit) {
+        baseArgs.push("--limit-rate", options.rateLimit);
+    }
+    if (options.userAgent) {
+        baseArgs.push("--user-agent", options.userAgent);
+    }
+    const browserCandidates = options.cookies || !options.browserCookies
+        ? []
+        : options.cookiesFromBrowser === "auto"
+            ? await detectCookieBrowsers()
+            : options.cookiesFromBrowser
+                ? [{ id: options.cookiesFromBrowser, name: options.cookiesFromBrowser }]
+                : [];
+    const attempts = browserCandidates.length > 0 ? browserCandidates : [undefined];
+    const noDetectedBrowsers = Boolean(options.browserCookies && options.cookiesFromBrowser === "auto" && browserCandidates.length === 0);
+    let lastError;
+    for (const browser of attempts) {
+        const args = [...baseArgs];
+        const progress = new ProgressBar("Downloading audio");
+        const handleProgress = createYtdlpProgressHandler(progress);
+        if (options.cookies) {
+            args.push("--cookies", options.cookies);
+        }
+        if (browser) {
+            console.error(`Using browser cookies: ${browser.name}`);
+            args.push("--cookies-from-browser", browser.id);
+        }
+        else if (options.cookiesFromBrowser === "auto") {
+            console.error("No supported browser cookies found; trying without cookies.");
+        }
+        args.push(url);
+        try {
+            const result = await runCommand(ytdlp, args, {
+                quiet: true,
+                onStdout: handleProgress,
+                onStderr: handleProgress,
+                timeoutMs: timeoutMs(options.downloadTimeoutSeconds),
+            });
+            progress.finish();
+            const mediaPath = result.stdout
+                .trim()
+                .split(/\r?\n/)
+                .map((line) => line.trim())
+                .filter((line) => line && !line.startsWith("YT2TEXT_PROGRESS:"))
+                .at(-1);
+            if (!mediaPath) {
+                throw new Error("yt-dlp did not report an output file path");
+            }
+            return {
+                mediaPath,
+                title: sanitizeName(basename(mediaPath).replace(/\.[^.]+$/, "")),
+            };
+        }
+        catch (error) {
+            lastError = error;
+            progress.fail();
+            if (options.cookiesFromBrowser !== "auto" || !browser) {
+                throw explainYtDlpFailure(error, {
+                    browser: browser?.name,
+                    autoCookies: options.cookiesFromBrowser === "auto",
+                    noDetectedBrowsers,
+                });
+            }
+            console.error(`Could not use ${browser.name} cookies; trying another browser.`);
+        }
+    }
+    throw explainYtDlpFailure(lastError ?? new Error("yt-dlp download failed"), {
+        autoCookies: options.cookiesFromBrowser === "auto",
+        noDetectedBrowsers,
+    });
+}
+export async function prepareLocalMedia(inputPath, paths) {
+    await assertReadable(inputPath, "media");
+    const title = sanitizeName(basename(inputPath).replace(/\.[^.]+$/, ""));
+    const copied = join(paths.workDir, basename(inputPath));
+    await copyFile(inputPath, copied);
+    return { mediaPath: copied, title };
+}
+export async function normalizeToWav(inputPath, outputPath, timeoutSeconds = 0) {
+    const ffmpeg = await getFfmpegPath();
+    await runCommand(ffmpeg, ["-y", "-hide_banner", "-loglevel", "error", "-i", inputPath, "-vn", "-ac", "1", "-ar", "16000", outputPath], { quiet: true, timeoutMs: timeoutMs(timeoutSeconds) });
+    return outputPath;
+}
+export async function splitWav(wavPath, outputDir, chunkSeconds, timeoutSeconds = 0) {
+    if (chunkSeconds <= 0)
+        return [wavPath];
+    const ffmpeg = await getFfmpegPath();
+    const pattern = join(outputDir, "chunk_%04d.wav");
+    await runCommand(ffmpeg, [
+        "-y",
+        "-hide_banner",
+        "-loglevel",
+        "error",
+        "-i",
+        wavPath,
+        "-f",
+        "segment",
+        "-segment_time",
+        String(chunkSeconds),
+        "-c",
+        "copy",
+        pattern,
+    ], { quiet: true, timeoutMs: timeoutMs(timeoutSeconds) });
+    const { readdir } = await import("node:fs/promises");
+    const files = await readdir(outputDir);
+    return files
+        .filter((file) => /^chunk_\d+\.wav$/.test(file))
+        .sort()
+        .map((file) => join(outputDir, file));
+}

package/dist/output.js

@@ -0,0 +1,62 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+function sanitizeFilePart(value) {
+    return value.replace(/[\\/:*?"<>|]+/g, " ").replace(/\s+/g, " ").trim();
+}
+function timestamp(seconds) {
+    const safe = Math.max(0, seconds);
+    const hours = Math.floor(safe / 3600);
+    const minutes = Math.floor((safe % 3600) / 60);
+    const secs = Math.floor(safe % 60);
+    const millis = Math.round((safe - Math.floor(safe)) * 1000);
+    if (hours > 0) {
+        return `${hours.toString().padStart(2, "0")}:${minutes.toString().padStart(2, "0")}:${secs
+            .toString()
+            .padStart(2, "0")}.${millis.toString().padStart(3, "0")}`;
+    }
+    return `${minutes.toString().padStart(2, "0")}:${secs.toString().padStart(2, "0")}.${millis
+        .toString()
+        .padStart(3, "0")}`;
+}
+function srtTimestamp(seconds) {
+    return timestamp(seconds).replace(".", ",").padStart(12, "00:");
+}
+function textLine(segment) {
+    const speaker = segment.speaker ? `${segment.speaker}: ` : "";
+    return `[${timestamp(segment.start)} - ${timestamp(segment.end)}] ${speaker}${segment.text}`;
+}
+function toTxt(document) {
+    return `${document.segments.map(textLine).join("\n")}\n`;
+}
+function toSrt(document) {
+    return `${document.segments
+        .map((segment, index) => {
+        const speaker = segment.speaker ? `${segment.speaker}: ` : "";
+        return `${index + 1}\n${srtTimestamp(segment.start)} --> ${srtTimestamp(segment.end)}\n${speaker}${segment.text}`;
+    })
+        .join("\n\n")}\n`;
+}
+export async function writeTranscript(document, outputDir, format, filenameTemplate = "{title}") {
+    await mkdir(outputDir, { recursive: true });
+    const outputPath = join(outputDir, `${renderOutputStem(document, filenameTemplate)}.${format}`);
+    const body = format === "json" ? `${JSON.stringify(document, null, 2)}\n` : format === "srt" ? toSrt(document) : toTxt(document);
+    await writeFile(outputPath, body, "utf8");
+    return outputPath;
+}
+export function renderOutputStem(document, template) {
+    const createdAt = new Date(document.createdAt);
+    const date = Number.isNaN(createdAt.getTime()) ? new Date().toISOString().slice(0, 10) : createdAt.toISOString().slice(0, 10);
+    const datetime = Number.isNaN(createdAt.getTime())
+        ? new Date().toISOString().replace(/[:.]/g, "-")
+        : createdAt.toISOString().replace(/[:.]/g, "-");
+    const values = {
+        title: document.title ?? "transcript",
+        language: document.language,
+        engine: document.engine,
+        date,
+        datetime,
+        source: document.source,
+    };
+    const rendered = template.replace(/\{([a-zA-Z][a-zA-Z0-9_]*)\}/g, (match, key) => values[key] ?? match);
+    return sanitizeFilePart(rendered) || "transcript";
+}

package/dist/platform.js

@@ -0,0 +1,39 @@
+export function isSupportedPlatform() {
+    return process.platform === "darwin" || process.platform === "linux" || process.platform === "win32";
+}
+export function defaultAsrProvider() {
+    return process.platform === "linux" ? "local" : "system";
+}
+export function defaultSystemMode() {
+    return process.platform === "darwin" || process.platform === "win32" ? "offline" : "online";
+}
+export function platformName() {
+    if (process.platform === "darwin")
+        return "macOS";
+    if (process.platform === "linux")
+        return "Linux";
+    if (process.platform === "win32")
+        return "Windows";
+    return process.platform;
+}
+export function executableName(name) {
+    return process.platform === "win32" ? `${name}.exe` : name;
+}
+export function ytdlpReleaseUrl() {
+    if (process.platform === "darwin") {
+        return "https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp_macos";
+    }
+    if (process.platform === "win32") {
+        if (process.arch === "arm64") {
+            return "https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp_arm64.exe";
+        }
+        return "https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp.exe";
+    }
+    if (process.platform === "linux") {
+        if (process.arch === "arm64") {
+            return "https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp_linux_aarch64";
+        }
+        return "https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp_linux";
+    }
+    throw new Error(`Unsupported platform: ${process.platform}. yt2text supports macOS, Linux, and Windows only.`);
+}

package/dist/process.js

@@ -0,0 +1,69 @@
+import { spawn } from "node:child_process";
+import { Yt2TextError } from "./errors.js";
+export function runCommand(command, args, options = {}) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        let killTimer;
+        const child = spawn(command, args, {
+            cwd: options.cwd,
+            env: { ...process.env, ...options.env },
+            windowsHide: true,
+        });
+        const cleanup = () => {
+            if (timeout)
+                clearTimeout(timeout);
+            if (killTimer)
+                clearTimeout(killTimer);
+        };
+        const timeout = options.timeoutMs && options.timeoutMs > 0
+            ? setTimeout(() => {
+                settled = true;
+                child.kill("SIGTERM");
+                killTimer = setTimeout(() => child.kill("SIGKILL"), 2000);
+                reject(new Yt2TextError(`${command} timed out after ${Math.round(options.timeoutMs / 1000)} seconds`, "COMMAND_TIMEOUT"));
+            }, options.timeoutMs)
+            : undefined;
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (chunk) => {
+            const text = chunk.toString();
+            stdout += text;
+            options.onStdout?.(text);
+            if (!options.quiet)
+                process.stdout.write(text);
+        });
+        child.stderr.on("data", (chunk) => {
+            const text = chunk.toString();
+            stderr += text;
+            options.onStderr?.(text);
+            if (!options.quiet)
+                process.stderr.write(text);
+        });
+        child.on("error", (error) => {
+            if (settled) {
+                cleanup();
+                return;
+            }
+            settled = true;
+            cleanup();
+            if (error.code === "ENOENT") {
+                reject(new Yt2TextError(`${command} was not found in PATH`, "COMMAND_NOT_FOUND"));
+                return;
+            }
+            reject(error);
+        });
+        child.on("close", (code) => {
+            if (settled) {
+                cleanup();
+                return;
+            }
+            settled = true;
+            cleanup();
+            if (code === 0) {
+                resolve({ stdout, stderr });
+                return;
+            }
+            reject(new Yt2TextError(`${command} exited with code ${code ?? "unknown"}\n${stderr.trim() || stdout.trim()}`, "COMMAND_FAILED"));
+        });
+    });
+}

package/dist/progress.js

@@ -0,0 +1,79 @@
+function clamp(value) {
+    if (!Number.isFinite(value))
+        return 0;
+    return Math.max(0, Math.min(1, value));
+}
+function formatBytes(bytes) {
+    if (!Number.isFinite(bytes) || bytes < 0)
+        return "";
+    const units = ["B", "KB", "MB", "GB", "TB"];
+    let value = bytes;
+    let unit = 0;
+    while (value >= 1024 && unit < units.length - 1) {
+        value /= 1024;
+        unit += 1;
+    }
+    const precision = unit === 0 || value >= 10 ? 0 : 1;
+    return `${value.toFixed(precision)} ${units[unit]}`;
+}
+export class ProgressBar {
+    label;
+    width;
+    lastRender = 0;
+    lastLinePercent = -1;
+    active = false;
+    isTty = Boolean(process.stderr.isTTY);
+    constructor(label, width = 28) {
+        this.label = label;
+        this.width = width;
+    }
+    updatePercent(percent, detail = "") {
+        this.update(percent / 100, detail);
+    }
+    updateBytes(done, total, detail = "") {
+        if (total && total > 0) {
+            this.update(done / total, `${formatBytes(done)}/${formatBytes(total)}${detail ? ` ${detail}` : ""}`);
+            return;
+        }
+        this.render(undefined, `${formatBytes(done)}${detail ? ` ${detail}` : ""}`);
+    }
+    update(ratio, detail = "") {
+        this.render(clamp(ratio), detail);
+    }
+    finish(detail = "done") {
+        this.render(1, detail, true);
+        if (this.isTty)
+            process.stderr.write("\n");
+        this.active = false;
+    }
+    fail(detail = "failed") {
+        this.render(undefined, detail, true);
+        if (this.isTty)
+            process.stderr.write("\n");
+        this.active = false;
+    }
+    render(ratio, detail = "", force = false) {
+        const now = Date.now();
+        if (!force && now - this.lastRender < 120)
+            return;
+        this.lastRender = now;
+        this.active = true;
+        if (!this.isTty) {
+            const percent = ratio === undefined ? -1 : Math.floor(ratio * 100);
+            if (!force && percent >= 0 && percent < this.lastLinePercent + 10)
+                return;
+            this.lastLinePercent = percent;
+            const prefix = percent >= 0 ? `${percent.toString().padStart(3, " ")}%` : "...";
+            console.error(`${this.label}: ${prefix}${detail ? ` ${detail}` : ""}`);
+            return;
+        }
+        const percent = ratio === undefined ? undefined : Math.round(ratio * 100);
+        const filled = ratio === undefined ? 0 : Math.round(ratio * this.width);
+        const bar = ratio === undefined
+            ? `${".".repeat(Math.min(this.width, 3))}${" ".repeat(Math.max(0, this.width - 3))}`
+            : `${"#".repeat(filled)}${"-".repeat(this.width - filled)}`;
+        const percentText = percent === undefined ? "   " : `${percent.toString().padStart(3, " ")}%`;
+        const text = `${this.label} [${bar}] ${percentText}${detail ? ` ${detail}` : ""}`;
+        process.stderr.write(`\r${text.slice(0, process.stderr.columns ?? 120).padEnd(process.stderr.columns ?? 120, " ")}`);
+    }
+}

package/dist/segments.js

@@ -0,0 +1,36 @@
+export function mergeWordSegments(words) {
+    const sorted = words
+        .filter((word) => word.text.trim())
+        .sort((a, b) => a.start - b.start);
+    const merged = [];
+    for (const word of sorted) {
+        const previous = merged.at(-1);
+        const gap = previous ? word.start - previous.end : Number.POSITIVE_INFINITY;
+        const candidateLength = previous ? `${previous.text} ${word.text}`.length : 0;
+        if (!previous || gap > 0.85 || candidateLength > 180) {
+            merged.push({ ...word, text: word.text.trim() });
+            continue;
+        }
+        previous.end = Math.max(previous.end, word.end);
+        previous.text = `${previous.text} ${word.text.trim()}`;
+        if (word.confidence !== undefined) {
+            previous.confidence =
+                previous.confidence === undefined ? word.confidence : Math.min(previous.confidence, word.confidence);
+        }
+    }
+    return merged;
+}
+export function assignSpeakers(transcript, speakers) {
+    return transcript.map((segment) => {
+        let bestSpeaker;
+        let bestOverlap = 0;
+        for (const speaker of speakers) {
+            const overlap = Math.max(0, Math.min(segment.end, speaker.end) - Math.max(segment.start, speaker.start));
+            if (overlap > bestOverlap) {
+                bestOverlap = overlap;
+                bestSpeaker = speaker.speaker;
+            }
+        }
+        return bestSpeaker ? { ...segment, speaker: bestSpeaker } : segment;
+    });
+}