@mkterswingman/5mghost-yonder 0.0.5 → 0.0.7

package/README.md

@@ -12,8 +12,6 @@ curl -fsSL https://mkterswingman.com/install/yt-mcp.sh | bash
 powershell -ExecutionPolicy Bypass -Command "irm https://mkterswingman.com/install/yt-mcp.ps1 | iex"
 ```
 
-```
-
 The bootstrap installer:
 
 - installs the npm package
@@ -54,7 +52,12 @@ Media download runtime expectations:
 - `smoke` — run the installer smoke checks (`search_videos`, plus `validate_cookies` with `--subtitles`)
 - `runtime` — install, update, or check required runtimes
 - `check` — inspect shared auth, runtime status, and YouTube cookies
-- `setup-cookies` — refresh YouTube cookies
+- `setup-cookies` — first try importing an existing YouTube login from the most recently active local Chrome/Edge profile on macOS or Windows with a headless real-browser CDP probe, then fall back to manual browser login
 - `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

@@ -1,3 +1,5 @@
+import { ensureConfigDir } from "../utils/config.js";
+import { cleanupImportedBrowserWorkspace, findImportableBrowserProfileCandidates, prepareImportedBrowserWorkspace, type BrowserProfileCandidate } from "../utils/browserProfileImport.js";
 export type PlaywrightCookie = {
     name: string;
     value: string;
@@ -28,7 +30,51 @@ export declare function saveCookiesAndClose(context: {
  * Save cookies to disk WITHOUT closing the context (caller manages lifecycle).
  */
 export declare function saveCookiesToDisk(rawCookies: PlaywrightCookie[]): void;
+/**
+ * Poll cookies at intervals until YouTube session cookies appear or timeout.
+ * Returns the full cookie list on success, or null on timeout / browser closed.
+ */
+declare function waitForLogin(context: Awaited<ReturnType<typeof import("playwright").chromium.launchPersistentContext>>, isClosed: () => boolean, timeoutMs: number, pollIntervalMs?: number): Promise<PlaywrightCookie[] | null>;
+declare function loadPlaywrightChromium(): Promise<typeof import("playwright").chromium>;
+export interface SetupCookiesDeps {
+    ensureConfigDir: typeof ensureConfigDir;
+    loadChromium: typeof loadPlaywrightChromium;
+    detectBrowserChannel: typeof detectBrowserChannel;
+    hasYouTubeSession: typeof hasYouTubeSession;
+    saveCookiesAndClose: typeof saveCookiesAndClose;
+    waitForLogin: typeof waitForLogin;
+    findImportableBrowserProfileCandidates: typeof findImportableBrowserProfileCandidates;
+    prepareImportedBrowserWorkspace: typeof prepareImportedBrowserWorkspace;
+    cleanupImportedBrowserWorkspace: typeof cleanupImportedBrowserWorkspace;
+    readImportedBrowserCookies: typeof readImportedBrowserCookies;
+    tryImportBrowserCookies: typeof tryImportBrowserCookies;
+    runManualCookieSetup: typeof runManualCookieSetup;
+    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>;
 /**
  * Interactive cookie setup — opens a visible browser for user to log in.
  */
-export declare function runSetupCookies(): Promise<void>;
+export declare function runSetupCookies(overrides?: Partial<SetupCookiesDeps>): Promise<void>;
+export {};

package/dist/cli/setupCookies.js

@@ -1,6 +1,9 @@
+import { spawn } from "node:child_process";
 import { writeFileSync } from "node:fs";
+import { createServer } from "node:net";
 import { PATHS, ensureConfigDir } from "../utils/config.js";
 import { cookiesToNetscape } from "../utils/cookies.js";
+import { cleanupImportedBrowserWorkspace, findImportableBrowserProfileCandidates, prepareImportedBrowserWorkspace, } from "../utils/browserProfileImport.js";
 /**
  * Detect which browser channel is available on the system.
  * Prefers Chrome → Edge → falls back to bundled Chromium.
@@ -25,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.
@@ -92,25 +104,177 @@ async function waitForLogin(context, isClosed, timeoutMs, pollIntervalMs = 2000)
     }
     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();
-    let chromium;
+async function loadPlaywrightChromium() {
+    const pw = await import("playwright");
+    return pw.chromium;
+}
+function buildSetupCookiesDeps(overrides = {}) {
+    return {
+        ensureConfigDir,
+        loadChromium: loadPlaywrightChromium,
+        detectBrowserChannel,
+        hasYouTubeSession,
+        saveCookiesAndClose,
+        waitForLogin,
+        findImportableBrowserProfileCandidates,
+        prepareImportedBrowserWorkspace,
+        cleanupImportedBrowserWorkspace,
+        readImportedBrowserCookies,
+        tryImportBrowserCookies,
+        runManualCookieSetup,
+        log: console.log,
+        ...overrides,
+    };
+}
+async function allocateDebugPort() {
+    const server = createServer();
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(0, "127.0.0.1", () => resolve());
+    });
+    const address = server.address();
+    const port = typeof address === "object" && address ? address.port : 0;
+    await new Promise((resolve, reject) => {
+        server.close((err) => err ? reject(err) : resolve());
+    });
+    return port;
+}
+async function waitForCdpVersion(port, timeoutMs = 15_000) {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < timeoutMs) {
+        try {
+            const response = await fetch(`http://127.0.0.1:${port}/json/version`);
+            if (response.ok) {
+                return await response.json();
+            }
+        }
+        catch {
+            // Browser not ready yet.
+        }
+        await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+    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;
+    }
+    processHandle.kill("SIGTERM");
+    await Promise.race([
+        new Promise((resolve) => processHandle.once("exit", () => resolve())),
+        new Promise((resolve) => setTimeout(resolve, 2_000)),
+    ]);
+    if (processHandle.exitCode === null && processHandle.signalCode === null) {
+        processHandle.kill("SIGKILL");
+    }
+}
+export async function tryImportBrowserCookies(chromium, deps) {
+    const candidates = deps.findImportableBrowserProfileCandidates();
+    if (candidates.length === 0) {
+        return false;
+    }
+    for (let index = 0; index < candidates.length; index += 1) {
+        const candidate = candidates[index];
+        const isLastCandidate = index === candidates.length - 1;
+        deps.log(`Trying to import existing YouTube login from ${candidate.label} (${candidate.profileLabel})...`);
+        const importedCookies = await deps.readImportedBrowserCookies(candidate, chromium, deps);
+        if (importedCookies) {
+            await deps.saveCookiesAndClose({ close: async () => { } }, importedCookies, true);
+            deps.log(`✅ Imported YouTube session from ${candidate.label} (${candidate.profileLabel})\n`);
+            return true;
+        }
+        if (!isLastCandidate) {
+            const nextCandidate = candidates[index + 1];
+            deps.log(`${candidate.label} (${candidate.profileLabel}) import unavailable, trying ${nextCandidate.label} (${nextCandidate.profileLabel})...`);
+        }
+    }
+    deps.log("Browser profile import failed, falling back to manual login...\n");
+    return false;
+}
+export async function readImportedBrowserCookies(candidate, chromium, deps) {
+    let workspace = null;
+    let browser = null;
+    let browserProcess = null;
     try {
-        const pw = await import("playwright");
-        chromium = pw.chromium;
+        workspace = deps.prepareImportedBrowserWorkspace(candidate);
+        const port = await allocateDebugPort();
+        browserProcess = spawn(workspace.executablePath, [
+            `--user-data-dir=${workspace.workspaceDir}`,
+            `--profile-directory=${workspace.profileName}`,
+            `--remote-debugging-port=${port}`,
+            "--headless=new",
+            "--no-first-run",
+            "--no-default-browser-check",
+            "https://www.youtube.com",
+        ], {
+            detached: true,
+            stdio: "ignore",
+        });
+        browserProcess.unref();
+        const version = await waitForCdpVersion(port);
+        if (!version?.webSocketDebuggerUrl) {
+            return null;
+        }
+        browser = await chromium.connectOverCDP(`http://127.0.0.1:${port}`);
+        const context = browser.contexts()[0];
+        if (!context) {
+            return null;
+        }
+        const page = context.pages()[0] ?? await context.newPage();
+        const client = await context.newCDPSession(page);
+        const cookies = await readCdpCookiesUntilSession(client, deps, {
+            attempts: 6,
+            delayMs: 1_000,
+        });
+        if (!cookies) {
+            return null;
+        }
+        return cookies;
     }
     catch {
-        throw new Error("Playwright runtime is not installed.\nRun: yt-mcp runtime install");
+        return null;
     }
-    const channel = await detectBrowserChannel(chromium);
-    console.log(`Using browser: ${CHANNEL_LABELS[channel] ?? channel}`);
+    finally {
+        if (browser) {
+            await browser.close().catch(() => { });
+        }
+        if (browserProcess) {
+            await terminateImportedBrowser(browserProcess);
+        }
+        if (workspace) {
+            deps.cleanupImportedBrowserWorkspace(workspace);
+        }
+    }
+}
+export async function runManualCookieSetup(chromium, deps) {
+    const channel = await deps.detectBrowserChannel(chromium);
+    deps.log(`Using browser: ${CHANNEL_LABELS[channel] ?? channel}`);
     if (channel === "chromium") {
-        console.log("⚠️  No system Chrome or Edge found. Using bundled Chromium.\n" +
-            "   If it fails, run: npx playwright install chromium\n");
+        deps.log("⚠️  No system Chrome or Edge found. Using bundled Chromium.\n" +
+            "   If it fails, run: yt-mcp runtime install\n");
     }
     let context;
     try {
@@ -141,15 +305,15 @@ export async function runSetupCookies() {
     }
     catch {
         if (browserClosed) {
-            console.log("\n⚠️  Browser was closed. Setup cancelled.\n");
+            deps.log("\n⚠️  Browser was closed. Setup cancelled.\n");
             return;
         }
         throw new Error("Failed to navigate to YouTube");
     }
     const existingCookies = await context.cookies("https://www.youtube.com");
-    if (hasYouTubeSession(existingCookies)) {
-        console.log("✅ Already logged in to YouTube!\n");
-        await saveCookiesAndClose(context, existingCookies);
+    if (deps.hasYouTubeSession(existingCookies)) {
+        deps.log("✅ Already logged in to YouTube!\n");
+        await deps.saveCookiesAndClose(context, existingCookies);
         return;
     }
     try {
@@ -159,28 +323,28 @@ export async function runSetupCookies() {
             'ytd-button-renderer a:has-text("Sign in")').first();
         await signInBtn.waitFor({ state: "visible", timeout: 5000 });
         await signInBtn.click();
-        console.log("🔑 Opened sign-in page. Please log in to your Google account.\n");
+        deps.log("🔑 Opened sign-in page. Please log in to your Google account.\n");
     }
     catch {
         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");
+            deps.log("🔑 Please log in to your Google account in the browser window.\n");
         }
         catch {
             if (browserClosed) {
-                console.log("\n⚠️  Browser was closed. Setup cancelled.\n");
+                deps.log("\n⚠️  Browser was closed. Setup cancelled.\n");
                 return;
             }
             throw new Error("Failed to navigate to Google login");
         }
     }
     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);
+    deps.log("⏳ Waiting for login (up to 2 minutes)...");
+    deps.log("   Login will be detected automatically once you sign in.\n");
+    const finalCookies = await deps.waitForLogin(context, () => browserClosed, LOGIN_TIMEOUT_MS);
     if (browserClosed) {
-        console.log("\n⚠️  Browser was closed before login completed.");
-        console.log("   Run again: npx @mkterswingman/5mghost-yonder setup-cookies\n");
+        deps.log("\n⚠️  Browser was closed before login completed.");
+        deps.log("   Run again: npx @mkterswingman/5mghost-yonder setup-cookies\n");
         return;
     }
     if (!finalCookies) {
@@ -188,9 +352,29 @@ export async function runSetupCookies() {
             await context.close();
         }
         catch { /* already closed */ }
-        console.log("\n⏰ Login timed out (2 minutes).");
-        console.log("   Run again: npx @mkterswingman/5mghost-yonder setup-cookies\n");
+        deps.log("\n⏰ Login timed out (2 minutes).");
+        deps.log("   Run again: npx @mkterswingman/5mghost-yonder setup-cookies\n");
+        return;
+    }
+    await deps.saveCookiesAndClose(context, finalCookies);
+}
+/**
+ * Interactive cookie setup — opens a visible browser for user to log in.
+ */
+export async function runSetupCookies(overrides = {}) {
+    const deps = buildSetupCookiesDeps(overrides);
+    deps.log("\n🍪 YouTube Cookie Setup\n");
+    deps.ensureConfigDir();
+    let chromium;
+    try {
+        chromium = await deps.loadChromium();
+    }
+    catch {
+        throw new Error("Playwright runtime is not installed.\nRun: yt-mcp runtime install");
+    }
+    const imported = await deps.tryImportBrowserCookies(chromium, deps);
+    if (imported) {
         return;
     }
-    await saveCookiesAndClose(context, finalCookies);
+    await deps.runManualCookieSetup(chromium, deps);
 }

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/browserProfileImport.d.ts

