@mkterswingman/5mghost-yonder 0.0.11 → 0.0.13

package/dist/download/downloader.d.ts

@@ -38,6 +38,7 @@ interface DownloadOneItemDeps {
         videoQuality: string;
         onProgress: (update: DownloadOneItemProgressUpdate) => void;
     }) => Promise<string>;
+    refreshCookies: () => Promise<boolean>;
     downloadSubtitles: (input: {
         videoId: string;
         sourceUrl: string;

package/dist/download/downloader.js

@@ -2,9 +2,11 @@ import { mkdir, rm, stat, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { downloadSubtitlesForLanguages, toReadableSubtitleJobError } from "../tools/subtitles.js";
 import { loadConfig } from "../utils/config.js";
+import { tryHeadlessRefresh } from "../utils/cookieRefresh.js";
 import { hasFfmpeg, isRuntimeMissingMessage } from "../utils/ffmpeg.js";
 import { formatBytes } from "../utils/formatters.js";
 import { hasYtDlp, runYtDlp, runYtDlpJson } from "../utils/ytdlp.js";
+import { appendDiagnosticLog, classifyYtDlpFailure } from "../utils/ytdlpFailures.js";
 import { parseYtDlpProgressLine } from "../utils/ytdlpProgress.js";
 export async function downloadOneItem(input) {
     const deps = resolveDeps(input.deps);
@@ -50,12 +52,28 @@ export async function downloadOneItem(input) {
         if (needsVideo(input.mode)) {
             currentStep = "download_video";
             manager?.updateItemProgress(jobId, input.item.video_id, currentStep, 0);
-            result.video_file = await deps.downloadVideo({
-                sourceUrl: input.item.source_url,
-                outputFile: videoFile,
-                videoQuality,
-                onProgress,
-            });
+            try {
+                result.video_file = await deps.downloadVideo({
+                    sourceUrl: input.item.source_url,
+                    outputFile: videoFile,
+                    videoQuality,
+                    onProgress,
+                });
+            }
+            catch (error) {
+                const failureKind = classifyVideoDownloadError(error);
+                if (failureKind != null && failureKind !== "RATE_LIMITED" && await deps.refreshCookies()) {
+                    result.video_file = await deps.downloadVideo({
+                        sourceUrl: input.item.source_url,
+                        outputFile: videoFile,
+                        videoQuality,
+                        onProgress,
+                    });
+                }
+                else {
+                    throw error;
+                }
+            }
             result.final_file_size = formatBytes((await deps.stat(result.video_file)).size);
         }
         if (needsSubtitles(input.mode)) {
@@ -103,6 +121,7 @@ function resolveDeps(overrides) {
         hasFfmpeg,
         fetchMetadata: fetchMetadataWithYtDlp,
         downloadVideo: downloadVideoWithYtDlp,
+        refreshCookies: tryHeadlessRefresh,
         downloadSubtitles: downloadSubtitlesWithYtDlp,
         mkdir: async (path, options) => {
             await mkdir(path, options);
@@ -166,7 +185,17 @@ async function downloadVideoWithYtDlp(input) {
         }
     });
     if (result.exitCode !== 0) {
-        throw new Error(result.stderr.slice(0, 500) || `yt-dlp exited with ${result.exitCode}`);
+        const failureKind = classifyYtDlpFailure(result.stderr);
+        if (failureKind === "RATE_LIMITED") {
+            throw new Error(appendDiagnosticLog("The current YouTube session has been rate-limited. Wait and retry later.", result.failureLogPath));
+        }
+        if (failureKind === "SIGN_IN_REQUIRED") {
+            throw new Error(appendDiagnosticLog("YouTube requested an additional sign-in confirmation for this video.", result.failureLogPath));
+        }
+        if (failureKind === "COOKIES_INVALID" || failureKind === "COOKIES_EXPIRED") {
+            throw new Error(appendDiagnosticLog("YouTube rejected the current cookies for video download.", result.failureLogPath));
+        }
+        throw new Error(appendDiagnosticLog(result.stderr.slice(0, 500) || `yt-dlp exited with ${result.exitCode}`, result.failureLogPath));
     }
     return resolveYtDlpOutputPath(input.outputFile, result.stdout);
 }
@@ -259,6 +288,10 @@ function sortSubtitleFiles(files) {
         .sort(([left], [right]) => left.localeCompare(right))
         .map(([format, paths]) => [format, [...paths].sort()]));
 }
+function classifyVideoDownloadError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return classifyYtDlpFailure(message);
+}
 function toErrorMessage(error) {
     return toReadableSubtitleJobError(error);
 }

package/dist/tools/subtitles.js

@@ -5,12 +5,16 @@ import { PATHS } from "../utils/config.js";
 import { runYtDlp } from "../utils/ytdlp.js";
 import { hasSIDCookies, areCookiesExpired } from "../utils/cookies.js";
 import { tryHeadlessRefresh } from "../utils/cookieRefresh.js";
+import { appendDiagnosticLog, classifyYtDlpFailure } from "../utils/ytdlpFailures.js";
 import { resolveVideoInput, normalizeVideoInputs } from "../utils/videoInput.js";
 const AUTH_REQUIRED_MSG = "❌ 未认证。请先登录：\n• OAuth: npx @mkterswingman/5mghost-yonder setup\n• PAT: 设置环境变量 YT_MCP_TOKEN 或在 https://mkterswingman.com/pat/login 生成 token";
 const COOKIE_SETUP_COMMAND = "yt-mcp setup-cookies";
 const COOKIE_MISSING_MESSAGE = `No valid YouTube cookies found.\nPlease run in your terminal: ${COOKIE_SETUP_COMMAND}`;
 const COOKIE_EXPIRED_MESSAGE = `YouTube cookies have expired and auto-refresh failed.\nPlease run in your terminal: ${COOKIE_SETUP_COMMAND}`;
-const COOKIE_JOB_MESSAGE = `YouTube cookies are missing or expired.\nPlease run in your terminal: ${COOKIE_SETUP_COMMAND}`;
+const COOKIE_INVALID_MESSAGE = `YouTube rejected the current cookies and auto-refresh failed.\nPlease run in your terminal: ${COOKIE_SETUP_COMMAND}`;
+const SIGN_IN_REQUIRED_MESSAGE = `YouTube requested an additional sign-in confirmation and auto-refresh failed.\nPlease run in your terminal: ${COOKIE_SETUP_COMMAND}`;
+const RATE_LIMITED_MESSAGE = "The current YouTube session has been rate-limited. Wait and retry later.";
+const COOKIE_JOB_MESSAGE = `YouTube cookies are missing, expired, or invalid.\nPlease run in your terminal: ${COOKIE_SETUP_COMMAND}`;
 function toolOk(payload) {
     return {
         structuredContent: payload,
@@ -55,12 +59,29 @@ function isCookieFailureText(error) {
         normalized.includes("login") ||
         normalized.includes("not a bot"));
 }
+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;
 }
 async function ensureSubtitleCookiesReady() {
-    if (hasSIDCookies(PATHS.cookiesTxt) && !areCookiesExpired(PATHS.cookiesTxt)) {
+    const hasSession = hasSIDCookies(PATHS.cookiesTxt);
+    const expired = areCookiesExpired(PATHS.cookiesTxt);
+    if (hasSession && !expired) {
         return { ok: true };
     }
     const refreshed = await tryRefreshSubtitleCookies();
@@ -69,9 +90,9 @@ async function ensureSubtitleCookiesReady() {
     }
     return {
         ok: false,
-        code: "COOKIES_MISSING",
-        toolMessage: COOKIE_MISSING_MESSAGE,
-        jobMessage: COOKIE_JOB_MESSAGE,
+        code: hasSession && expired ? "COOKIES_EXPIRED" : "COOKIES_MISSING",
+        toolMessage: hasSession && expired ? COOKIE_EXPIRED_MESSAGE : COOKIE_MISSING_MESSAGE,
+        jobMessage: appendDiagnosticLog(COOKIE_JOB_MESSAGE, undefined),
     };
 }
 /**
@@ -244,16 +265,20 @@ async function downloadSubtitle(videoId, lang, format, options = {}) {
         outTemplate,
         options.sourceUrl ?? `https://www.youtube.com/watch?v=${videoId}`,
     ]);
-    if (result.exitCode !== 0 &&
-        (result.stderr.includes("Sign in") ||
-            result.stderr.includes("cookies") ||
-            result.stderr.includes("login"))) {
-        return { ok: false, cookiesExpired: true, error: "COOKIES_EXPIRED" };
+    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,
-            error: result.stderr.slice(0, 500) || `yt-dlp exited with ${result.exitCode}`,
+            diagnosticLogPath: result.failureLogPath,
+            error: appendDiagnosticLog(result.stderr.slice(0, 500) || `yt-dlp exited with ${result.exitCode}`, result.failureLogPath),
         };
     }
     // Find the output file - yt-dlp appends lang and format extension.
@@ -335,7 +360,7 @@ export async function downloadSubtitlesForLanguages(input) {
                 outputStem: `${lang}`,
                 targetFile,
             });
-            if (result.cookiesExpired) {
+            if (result.cookieFailureCode && result.cookieFailureCode !== "RATE_LIMITED") {
                 const refreshed = await tryRefreshSubtitleCookies();
                 if (refreshed) {
                     result = await downloadSubtitle(input.videoId, lang, format, {
@@ -419,7 +444,7 @@ export function registerSubtitleTools(server, config, tokenManager) {
             }
             const lang = langs[i];
             const dl = await downloadSubtitle(videoId, lang, fmt);
-            if (dl.cookiesExpired) {
+            if (dl.cookieFailureCode) {
                 const refreshed = await tryRefreshSubtitleCookies();
                 if (refreshed) {
                     // Retry the download with fresh cookies
@@ -435,7 +460,14 @@ export function registerSubtitleTools(server, config, tokenManager) {
                     }
                     // Retry also failed with expired cookies — give up
                 }
-                return toolErr("COOKIES_EXPIRED", COOKIE_EXPIRED_MESSAGE);
+                return toolErr(dl.cookieFailureCode, dl.error ??
+                    (dl.cookieFailureCode === "COOKIES_EXPIRED"
+                        ? COOKIE_EXPIRED_MESSAGE
+                        : dl.cookieFailureCode === "SIGN_IN_REQUIRED"
+                            ? SIGN_IN_REQUIRED_MESSAGE
+                            : dl.cookieFailureCode === "RATE_LIMITED"
+                                ? RATE_LIMITED_MESSAGE
+                                : COOKIE_INVALID_MESSAGE));
             }
             if (!dl.ok) {
                 // When using default languages, silently skip unavailable ones
@@ -505,14 +537,14 @@ export function registerSubtitleTools(server, config, tokenManager) {
             const videoId = resolvedIds[v];
             const langFound = [];
             let lastError;
-            let cookiesExpired = false;
+            let cookieFailureCode = null;
             for (let l = 0; l < langs.length; l++) {
                 if (l > 0) {
                     await randomSleep(2000, 5000);
                 }
                 const dl = await downloadSubtitle(videoId, langs[l], fmt);
-                if (dl.cookiesExpired) {
-                    cookiesExpired = true;
+                if (dl.cookieFailureCode) {
+                    cookieFailureCode = dl.cookieFailureCode;
                     break;
                 }
                 if (dl.ok) {
@@ -522,7 +554,10 @@ export function registerSubtitleTools(server, config, tokenManager) {
                     lastError = dl.error;
                 }
             }
-            if (cookiesExpired) {
+            if (cookieFailureCode === "RATE_LIMITED") {
+                return toolErr("RATE_LIMITED", RATE_LIMITED_MESSAGE);
+            }
+            if (cookieFailureCode) {
                 const refreshed = await tryRefreshSubtitleCookies();
                 if (refreshed) {
                     // Retry this video's subtitles
@@ -535,11 +570,15 @@ export function registerSubtitleTools(server, config, tokenManager) {
                         }
                     }
                     if (retrySuccess) {
-                        cookiesExpired = false;
+                        cookieFailureCode = null;
                     }
                 }
-                if (cookiesExpired) {
-                    return toolErr("COOKIES_EXPIRED", COOKIE_EXPIRED_MESSAGE);
+                if (cookieFailureCode) {
+                    return toolErr(cookieFailureCode, cookieFailureCode === "COOKIES_EXPIRED"
+                        ? COOKIE_EXPIRED_MESSAGE
+                        : cookieFailureCode === "SIGN_IN_REQUIRED"
+                            ? SIGN_IN_REQUIRED_MESSAGE
+                            : COOKIE_INVALID_MESSAGE);
                 }
             }
             if (langFound.length > 0) {

package/dist/utils/config.d.ts

@@ -6,6 +6,7 @@ export declare function buildPaths(homeDir?: string): {
     configDir: string;
     authJson: string;
     cookiesTxt: string;
+    logsDir: string;
     browserProfile: string;
     launcherJs: string;
     npmCacheDir: string;
@@ -25,6 +26,7 @@ export declare const PATHS: {
     configDir: string;
     authJson: string;
     cookiesTxt: string;
+    logsDir: string;
     browserProfile: string;
     launcherJs: string;
     npmCacheDir: string;

package/dist/utils/config.js

@@ -20,6 +20,7 @@ export function buildPaths(homeDir = homedir()) {
         configDir,
         authJson: join(configDir, "auth.json"),
         cookiesTxt: join(configDir, "cookies.txt"),
+        logsDir: join(configDir, "logs"),
         browserProfile: join(configDir, "browser-profile"),
         launcherJs: join(configDir, "launcher.mjs"),
         npmCacheDir: join(configDir, "npm-cache"),

package/dist/utils/cookies.js

@@ -15,12 +15,39 @@ export function cookiesToNetscape(cookies) {
     }
     return lines.join("\n") + "\n";
 }
+function parseCookieRows(content) {
+    const rows = [];
+    for (const line of content.split("\n")) {
+        if (line.startsWith("#") || !line.trim())
+            continue;
+        const fields = line.split("\t");
+        if (fields.length < 7)
+            continue;
+        rows.push({
+            domain: fields[0],
+            expires: Number(fields[4]),
+            name: fields[5],
+        });
+    }
+    return rows;
+}
+function hasCookieTriplet(rows, domainFragment) {
+    const names = new Set(rows
+        .filter((row) => row.domain.includes(domainFragment))
+        .map((row) => row.name));
+    return names.has("SID") && names.has("HSID") && names.has("SSID");
+}
 export function hasSIDCookies(cookiesPath) {
     if (!existsSync(cookiesPath))
         return false;
     try {
         const content = readFileSync(cookiesPath, "utf8");
-        return content.includes("SID") && content.includes(".youtube.com");
+        const rows = parseCookieRows(content);
+        if (hasCookieTriplet(rows, "youtube.com")) {
+            return true;
+        }
+        const hasYouTubeLoginInfo = rows.some((row) => row.name === "LOGIN_INFO" && row.domain.includes("youtube.com"));
+        return hasYouTubeLoginInfo && hasCookieTriplet(rows, "google.");
     }
     catch {
         return false;
@@ -48,19 +75,14 @@ export function areCookiesExpired(cookiesPath) {
     try {
         const content = readFileSync(cookiesPath, "utf8");
         const nowSec = Date.now() / 1000;
+        const rows = parseCookieRows(content);
         let foundAnySession = false;
         let foundAnyValid = false;
-        for (const line of content.split("\n")) {
-            if (line.startsWith("#") || !line.trim())
-                continue;
-            const fields = line.split("\t");
-            if (fields.length < 7)
-                continue;
-            const name = fields[5];
-            if (!SESSION_COOKIE_PATTERNS.includes(name))
+        for (const row of rows) {
+            if (!SESSION_COOKIE_PATTERNS.includes(row.name))
                 continue;
             foundAnySession = true;
-            const expiry = Number(fields[4]);
+            const expiry = row.expires;
             // expiry 0 = session cookie (no expiration) — treat as valid
             if (expiry === 0 || expiry >= nowSec) {
                 foundAnyValid = true;

package/dist/utils/ytdlp.d.ts

@@ -4,6 +4,7 @@ export interface YtDlpResult {
     stdout: string;
     stderr: string;
     durationMs: number;
+    failureLogPath?: string;
 }
 export interface YtDlpStderrLineSplitter {
     push(chunk: Buffer | string): void;

package/dist/utils/ytdlp.js

@@ -1,8 +1,25 @@
 import { spawn } from "node:child_process";
 import { spawnSync } from "node:child_process";
-import { existsSync } from "node:fs";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 import { PATHS } from "./config.js";
 import { getYtDlpPath } from "./ytdlpPath.js";
+function writeYtDlpFailureLog(payload) {
+    try {
+        mkdirSync(PATHS.logsDir, { recursive: true });
+        const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+        const filePath = join(PATHS.logsDir, `yt-dlp-failure-${stamp}.json`);
+        writeFileSync(filePath, JSON.stringify({
+            timestamp: new Date().toISOString(),
+            binary: getYtDlpPath(),
+            ...payload,
+        }, null, 2), "utf8");
+        return filePath;
+    }
+    catch {
+        return undefined;
+    }
+}
 export function createYtDlpStderrLineSplitter(onLine) {
     let buffer = "";
     let pendingCarriageReturn = false;
@@ -92,11 +109,22 @@ export function runYtDlp(args, timeoutMs = 45_000, onStderrLine) {
                 settled = true;
                 proc.kill("SIGKILL");
                 flushStderrLineBuffer();
+                const stdout = Buffer.concat(stdoutChunks).toString("utf8");
+                const stderr = `yt-dlp timed out after ${timeoutMs}ms`;
                 resolve({
                     exitCode: -1,
-                    stdout: Buffer.concat(stdoutChunks).toString("utf8"),
-                    stderr: `yt-dlp timed out after ${timeoutMs}ms`,
+                    stdout,
+                    stderr,
                     durationMs: Date.now() - start,
+                    failureLogPath: writeYtDlpFailureLog({
+                        args: finalArgs,
+                        exitCode: -1,
+                        stdout,
+                        stderr,
+                        durationMs: Date.now() - start,
+                        timeoutMs,
+                        trigger: "timeout",
+                    }),
                 });
             }
         }, timeoutMs);
@@ -105,11 +133,25 @@ export function runYtDlp(args, timeoutMs = 45_000, onStderrLine) {
             if (!settled) {
                 settled = true;
                 flushStderrLineBuffer();
+                const stdout = Buffer.concat(stdoutChunks).toString("utf8");
+                const stderr = Buffer.concat(stderrChunks).toString("utf8");
+                const exitCode = code ?? 1;
                 resolve({
-                    exitCode: code ?? 1,
-                    stdout: Buffer.concat(stdoutChunks).toString("utf8"),
-                    stderr: Buffer.concat(stderrChunks).toString("utf8"),
+                    exitCode,
+                    stdout,
+                    stderr,
                     durationMs: Date.now() - start,
+                    failureLogPath: exitCode === 0
+                        ? undefined
+                        : writeYtDlpFailureLog({
+                            args: finalArgs,
+                            exitCode,
+                            stdout,
+                            stderr,
+                            durationMs: Date.now() - start,
+                            timeoutMs,
+                            trigger: "exit",
+                        }),
                 });
             }
         });
@@ -117,7 +159,20 @@ export function runYtDlp(args, timeoutMs = 45_000, onStderrLine) {
             clearTimeout(timer);
             if (!settled) {
                 settled = true;
-                reject(err);
+                const stdout = Buffer.concat(stdoutChunks).toString("utf8");
+                const stderr = Buffer.concat(stderrChunks).toString("utf8");
+                reject(Object.assign(err, {
+                    failureLogPath: writeYtDlpFailureLog({
+                        args: finalArgs,
+                        exitCode: 1,
+                        stdout,
+                        stderr,
+                        durationMs: Date.now() - start,
+                        timeoutMs,
+                        trigger: "spawn_error",
+                        spawnError: err instanceof Error ? err.message : String(err),
+                    }),
+                }));
             }
         });
     });

package/dist/utils/ytdlpFailures.d.ts

@@ -0,0 +1,3 @@
+export type YtDlpFailureKind = "COOKIES_EXPIRED" | "COOKIES_INVALID" | "SIGN_IN_REQUIRED" | "RATE_LIMITED";
+export declare function classifyYtDlpFailure(stderr: string): YtDlpFailureKind | null;
+export declare function appendDiagnosticLog(message: string, logPath?: string): string;

package/dist/utils/ytdlpFailures.js

@@ -0,0 +1,27 @@
+export function classifyYtDlpFailure(stderr) {
+    const normalized = stderr.toLowerCase();
+    if (normalized.includes("cookies are no longer valid") ||
+        normalized.includes("cookie has expired") ||
+        normalized.includes("cookies have expired") ||
+        normalized.includes("session expired")) {
+        return "COOKIES_EXPIRED";
+    }
+    if (normalized.includes("rate-limited by youtube") ||
+        normalized.includes("current session has been rate-limited")) {
+        return "RATE_LIMITED";
+    }
+    if (normalized.includes("sign in to confirm you're not a bot") ||
+        normalized.includes("sign in to confirm you’re not a bot")) {
+        return "SIGN_IN_REQUIRED";
+    }
+    if (normalized.includes("sign in") ||
+        normalized.includes("login") ||
+        normalized.includes("cookies") ||
+        normalized.includes("not a bot")) {
+        return "COOKIES_INVALID";
+    }
+    return null;
+}
+export function appendDiagnosticLog(message, logPath) {
+    return logPath ? `${message}\nDiagnostic log: ${logPath}` : message;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mkterswingman/5mghost-yonder",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "description": "Internal MCP client with local data tools and remote API proxy",
   "type": "module",
   "bin": {