@mkterswingman/yt-mcp 0.3.0 → 0.3.1

package/dist/cli/setupCookies.d.ts

@@ -1 +1,34 @@
+export type PlaywrightCookie = {
+    name: string;
+    value: string;
+    domain: string;
+    path: string;
+    secure: boolean;
+    httpOnly: boolean;
+    expires: number;
+};
+/**
+ * Detect which browser channel is available on the system.
+ * Prefers Chrome → Edge → falls back to bundled Chromium.
+ */
+export declare function detectBrowserChannel(chromium: typeof import("playwright").chromium): Promise<string>;
+export declare const CHANNEL_LABELS: Record<string, string>;
+/** Check if YouTube SID cookies are present — the real signal of a logged-in session. */
+export declare function hasYouTubeSession(cookies: Array<{
+    name: string;
+    domain: string;
+}>): boolean;
+/**
+ * Save cookies to Netscape format file and close the browser context.
+ */
+export declare function saveCookiesAndClose(context: {
+    close(): Promise<void>;
+}, rawCookies: PlaywrightCookie[], silent?: boolean): Promise<void>;
+/**
+ * Save cookies to disk WITHOUT closing the context (caller manages lifecycle).
+ */
+export declare function saveCookiesToDisk(rawCookies: PlaywrightCookie[]): void;
+/**
+ * Interactive cookie setup — opens a visible browser for user to log in.
+ */
 export declare function runSetupCookies(): Promise<void>;

package/dist/cli/setupCookies.js

@@ -5,7 +5,7 @@ import { cookiesToNetscape } from "../utils/cookies.js";
  * Detect which browser channel is available on the system.
  * Prefers Chrome → Edge → falls back to bundled Chromium.
  */
