@mkterswingman/5mghost-yonder 0.0.6 → 0.0.7

package/README.md

@@ -56,3 +56,8 @@ Media download runtime expectations:
 - `uninstall` — remove MCP registrations and local `~/.yt-mcp` config
 - `update` — update the main package and required runtimes
 - `version` — print the installed version
+
+Runtime notes:
+
+- Playwright browser installs are managed through `yt-mcp runtime install`, not a raw `npx playwright install ...` call
+- `yt-dlp` is invoked with `--js-runtimes node`, so no extra Deno install is required

package/dist/cli/setupCookies.d.ts

@@ -52,6 +52,24 @@ export interface SetupCookiesDeps {
     log: (message: string) => void;
 }
 type SetupCookiesChromium = Awaited<ReturnType<SetupCookiesDeps["loadChromium"]>>;
+interface CdpCookie {
+    name: string;
+    value: string;
+    domain: string;
+    path: string;
+    secure?: boolean;
+    httpOnly?: boolean;
+    expires?: number;
+}
+interface CdpCookieClient {
+    send(method: "Network.getAllCookies"): Promise<{
+        cookies?: CdpCookie[];
+    }>;
+}
+export declare function readCdpCookiesUntilSession(client: CdpCookieClient, deps: Pick<SetupCookiesDeps, "hasYouTubeSession">, options?: {
+    attempts?: number;
+    delayMs?: number;
+}): Promise<PlaywrightCookie[] | null>;
 export declare function tryImportBrowserCookies(chromium: SetupCookiesChromium, deps: SetupCookiesDeps): Promise<boolean>;
 export declare function readImportedBrowserCookies(candidate: BrowserProfileCandidate, chromium: SetupCookiesChromium, deps: SetupCookiesDeps): Promise<PlaywrightCookie[] | null>;
 export declare function runManualCookieSetup(chromium: SetupCookiesChromium, deps: SetupCookiesDeps): Promise<void>;

package/dist/cli/setupCookies.js

