@mkterswingman/5mghost-yonder 0.0.11 → 0.0.12

package/dist/tools/subtitles.js

@@ -10,7 +10,8 @@ const AUTH_REQUIRED_MSG = "❌ 未认证。请先登录：\n• OAuth: npx @mkte
 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 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 +56,39 @@ function isCookieFailureText(error) {
         normalized.includes("login") ||
         normalized.includes("not a bot"));
 }
+function appendDiagnosticLog(message, logPath) {
+    return logPath ? `${message}\nDiagnostic log: ${logPath}` : message;
+}
+function classifyYtDlpCookieFailure(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 {
+            code: "COOKIES_EXPIRED",
+            message: COOKIE_EXPIRED_MESSAGE,
+        };
+    }
+    if (normalized.includes("sign in") ||
+        normalized.includes("login") ||
+        normalized.includes("cookies") ||
+        normalized.includes("not a bot")) {
+        return {
+            code: "COOKIES_INVALID",
+            message: COOKIE_INVALID_MESSAGE,
+        };
+    }
+    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 +97,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 +272,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 +367,7 @@ export async function downloadSubtitlesForLanguages(input) {
                 outputStem: `${lang}`,
                 targetFile,
             });
-            if (result.cookiesExpired) {
+            if (result.cookieFailureCode) {
                 const refreshed = await tryRefreshSubtitleCookies();
                 if (refreshed) {
                     result = await downloadSubtitle(input.videoId, lang, format, {
@@ -419,7 +451,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 +467,7 @@ 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 : 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,7 @@ export function registerSubtitleTools(server, config, tokenManager) {
                     lastError = dl.error;
                 }
             }
-            if (cookiesExpired) {
+            if (cookieFailureCode) {
                 const refreshed = await tryRefreshSubtitleCookies();
                 if (refreshed) {
                     // Retry this video's subtitles
@@ -535,11 +567,11 @@ 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 : 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/package.json

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