@@ -0,0 +1,49 @@
+export type SupportedBrowser = "chrome" | "msedge";
+export interface BrowserInstallationCandidate {
+    browser: SupportedBrowser;
+    label: string;
+    rootDir: string;
+    localStatePath: string;
+    executablePathCandidates: string[];
+}
+export interface BrowserProfileCandidate extends BrowserInstallationCandidate {
+    profileName: string;
+    profileLabel: string;
+    profileDir: string;
+    executablePath: string;
+}
+export interface ImportedBrowserWorkspace {
+    browser: SupportedBrowser;
+    label: string;
+    profileName: string;
+    profileLabel: string;
+    workspaceDir: string;
+    localStatePath: string;
+    profileDir: string;
+    executablePath: string;
+}
+interface LocalStateProfileMeta {
+    name?: string;
+    user_name?: string;
+    gaia_name?: string;
+    active_time?: number;
+}
+export declare function listSupportedBrowserInstallations(input?: {
+    platform?: NodeJS.Platform;
+    env?: NodeJS.ProcessEnv;
+    homeDir?: string;
+}): BrowserInstallationCandidate[];
+export declare function parseBrowserProfilesFromLocalState(localStateText: string): {
+    orderedProfileNames: string[];
+    infoCache: Record<string, LocalStateProfileMeta>;
+};
+export declare function findImportableBrowserProfileCandidates(input?: {
+    platform?: NodeJS.Platform;
+    env?: NodeJS.ProcessEnv;
+    homeDir?: string;
+    exists?: (path: string) => boolean;
+    readFile?: (path: string) => string;
+}): BrowserProfileCandidate[];
+export declare function prepareImportedBrowserWorkspace(candidate: BrowserProfileCandidate, tempRootDir?: string): ImportedBrowserWorkspace;
+export declare function cleanupImportedBrowserWorkspace(workspace: ImportedBrowserWorkspace): void;
+export {};

