@mkterswingman/5mghost-yonder 0.0.6 → 0.0.8

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

@@ -6,6 +6,7 @@ export interface UnifiedUpdateDeps {
     installLatestPackage(): Promise<void>;
     updateRuntime(): Promise<import("../runtime/installers.js").RuntimeSummary>;
 }
+export declare function compareVersions(currentVersion: string, latestVersion: string): number;
 export declare function runUnifiedUpdate(deps: UnifiedUpdateDeps): Promise<{
     package: {
         currentVersion: string;

package/dist/cli/index.js

@@ -35,11 +35,25 @@ Environment variables:
   YT_MCP_TOKEN   Personal Access Token (skips OAuth)
 `;
 }
+export function compareVersions(currentVersion, latestVersion) {
+    const normalize = (value) => value.split(".").map((part) => Number.parseInt(part, 10)).map((part) => (Number.isFinite(part) ? part : 0));
+    const current = normalize(currentVersion);
+    const latest = normalize(latestVersion);
+    const max = Math.max(current.length, latest.length);
+    for (let index = 0; index < max; index += 1) {
+        const a = current[index] ?? 0;
+        const b = latest[index] ?? 0;
+        if (a === b)
+            continue;
+        return a < b ? -1 : 1;
+    }
+    return 0;
+}
 export async function runUnifiedUpdate(deps) {
     const currentVersion = deps.getCurrentVersion();
     const latestVersion = await deps.getLatestVersion();
     let updated = false;
-    if (latestVersion !== currentVersion) {
+    if (compareVersions(currentVersion, latestVersion) < 0) {
         await deps.installLatestPackage();
         updated = true;
     }

package/dist/cli/setup.d.ts

@@ -1,3 +1,13 @@
+interface CliCommand {
+    file: string;
+    args: string[];
+}
+interface SetupCliCandidate {
+    bin: string;
+    label: string;
+    command: CliCommand;
+}
+export declare function buildSetupCliCandidates(launcherCommand: CliCommand): SetupCliCandidate[];
 export declare function canOpenBrowserForEnv(input: {
     platform: NodeJS.Platform;
     env: NodeJS.ProcessEnv;
@@ -7,3 +17,4 @@ export declare function getNoBrowserSessionNotice(): string;
 export declare function getNoBrowserPatHint(authUrl: string): string[];
 export declare function getCookieSetupDeferredHint(): string[];
 export declare function runSetup(): Promise<void>;
+export {};

package/dist/cli/setup.js

@@ -7,6 +7,7 @@ import { hasSIDCookies } from "../utils/cookies.js";
 import { buildLauncherCommand, writeLauncherFile } from "../utils/launcher.js";
 import { checkAll } from "../runtime/installers.js";
 import { getOpenClawConfigPath, isOpenClawInstallLikelyInstalled, writeOpenClawConfig, } from "../utils/openClaw.js";
+import { getCodexInternalConfigPath, writeCodexInternalConfig, } from "../utils/codexInternal.js";
 import { MCP_REGISTER_TIMEOUT_MS, classifyRegistrationFailure, } from "../utils/mcpRegistration.js";
 function detectCli(name) {
     try {
@@ -40,6 +41,16 @@ function tryRegisterMcp(cmd, label) {
         return false;
     }
 }
+export function buildSetupCliCandidates(launcherCommand) {
+    return [
+        { bin: "claude-internal", label: "Claude Code (internal)", command: { file: "claude-internal", args: ["mcp", "add", "-s", "user", "yt-mcp", "--", launcherCommand.file, ...launcherCommand.args] } },
+        { bin: "claude", label: "Claude Code", command: { file: "claude", args: ["mcp", "add", "-s", "user", "yt-mcp", "--", launcherCommand.file, ...launcherCommand.args] } },
+        { bin: "codex", label: "Codex CLI / Codex App", command: { file: "codex", args: ["mcp", "add", "yt-mcp", "--", launcherCommand.file, ...launcherCommand.args] } },
+        { bin: "gemini-internal", label: "Gemini CLI (internal)", command: { file: "gemini-internal", args: ["mcp", "add", "-s", "user", "yt-mcp", launcherCommand.file, ...launcherCommand.args] } },
+        { bin: "gemini", label: "Gemini CLI", command: { file: "gemini", args: ["mcp", "add", "-s", "user", "yt-mcp", launcherCommand.file, ...launcherCommand.args] } },
+        { bin: "opencode", label: "OpenCode", command: { file: "opencode", args: ["mcp", "add", "yt-mcp", "--", launcherCommand.file, ...launcherCommand.args] } },
+    ];
+}
 export function canOpenBrowserForEnv(input) {
     if (input.env.YT_MCP_NO_BROWSER === "1") {
         return false;
@@ -243,36 +254,12 @@ export async function runSetup() {
     console.log("Step 5/5: Registering MCP in AI clients...");
     const launcherCommand = buildLauncherCommand();
     let registered = false;
-    const cliCandidates = [
-        // Claude Code: {bin} mcp add yt-mcp -- npx ... serve
-        { bin: "claude-internal", label: "Claude Code (internal)",
-            cmd: (b, launcher) => ({ file: b, args: ["mcp", "add", "-s", "user", "yt-mcp", "--", launcher.command, ...launcher.args] }) },
-        { bin: "claude", label: "Claude Code",
-            cmd: (b, launcher) => ({ file: b, args: ["mcp", "add", "-s", "user", "yt-mcp", "--", launcher.command, ...launcher.args] }) },
-        // Codex (public): {bin} mcp add yt-mcp -- npx ... serve
-        { bin: "codex", label: "Codex CLI / Codex App",
-            cmd: (b, launcher) => ({ file: b, args: ["mcp", "add", "yt-mcp", "--", launcher.command, ...launcher.args] }) },
-        // Codex-internal doesn't support mcp add — needs manual config
-        { bin: "codex-internal", label: "Codex CLI (internal)",
-            cmd: () => null },
-        // Gemini: {bin} mcp add -s user yt-mcp node <launcher> serve (no --)
-        { bin: "gemini-internal", label: "Gemini CLI (internal)",
-            cmd: (b, launcher) => ({ file: b, args: ["mcp", "add", "-s", "user", "yt-mcp", launcher.command, ...launcher.args] }) },
-        { bin: "gemini", label: "Gemini CLI",
-            cmd: (b, launcher) => ({ file: b, args: ["mcp", "add", "-s", "user", "yt-mcp", launcher.command, ...launcher.args] }) },
-        // Others: assume Claude-style syntax
-        { bin: "opencode", label: "OpenCode",
-            cmd: (b, launcher) => ({ file: b, args: ["mcp", "add", "yt-mcp", "--", launcher.command, ...launcher.args] }) },
-    ];
-    for (const { bin, label, cmd } of cliCandidates) {
+    for (const { bin, label, command } of buildSetupCliCandidates({
+        file: launcherCommand.command,
+        args: launcherCommand.args,
+    })) {
         if (!detectCli(bin))
             continue;
-        const command = cmd(bin, launcherCommand);
-        if (!command) {
-            // CLI detected but doesn't support auto-registration
-            console.log(`  ⚠️  ${label} detected but requires manual MCP config.`);
-            continue;
-        }
         if (tryRegisterMcp(command, label)) {
             registered = true;
         }
@@ -288,6 +275,17 @@ export async function runSetup() {
             console.log(`  ⚠️  OpenClaw auto-register failed: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
+    if (detectCli("codex-internal")) {
+        try {
+            const status = writeCodexInternalConfig("yt-mcp", launcherCommand);
+            const suffix = status === "created" ? "created" : "updated";
+            console.log(`  ✅ MCP registered in Codex CLI (internal) (${suffix} ${getCodexInternalConfigPath()})`);
+            registered = true;
+        }
+        catch (err) {
+            console.log(`  ⚠️  Codex CLI (internal) auto-register failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     if (!registered) {
         console.log("  ℹ️  No supported CLI found. Add manually to your AI client:");
     }

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

@@ -1 +1,16 @@
+interface CliCommand {
+    file: string;
+    args: string[];
+}
+interface UninstallCliCandidate {
+    bin: string;
+    label: string;
+    command: CliCommand;
+}
+export declare function buildUninstallCliCandidates(): UninstallCliCandidate[];
+export declare function buildSelfUninstallInvocation(): {
+    command: string;
+    args: string[];
+};
 export declare function runUninstall(): Promise<void>;
+export {};

package/dist/cli/uninstall.js

@@ -1,7 +1,8 @@
-import { execFileSync } from "node:child_process";
+import { execFileSync, spawn } from "node:child_process";
 import { existsSync, rmSync } from "node:fs";
 import { PATHS } from "../utils/config.js";
 import { getOpenClawConfigPath, removeOpenClawConfig } from "../utils/openClaw.js";
+import { getCodexInternalConfigPath, removeCodexInternalConfig, } from "../utils/codexInternal.js";
 function detectCli(name) {
     try {
         execFileSync(name, ["--version"], { stdio: "pipe" });
@@ -30,10 +31,8 @@ function tryRemoveMcp(command, label) {
         return "failed";
     }
 }
-export async function runUninstall() {
-    console.log("\n🧹 yt-mcp uninstall\n");
-    console.log("Removing MCP client registrations...");
-    const cliCandidates = [
+export function buildUninstallCliCandidates() {
+    return [
         { bin: "claude-internal", label: "Claude Code (internal)", command: { file: "claude-internal", args: ["mcp", "remove", "-s", "user", "yt-mcp"] } },
         { bin: "claude", label: "Claude Code", command: { file: "claude", args: ["mcp", "remove", "-s", "user", "yt-mcp"] } },
         { bin: "codex", label: "Codex CLI / Codex App", command: { file: "codex", args: ["mcp", "remove", "yt-mcp"] } },
@@ -41,8 +40,31 @@ export async function runUninstall() {
         { bin: "gemini", label: "Gemini CLI", command: { file: "gemini", args: ["mcp", "remove", "-s", "user", "yt-mcp"] } },
         { bin: "opencode", label: "OpenCode", command: { file: "opencode", args: ["mcp", "remove", "yt-mcp"] } },
     ];
-    for (const candidate of cliCandidates) {
-        if (!detectCli(candidate.bin) || !candidate.command)
+}
+export function buildSelfUninstallInvocation() {
+    const npmBin = process.platform === "win32" ? "npm.cmd" : "npm";
+    const helper = process.platform === "win32"
+        ? `setTimeout(() => { require("node:child_process").spawnSync(${JSON.stringify(npmBin)}, ["uninstall","-g","@mkterswingman/5mghost-yonder"], { stdio: "ignore", shell: false }); }, 1500);`
+        : `setTimeout(() => { require("node:child_process").spawnSync(${JSON.stringify(npmBin)}, ["uninstall","-g","@mkterswingman/5mghost-yonder"], { stdio: "ignore" }); }, 1500);`;
+    return {
+        command: process.execPath,
+        args: ["-e", helper],
+    };
+}
+function scheduleSelfUninstall() {
+    const invocation = buildSelfUninstallInvocation();
+    const child = spawn(invocation.command, invocation.args, {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true,
+    });
+    child.unref();
+}
+export async function runUninstall() {
+    console.log("\n🧹 yt-mcp uninstall\n");
+    console.log("Removing MCP client registrations...");
+    for (const candidate of buildUninstallCliCandidates()) {
+        if (!detectCli(candidate.bin))
             continue;
         tryRemoveMcp(candidate.command, candidate.label);
     }
@@ -53,6 +75,15 @@ export async function runUninstall() {
     else {
         console.log("  ℹ️  OpenClaw did not have yt-mcp registered");
     }
+    if (detectCli("codex-internal")) {
+        const codexInternalStatus = removeCodexInternalConfig("yt-mcp");
+        if (codexInternalStatus === "removed") {
+            console.log(`  ✅ Removed MCP registration from Codex CLI (internal) (${getCodexInternalConfigPath()})`);
+        }
+        else {
+            console.log("  ℹ️  Codex CLI (internal) did not have yt-mcp registered");
+        }
+    }
     if (existsSync(PATHS.configDir)) {
         // Why: ~/.yt-mcp contains launcher, token cache, cookies, and npm cache owned by this package.
         rmSync(PATHS.configDir, { recursive: true, force: true });
@@ -62,6 +93,7 @@ export async function runUninstall() {
         console.log(`  ℹ️  Local yt-mcp config already absent: ${PATHS.configDir}`);
     }
     console.log(`  ℹ️  Preserved downloaded media: ${PATHS.subtitlesDir}`);
-    console.log("  ℹ️  If you installed globally, remove the package with: npm uninstall -g @mkterswingman/5mghost-yonder");
+    scheduleSelfUninstall();
+    console.log("  ✅ Scheduled global npm package removal");
     console.log("");
 }

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

@@ -0,0 +1,9 @@
+import type { LauncherCommand } from "./launcher.js";
+export declare function getCodexInternalConfigPath(homeDir?: string): string;
+export declare function upsertCodexInternalConfigText(currentText: string | null, serverName: string, launcherCommand: LauncherCommand): string;
+export declare function removeCodexInternalConfigEntryText(currentText: string | null, serverName: string): {
+    changed: boolean;
+    nextText: string | null;
+};
+export declare function writeCodexInternalConfig(serverName: string, launcherCommand: LauncherCommand, configPath?: string): "created" | "updated";
+export declare function removeCodexInternalConfig(serverName: string, configPath?: string): "removed" | "missing";

package/dist/utils/codexInternal.js

@@ -0,0 +1,60 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+export function getCodexInternalConfigPath(homeDir = homedir()) {
+    return join(homeDir, ".codex-internal", "config.toml");
+}
+function formatCodexInternalSection(serverName, launcherCommand) {
+    const escapedName = serverName.replace(/"/g, '\\"');
+    const args = launcherCommand.args.map((arg) => JSON.stringify(arg)).join(", ");
+    return `[mcp_servers.${JSON.stringify(escapedName)}]
+command = ${JSON.stringify(launcherCommand.command)}
+args = [${args}]
+`;
+}
+export function upsertCodexInternalConfigText(currentText, serverName, launcherCommand) {
+    const section = formatCodexInternalSection(serverName, launcherCommand).trimEnd();
+    const sectionPattern = new RegExp(String.raw `(?:^|\n)\[mcp_servers\.${JSON.stringify(serverName).replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\]\n(?:.+\n?)*?(?=\n\[|$)`, "m");
+    if (!currentText || currentText.trim() === "") {
+        return `${section}\n`;
+    }
+    if (sectionPattern.test(currentText)) {
+        return `${currentText.replace(sectionPattern, `\n${section}\n`).trim()}\n`;
+    }
+    return `${currentText.trimEnd()}\n\n${section}\n`;
+}
+export function removeCodexInternalConfigEntryText(currentText, serverName) {
+    if (!currentText) {
+        return { changed: false, nextText: null };
+    }
+    const sectionPattern = new RegExp(String.raw `(?:^|\n)\[mcp_servers\.${JSON.stringify(serverName).replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\]\n(?:.+\n?)*?(?=\n\[|$)`, "m");
+    if (!sectionPattern.test(currentText)) {
+        return { changed: false, nextText: currentText };
+    }
+    const nextText = currentText.replace(sectionPattern, "\n").replace(/\n{3,}/g, "\n\n").trim();
+    return {
+        changed: true,
+        nextText: nextText ? `${nextText}\n` : null,
+    };
+}
+export function writeCodexInternalConfig(serverName, launcherCommand, configPath = getCodexInternalConfigPath()) {
+    const existingText = existsSync(configPath) ? readFileSync(configPath, "utf8") : null;
+    const created = existingText === null;
+    const nextText = upsertCodexInternalConfigText(existingText, serverName, launcherCommand);
+    mkdirSync(dirname(configPath), { recursive: true });
+    writeFileSync(configPath, nextText, "utf8");
+    return created ? "created" : "updated";
+}
+export function removeCodexInternalConfig(serverName, configPath = getCodexInternalConfigPath()) {
+    const existingText = existsSync(configPath) ? readFileSync(configPath, "utf8") : null;
+    const result = removeCodexInternalConfigEntryText(existingText, serverName);
+    if (!result.changed) {
+        return "missing";
+    }
+    if (!result.nextText) {
+        rmSync(configPath, { force: true });
+        return "removed";
+    }
+    writeFileSync(configPath, result.nextText, "utf8");
+    return "removed";
+}

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