@@ -28,8 +28,17 @@ export const CHANNEL_LABELS = {
 };
 /** Check if YouTube SID cookies are present — the real signal of a logged-in session. */
 export function hasYouTubeSession(cookies) {
-    return cookies.some((c) => (c.name === "SID" || c.name === "HSID" || c.name === "SSID") &&
-        c.domain.includes("youtube.com"));
+    const hasCookieTriplet = (domainFragment) => {
+        const names = new Set(cookies
+            .filter((cookie) => cookie.domain.includes(domainFragment))
+            .map((cookie) => cookie.name));
+        return names.has("SID") && names.has("HSID") && names.has("SSID");
+    };
+    if (hasCookieTriplet("youtube.com")) {
+        return true;
+    }
+    const hasYouTubeLoginInfo = cookies.some((cookie) => cookie.name === "LOGIN_INFO" && cookie.domain.includes("youtube.com"));
+    return hasYouTubeLoginInfo && hasCookieTriplet("google.");
 }
 /**
  * Save cookies to Netscape format file and close the browser context.
@@ -146,6 +155,29 @@ async function waitForCdpVersion(port, timeoutMs = 15_000) {
     }
     return null;
 }
+export async function readCdpCookiesUntilSession(client, deps, options = {}) {
+    const attempts = options.attempts ?? 5;
+    const delayMs = options.delayMs ?? 1_000;
+    for (let attempt = 0; attempt < attempts; attempt += 1) {
+        const result = await client.send("Network.getAllCookies");
+        const cookies = (result.cookies ?? []).map((cookie) => ({
+            name: cookie.name,
+            value: cookie.value,
+            domain: cookie.domain,
+            path: cookie.path,
+            secure: cookie.secure ?? false,
+            httpOnly: cookie.httpOnly ?? false,
+            expires: cookie.expires ?? -1,
+        }));
+        if (deps.hasYouTubeSession(cookies)) {
+            return cookies;
+        }
+        if (attempt < attempts - 1) {
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+        }
+    }
+    return null;
+}
 async function terminateImportedBrowser(processHandle) {
     if (processHandle.exitCode !== null || processHandle.signalCode !== null) {
         return;
@@ -213,17 +245,11 @@ export async function readImportedBrowserCookies(candidate, chromium, deps) {
         }
         const page = context.pages()[0] ?? await context.newPage();
         const client = await context.newCDPSession(page);
-        const result = await client.send("Network.getAllCookies");
-        const cookies = (result.cookies ?? []).map((cookie) => ({
-            name: cookie.name,
-            value: cookie.value,
-            domain: cookie.domain,
-            path: cookie.path,
-            secure: cookie.secure ?? false,
-            httpOnly: cookie.httpOnly ?? false,
-            expires: cookie.expires ?? -1,
-        }));
-        if (!deps.hasYouTubeSession(cookies)) {
+        const cookies = await readCdpCookiesUntilSession(client, deps, {
+            attempts: 6,
+            delayMs: 1_000,
+        });
+        if (!cookies) {
             return null;
         }
         return cookies;
@@ -248,7 +274,7 @@ export async function runManualCookieSetup(chromium, deps) {
     deps.log(`Using browser: ${CHANNEL_LABELS[channel] ?? channel}`);
     if (channel === "chromium") {
         deps.log("⚠️  No system Chrome or Edge found. Using bundled Chromium.\n" +
-            "   If it fails, run: npx playwright install chromium\n");
+            "   If it fails, run: yt-mcp runtime install\n");
     }
     let context;
     try {

package/dist/runtime/playwrightRuntime.d.ts

@@ -1,4 +1,8 @@
 import type { RuntimeComponentState } from "./manifest.js";
+export declare function getPlaywrightInstallInvocation(): {
+    command: string;
+    args: string[];
+};
 export declare function checkPlaywrightRuntime(): Promise<RuntimeComponentState & {
     name: "playwright";
     message?: string;

package/dist/runtime/playwrightRuntime.js

@@ -1,5 +1,16 @@
-import { execSync } from "node:child_process";
+import { execFileSync } from "node:child_process";
 import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+export function getPlaywrightInstallInvocation() {
+    const packageJsonPath = require.resolve("playwright/package.json");
+    const cliPath = join(dirname(packageJsonPath), "cli.js");
+    return {
+        command: process.execPath,
+        args: [cliPath, "install", "chromium"],
+    };
+}
 export async function checkPlaywrightRuntime() {
     try {
         const { chromium } = await import("playwright");
@@ -25,11 +36,12 @@ export async function checkPlaywrightRuntime() {
         source: "runtime",
         installed_at: null,
         binary_path: null,
-        message: "npx playwright install chromium",
+        message: "yt-mcp runtime install",
     };
 }
 export async function installPlaywrightRuntime() {
-    execSync("npx playwright install chromium", { stdio: "inherit" });
+    const invocation = getPlaywrightInstallInvocation();
+    execFileSync(invocation.command, invocation.args, { stdio: "inherit" });
     return checkPlaywrightRuntime();
 }
 export async function updatePlaywrightRuntime() {

package/dist/utils/ytdlp.d.ts

@@ -12,6 +12,10 @@ export interface YtDlpStderrLineSplitter {
 type SpawnSyncFn = typeof spawnSync;
 export declare function createYtDlpStderrLineSplitter(onLine: (line: string) => void): YtDlpStderrLineSplitter;
 export declare function hasYtDlp(runSpawnSync?: SpawnSyncFn): boolean;
+export declare function buildYtDlpArgs(args: string[], options?: {
+    cookiesPath?: string;
+    cookiesExist?: boolean;
+}): string[];
 export declare function runYtDlp(args: string[], timeoutMs?: number, onStderrLine?: (line: string) => void): Promise<YtDlpResult>;
 export declare function runYtDlpJson<T>(args: string[], timeoutMs?: number): Promise<{
     ok: true;

package/dist/utils/ytdlp.js

@@ -57,13 +57,19 @@ export function hasYtDlp(runSpawnSync = spawnSync) {
     });
     return result.status === 0 && result.error == null;
 }
+export function buildYtDlpArgs(args, options = {}) {
+    const cookiesPath = options.cookiesPath ?? PATHS.cookiesTxt;
+    const cookiesExist = options.cookiesExist ?? existsSync(cookiesPath);
+    const finalArgs = ["--force-ipv4", "--no-warnings", "--js-runtimes", "node", ...args];
+    if (cookiesExist) {
+        finalArgs.push("--cookies", cookiesPath);
+    }
+    return finalArgs;
+}
 export function runYtDlp(args, timeoutMs = 45_000, onStderrLine) {
     return new Promise((resolve, reject) => {
         const start = Date.now();
-        const finalArgs = ["--force-ipv4", "--no-warnings", ...args];
-        if (existsSync(PATHS.cookiesTxt)) {
-            finalArgs.push("--cookies", PATHS.cookiesTxt);
-        }
+        const finalArgs = buildYtDlpArgs(args);
         const proc = spawn(getYtDlpPath(), finalArgs, {
             stdio: ["ignore", "pipe", "pipe"],
         });

package/package.json

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