-async function detectBrowserChannel(chromium) {
+export async function detectBrowserChannel(chromium) {
     for (const channel of ["chrome", "msedge"]) {
         try {
             const browser = await chromium.launch({ channel, headless: true });
@@ -18,16 +18,57 @@ async function detectBrowserChannel(chromium) {
     }
     return "chromium";
 }
-const CHANNEL_LABELS = {
+export const CHANNEL_LABELS = {
     chrome: "Google Chrome",
     msedge: "Microsoft Edge",
     chromium: "Playwright Chromium",
 };
 /** Check if YouTube SID cookies are present — the real signal of a logged-in session. */
-function hasYouTubeSession(cookies) {
+export function hasYouTubeSession(cookies) {
     return cookies.some((c) => (c.name === "SID" || c.name === "HSID" || c.name === "SSID") &&
         c.domain.includes("youtube.com"));
 }
+/**
+ * Save cookies to Netscape format file and close the browser context.
+ */
+export async function saveCookiesAndClose(context, rawCookies, silent = false) {
+    try {
+        await context.close();
+    }
+    catch { /* already closed */ }
+    const entries = rawCookies.map((c) => ({
+        name: c.name,
+        value: c.value,
+        domain: c.domain,
+        path: c.path,
+        secure: c.secure,
+        httpOnly: c.httpOnly,
+        expires: c.expires,
+    }));
+    const netscape = cookiesToNetscape(entries);
+    writeFileSync(PATHS.cookiesTxt, netscape, { mode: 0o600 });
+    if (!silent) {
+        const httpOnlyCount = entries.filter((c) => c.httpOnly).length;
+        console.log(`✅ Cookies saved to ${PATHS.cookiesTxt}`);
+        console.log(`   ${entries.length} cookies extracted (${httpOnlyCount} httpOnly)\n`);
+    }
+}
+/**
+ * Save cookies to disk WITHOUT closing the context (caller manages lifecycle).
+ */
+export function saveCookiesToDisk(rawCookies) {
+    const entries = rawCookies.map((c) => ({
+        name: c.name,
+        value: c.value,
+        domain: c.domain,
+        path: c.path,
+        secure: c.secure,
+        httpOnly: c.httpOnly,
+        expires: c.expires,
+    }));
+    const netscape = cookiesToNetscape(entries);
+    writeFileSync(PATHS.cookiesTxt, netscape, { mode: 0o600 });
+}
 /**
  * Poll cookies at intervals until YouTube session cookies appear or timeout.
  * Returns the full cookie list on success, or null on timeout / browser closed.
@@ -35,30 +76,28 @@ function hasYouTubeSession(cookies) {
 async function waitForLogin(context, isClosed, timeoutMs, pollIntervalMs = 2000) {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
-        // Detect if user closed the browser / all pages
-        if (isClosed()) {
+        if (isClosed())
             return null;
-        }
         try {
             const cookies = await context.cookies("https://www.youtube.com");
             if (hasYouTubeSession(cookies)) {
-                // Give a moment for all cookies to settle after login redirect
                 await new Promise((r) => setTimeout(r, 2000));
                 return await context.cookies("https://www.youtube.com");
             }
         }
         catch {
-            // Browser was closed by user — bail out
             return null;
         }
         await new Promise((r) => setTimeout(r, pollIntervalMs));
     }
-    return null; // timeout
+    return null;
 }
+/**
+ * Interactive cookie setup — opens a visible browser for user to log in.
+ */
 export async function runSetupCookies() {
     console.log("\n🍪 YouTube Cookie Setup\n");
     ensureConfigDir();
-    // Dynamic import of playwright to avoid pulling it in at serve time
     let chromium;
     try {
         const pw = await import("playwright");
@@ -88,20 +127,14 @@ export async function runSetupCookies() {
         }
         throw err;
     }
-    // Graceful handling when user closes browser manually
     let browserClosed = false;
-    context.on("close", () => {
-        browserClosed = true;
-    });
+    context.on("close", () => { browserClosed = true; });
     const page = context.pages()[0] ?? (await context.newPage());
-    // Also detect when user closes the page/window (not just the whole context)
     page.on("close", () => {
-        // If no more pages remain, treat as browser closed
         if (context.pages().length === 0) {
             browserClosed = true;
         }
     });
-    // Navigate to YouTube first — familiar page for the user
     try {
         await page.goto("https://www.youtube.com");
         await page.waitForLoadState("domcontentloaded");
@@ -113,14 +146,12 @@ export async function runSetupCookies() {
         }
         throw new Error("Failed to navigate to YouTube");
     }
-    // Check if already logged in (e.g., from a previous session in this profile)
     const existingCookies = await context.cookies("https://www.youtube.com");
     if (hasYouTubeSession(existingCookies)) {
         console.log("✅ Already logged in to YouTube!\n");
         await saveCookiesAndClose(context, existingCookies);
         return;
     }
-    // Try to click the "Sign in" button on YouTube homepage
     try {
         const signInBtn = page.locator('a[href*="accounts.google.com/ServiceLogin"], ' +
             'tp-yt-paper-button#button:has-text("Sign in"), ' +
@@ -131,7 +162,6 @@ export async function runSetupCookies() {
         console.log("🔑 Opened sign-in page. Please log in to your Google account.\n");
     }
     catch {
-        // Couldn't find sign-in button — navigate directly
         try {
             await page.goto("https://accounts.google.com/ServiceLogin?continue=https://www.youtube.com");
             console.log("🔑 Please log in to your Google account in the browser window.\n");
@@ -144,7 +174,7 @@ export async function runSetupCookies() {
             throw new Error("Failed to navigate to Google login");
         }
     }
-    const LOGIN_TIMEOUT_MS = 2 * 60 * 1000; // 2 minutes
+    const LOGIN_TIMEOUT_MS = 2 * 60 * 1000;
     console.log("⏳ Waiting for login (up to 2 minutes)...");
     console.log("   Login will be detected automatically once you sign in.\n");
     const finalCookies = await waitForLogin(context, () => browserClosed, LOGIN_TIMEOUT_MS);
@@ -154,7 +184,6 @@ export async function runSetupCookies() {
         return;
     }
     if (!finalCookies) {
-        // Timeout — clean up
         try {
             await context.close();
         }
@@ -165,23 +194,3 @@ export async function runSetupCookies() {
     }
     await saveCookiesAndClose(context, finalCookies);
 }
-async function saveCookiesAndClose(context, rawCookies) {
-    try {
-        await context.close();
-    }
-    catch { /* already closed */ }
-    const entries = rawCookies.map((c) => ({
-        name: c.name,
-        value: c.value,
-        domain: c.domain,
-        path: c.path,
-        secure: c.secure,
-        httpOnly: c.httpOnly,
-        expires: c.expires,
-    }));
-    const netscape = cookiesToNetscape(entries);
-    writeFileSync(PATHS.cookiesTxt, netscape, { mode: 0o600 });
-    const httpOnlyCount = entries.filter((c) => c.httpOnly).length;
-    console.log(`✅ Cookies saved to ${PATHS.cookiesTxt}`);
-    console.log(`   ${entries.length} cookies extracted (${httpOnlyCount} httpOnly)\n`);
-}

package/dist/tools/subtitles.js

@@ -3,7 +3,8 @@ import { join } from "node:path";
 import { z } from "zod";
 import { PATHS } from "../utils/config.js";
 import { runYtDlp } from "../utils/ytdlp.js";
-import { hasSIDCookies } from "../utils/cookies.js";
+import { hasSIDCookies, areCookiesExpired } from "../utils/cookies.js";
+import { tryHeadlessRefresh } from "../utils/cookieRefresh.js";
 import { resolveVideoInput, normalizeVideoInputs } from "../utils/videoInput.js";
 const AUTH_REQUIRED_MSG = "❌ 未认证。请先登录：\n• OAuth: npx @mkterswingman/yt-mcp setup\n• PAT: 设置环境变量 YT_MCP_TOKEN 或在 https://mkterswingman.com/pat/login 生成 token";
 function toolOk(payload) {
@@ -284,6 +285,17 @@ export function registerSubtitleTools(server, config, tokenManager) {
         const videoId = resolveVideoInput(video);
         if (!videoId)
             return toolErr("INVALID_INPUT", `无法解析视频 ID: ${video}`);
+        // Cookie pre-check: missing or expired → try headless refresh
+        if (!hasSIDCookies(PATHS.cookiesTxt) || areCookiesExpired(PATHS.cookiesTxt)) {
+            let refreshed = false;
+            try {
+                refreshed = await tryHeadlessRefresh();
+            }
+            catch { /* */ }
+            if (!refreshed || !hasSIDCookies(PATHS.cookiesTxt)) {
+                return toolErr("COOKIES_MISSING", "No valid YouTube cookies found.\nPlease run in your terminal: yt-mcp setup-cookies");
+            }
+        }
         const usingDefaults = !languages;
         const langs = languages ?? config.default_languages;
         const fmt = format ?? "vtt";
@@ -295,7 +307,30 @@ export function registerSubtitleTools(server, config, tokenManager) {
             const lang = langs[i];
             const dl = await downloadSubtitle(videoId, lang, fmt);
             if (dl.cookiesExpired) {
-                return toolErr("COOKIES_EXPIRED", "YouTube cookies have expired. Run: npx @mkterswingman/yt-mcp setup-cookies");
+                // Try headless auto-refresh
+                let refreshed = false;
+                try {
+                    refreshed = await tryHeadlessRefresh();
+                }
+                catch {
+                    // Playwright not available or browser failed — fall through
+                }
+                if (refreshed) {
+                    // Retry the download with fresh cookies
+                    const retry = await downloadSubtitle(videoId, lang, fmt);
+                    if (retry.ok) {
+                        if (retry.text) {
+                            results.push({ language: lang, status: "ok", text: retry.text, file_path: retry.filePath });
+                        }
+                        else {
+                            results.push({ language: lang, status: "ok", file_path: retry.filePath });
+                        }
+                        continue;
+                    }
+                    // Retry also failed with expired cookies — give up
+                }
+                return toolErr("COOKIES_EXPIRED", "YouTube cookies have expired and auto-refresh failed.\n" +
+                    "Please run in your terminal: yt-mcp setup-cookies");
             }
             if (!dl.ok) {
                 // When using default languages, silently skip unavailable ones
@@ -348,9 +383,16 @@ export function registerSubtitleTools(server, config, tokenManager) {
         }
         const langs = languages ?? config.default_languages;
         const fmt = format ?? "vtt";
-        // Cookie pre-check
-        if (!hasSIDCookies(PATHS.cookiesTxt)) {
-            return toolErr("COOKIES_MISSING", "No valid YouTube cookies found. Run: npx @mkterswingman/yt-mcp setup-cookies");
+        // Cookie pre-check: missing or expired → try headless refresh
+        if (!hasSIDCookies(PATHS.cookiesTxt) || areCookiesExpired(PATHS.cookiesTxt)) {
+            let refreshed = false;
+            try {
+                refreshed = await tryHeadlessRefresh();
+            }
+            catch { /* */ }
+            if (!refreshed || !hasSIDCookies(PATHS.cookiesTxt)) {
+                return toolErr("COOKIES_MISSING", "No valid YouTube cookies found.\nPlease run in your terminal: yt-mcp setup-cookies");
+            }
         }
         const results = [];
         let succeeded = 0;
@@ -380,7 +422,30 @@ export function registerSubtitleTools(server, config, tokenManager) {
                 }
             }
             if (cookiesExpired) {
-                return toolErr("COOKIES_EXPIRED", "YouTube cookies have expired. Run: npx @mkterswingman/yt-mcp setup-cookies");
+                // Try headless auto-refresh
+                let refreshed = false;
+                try {
+                    refreshed = await tryHeadlessRefresh();
+                }
+                catch { /* fall through */ }
+                if (refreshed) {
+                    // Retry this video's subtitles
+                    let retrySuccess = false;
+                    for (const lang of langs) {
+                        const retry = await downloadSubtitle(videoId, lang, fmt);
+                        if (retry.ok) {
+                            langFound.push(lang);
+                            retrySuccess = true;
+                        }
+                    }
+                    if (retrySuccess) {
+                        cookiesExpired = false;
+                    }
+                }
+                if (cookiesExpired) {
+                    return toolErr("COOKIES_EXPIRED", "YouTube cookies have expired and auto-refresh failed.\n" +
+                        "Please run in your terminal: yt-mcp setup-cookies");
+                }
             }
             if (langFound.length > 0) {
                 succeeded++;

package/dist/utils/cookieRefresh.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Headless cookie auto-refresh.
+ *
+ * Uses Playwright to open YouTube in a headless browser with the existing
+ * browser-profile. If Google session is still valid, YouTube cookies are
+ * extracted and saved automatically — no user interaction needed.
+ *
+ * If Google session has expired too, returns false so the caller can
+ * prompt the user for interactive login.
+ */
+/**
+ * Attempt to refresh YouTube cookies headlessly using existing browser profile.
+ *
+ * @returns true if cookies were refreshed, false if Google session expired
+ *          (needs interactive login).
+ * @throws if Playwright is not installed or browser can't launch.
+ */
+export declare function tryHeadlessRefresh(): Promise<boolean>;

package/dist/utils/cookieRefresh.js

@@ -0,0 +1,70 @@
+/**
+ * Headless cookie auto-refresh.
+ *
+ * Uses Playwright to open YouTube in a headless browser with the existing
+ * browser-profile. If Google session is still valid, YouTube cookies are
+ * extracted and saved automatically — no user interaction needed.
+ *
+ * If Google session has expired too, returns false so the caller can
+ * prompt the user for interactive login.
+ */
+import { existsSync } from "node:fs";
+import { PATHS, ensureConfigDir } from "./config.js";
+import { detectBrowserChannel, hasYouTubeSession, saveCookiesToDisk, } from "../cli/setupCookies.js";
+const HEADLESS_TIMEOUT_MS = 30_000;
+/**
+ * Attempt to refresh YouTube cookies headlessly using existing browser profile.
+ *
+ * @returns true if cookies were refreshed, false if Google session expired
+ *          (needs interactive login).
+ * @throws if Playwright is not installed or browser can't launch.
+ */
+export async function tryHeadlessRefresh() {
+    // No browser profile = never logged in = can't refresh
+    if (!existsSync(PATHS.browserProfile)) {
+        return false;
+    }
+    ensureConfigDir();
+    // Dynamic import to keep serve startup fast
+    let chromium;
+    try {
+        const pw = await import("playwright");
+        chromium = pw.chromium;
+    }
+    catch {
+        return false; // Playwright not installed — can't refresh
+    }
+    const channel = await detectBrowserChannel(chromium);
+    let context;
+    try {
+        context = await chromium.launchPersistentContext(PATHS.browserProfile, {
+            headless: true,
+            channel,
+            args: ["--disable-blink-features=AutomationControlled"],
+        });
+    }
+    catch {
+        return false; // Browser launch failed
+    }
+    try {
+        const page = context.pages()[0] ?? (await context.newPage());
+        await page.goto("https://www.youtube.com", { timeout: HEADLESS_TIMEOUT_MS });
+        await page.waitForLoadState("domcontentloaded");
+        const cookies = await context.cookies("https://www.youtube.com");
+        if (!hasYouTubeSession(cookies)) {
+            // Google session expired — can't auto-refresh
+            await context.close().catch(() => { });
+            return false;
+        }
+        // Wait a moment for all cookies to settle
+        await new Promise((r) => setTimeout(r, 1500));
+        const finalCookies = await context.cookies("https://www.youtube.com");
+        saveCookiesToDisk(finalCookies);
+        await context.close().catch(() => { });
+        return true;
+    }
+    catch {
+        await context.close().catch(() => { });
+        return false;
+    }
+}

package/dist/utils/cookies.d.ts

@@ -9,3 +9,10 @@ export interface CookieEntry {
 }
 export declare function cookiesToNetscape(cookies: CookieEntry[]): string;
 export declare function hasSIDCookies(cookiesPath: string): boolean;
+/**
+ * Check if YouTube session cookies have expired by parsing Netscape cookie
+ * file timestamps (field 5, Unix epoch seconds).
+ *
+ * Returns true if: file missing, no session cookies, or ALL session cookies expired.
+ */
+export declare function areCookiesExpired(cookiesPath: string): boolean;

package/dist/utils/cookies.js

@@ -26,3 +26,53 @@ export function hasSIDCookies(cookiesPath) {
         return false;
     }
 }
+/**
+ * Cookie names that indicate a valid YouTube session.
+ * If at least one of these is present and not expired, cookies are valid.
+ */
+const SESSION_COOKIE_PATTERNS = [
+    "SID", "HSID", "SSID", "APISID", "SAPISID",
+    "__Secure-1PSID", "__Secure-3PSID",
+    "__Secure-1PSIDTS", "__Secure-3PSIDTS",
+    "LOGIN_INFO",
+];
+/**
+ * Check if YouTube session cookies have expired by parsing Netscape cookie
+ * file timestamps (field 5, Unix epoch seconds).
+ *
+ * Returns true if: file missing, no session cookies, or ALL session cookies expired.
+ */
+export function areCookiesExpired(cookiesPath) {
+    if (!existsSync(cookiesPath))
+        return true;
+    try {
+        const content = readFileSync(cookiesPath, "utf8");
+        const nowSec = Date.now() / 1000;
+        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))
+                continue;
+            foundAnySession = true;
+            const expiry = Number(fields[4]);
+            // expiry 0 = session cookie (no expiration) — treat as valid
+            if (expiry === 0 || expiry >= nowSec) {
+                foundAnyValid = true;
+                break; // At least one valid session cookie — not expired
+            }
+        }
+        // No session cookies at all = need login; all expired = need refresh
+        if (!foundAnySession)
+            return true;
+        return !foundAnyValid;
+    }
+    catch {
+        return true;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mkterswingman/yt-mcp",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "YouTube MCP client — local subtitles + remote API proxy",
   "type": "module",
   "bin": {
@@ -17,10 +17,10 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.27.1",
+    "playwright": "^1.58.0",
     "zod": "^4.3.6"
   },
   "optionalDependencies": {
-    "playwright": "^1.58.0",
     "puppeteer-core": "^24.0.0"
   },
   "keywords": [