package/dist/utils/browserProfileImport.js

@@ -0,0 +1,159 @@
+import { cpSync, existsSync, mkdtempSync, readFileSync, rmSync, } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { basename, join } from "node:path";
+const CACHE_DIR_NAMES = new Set([
+    "Cache",
+    "Code Cache",
+    "GPUCache",
+    "GrShaderCache",
+    "ShaderCache",
+    "IndexedDB",
+    "Storage",
+    "WebStorage",
+    "Service Worker",
+    "blob_storage",
+    "File System",
+    "SharedStorage",
+    "DawnGraphiteCache",
+    "GraphiteDawnCache",
+    "segmentation_platform",
+    "commerce_subscription_db",
+]);
+export function listSupportedBrowserInstallations(input) {
+    const platform = input?.platform ?? process.platform;
+    const env = input?.env ?? process.env;
+    const homeDir = input?.homeDir ?? homedir();
+    if (platform === "win32") {
+        const localAppData = env.LOCALAPPDATA?.trim();
+        const programFiles = env.ProgramFiles?.trim() ?? "C:/Program Files";
+        const programFilesX86 = env["ProgramFiles(x86)"]?.trim() ?? "C:/Program Files (x86)";
+        if (!localAppData) {
+            return [];
+        }
+        return [
+            buildInstallation("chrome", "Google Chrome", join(localAppData, "Google", "Chrome", "User Data"), [
+                join(programFiles, "Google", "Chrome", "Application", "chrome.exe"),
+                join(programFilesX86, "Google", "Chrome", "Application", "chrome.exe"),
+            ]),
+            buildInstallation("msedge", "Microsoft Edge", join(localAppData, "Microsoft", "Edge", "User Data"), [
+                join(programFiles, "Microsoft", "Edge", "Application", "msedge.exe"),
+                join(programFilesX86, "Microsoft", "Edge", "Application", "msedge.exe"),
+            ]),
+        ];
+    }
+    if (platform === "darwin") {
+        return [
+            buildInstallation("chrome", "Google Chrome", join(homeDir, "Library", "Application Support", "Google", "Chrome"), ["/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"]),
+            buildInstallation("msedge", "Microsoft Edge", join(homeDir, "Library", "Application Support", "Microsoft Edge"), ["/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge"]),
+        ];
+    }
+    return [];
+}
+function buildInstallation(browser, label, rootDir, executablePathCandidates) {
+    return {
+        browser,
+        label,
+        rootDir,
+        localStatePath: join(rootDir, "Local State"),
+        executablePathCandidates,
+    };
+}
+export function parseBrowserProfilesFromLocalState(localStateText) {
+    const parsed = JSON.parse(localStateText);
+    const profile = parsed.profile ?? {};
+    const infoCache = profile.info_cache ?? {};
+    const orderedNames = [];
+    const pushUnique = (name) => {
+        if (!name || orderedNames.includes(name)) {
+            return;
+        }
+        orderedNames.push(name);
+    };
+    for (const name of profile.last_active_profiles ?? []) {
+        pushUnique(name);
+    }
+    pushUnique(profile.last_used);
+    for (const name of profile.profiles_order ?? []) {
+        pushUnique(name);
+    }
+    const remaining = Object.keys(infoCache)
+        .filter((name) => !orderedNames.includes(name))
+        .sort((left, right) => ((infoCache[right]?.active_time ?? 0) - (infoCache[left]?.active_time ?? 0)));
+    for (const name of remaining) {
+        pushUnique(name);
+    }
+    if (orderedNames.length === 0 && infoCache.Default) {
+        orderedNames.push("Default");
+    }
+    return {
+        orderedProfileNames: orderedNames,
+        infoCache,
+    };
+}
+function buildProfileLabel(profileName, meta) {
+    return meta?.name?.trim() || meta?.user_name?.trim() || meta?.gaia_name?.trim() || profileName;
+}
+export function findImportableBrowserProfileCandidates(input) {
+    const exists = input?.exists ?? existsSync;
+    const readFile = input?.readFile ?? ((path) => readFileSync(path, "utf8"));
+    const candidates = [];
+    for (const installation of listSupportedBrowserInstallations(input)) {
+        if (!exists(installation.rootDir) || !exists(installation.localStatePath)) {
+            continue;
+        }
+        const executablePath = installation.executablePathCandidates.find((path) => exists(path));
+        if (!executablePath) {
+            continue;
+        }
+        let parsedState;
+        try {
+            parsedState = parseBrowserProfilesFromLocalState(readFile(installation.localStatePath));
+        }
+        catch {
+            continue;
+        }
+        for (const profileName of parsedState.orderedProfileNames) {
+            const profileDir = join(installation.rootDir, profileName);
+            if (!exists(profileDir)) {
+                continue;
+            }
+            candidates.push({
+                ...installation,
+                executablePath,
+                profileName,
+                profileLabel: buildProfileLabel(profileName, parsedState.infoCache[profileName]),
+                profileDir,
+            });
+        }
+    }
+    return candidates;
+}
+function shouldCopyProfilePath(sourcePath) {
+    return !sourcePath
+        .split(/[\\/]+/)
+        .filter(Boolean)
+        .some((segment) => CACHE_DIR_NAMES.has(segment));
+}
+export function prepareImportedBrowserWorkspace(candidate, tempRootDir = tmpdir()) {
+    const workspaceDir = mkdtempSync(join(tempRootDir, `yt-mcp-${candidate.browser}-profile-`));
+    const localStatePath = join(workspaceDir, "Local State");
+    const profileDir = join(workspaceDir, candidate.profileName);
+    cpSync(candidate.localStatePath, localStatePath);
+    cpSync(candidate.profileDir, profileDir, {
+        recursive: true,
+        filter: (sourcePath) => shouldCopyProfilePath(sourcePath.replace(candidate.profileDir, basename(candidate.profileDir))),
+    });
+    return {
+        browser: candidate.browser,
+        label: candidate.label,
+        profileName: candidate.profileName,
+        profileLabel: candidate.profileLabel,
+        workspaceDir,
+        localStatePath,
+        profileDir,
+        executablePath: candidate.executablePath,
+    };
+}
+export function cleanupImportedBrowserWorkspace(workspace) {
+    rmSync(workspace.workspaceDir, { recursive: true, force: true });
+}

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.5",
+  "version": "0.0.7",
   "description": "Internal MCP client with local data tools and remote API proxy",
   "type": "module",
   "bin": {