@mkterswingman/5mghost-yonder 0.0.1

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

@@ -0,0 +1,18 @@
+export interface CookieEntry {
+    name: string;
+    value: string;
+    domain: string;
+    path: string;
+    secure: boolean;
+    httpOnly: boolean;
+    expires: number;
+}
+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

@@ -0,0 +1,78 @@
+import { existsSync, readFileSync } from "node:fs";
+export function cookiesToNetscape(cookies) {
+    const lines = [
+        "# Netscape HTTP Cookie File",
+        "# https://curl.haxx.se/rfc/cookie_spec.html",
+        "# This is a generated file!  Do not edit.",
+        "",
+    ];
+    for (const c of cookies) {
+        const domain = c.domain.startsWith(".") ? c.domain : c.domain;
+        const includeSubdomains = c.domain.startsWith(".") ? "TRUE" : "FALSE";
+        const secure = c.secure ? "TRUE" : "FALSE";
+        const expiry = Math.floor(c.expires);
+        lines.push(`${domain}\t${includeSubdomains}\t${c.path}\t${secure}\t${expiry}\t${c.name}\t${c.value}`);
+    }
+    return lines.join("\n") + "\n";
+}
+export function hasSIDCookies(cookiesPath) {
+    if (!existsSync(cookiesPath))
+        return false;
+    try {
+        const content = readFileSync(cookiesPath, "utf8");
+        return content.includes("SID") && content.includes(".youtube.com");
+    }
+    catch {
+        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/dist/utils/launcher.d.ts

@@ -0,0 +1,12 @@
+export interface LauncherSourceOptions {
+    packageSpec?: string;
+    npmCacheDir?: string;
+}
+export interface LauncherCommand {
+    command: string;
+    args: string[];
+}
+export declare function buildLauncherCommand(launcherPath?: string): LauncherCommand;
+export declare function isRepairableNpxFailure(stderr: string): boolean;
+export declare function buildLauncherSource(options?: LauncherSourceOptions): string;
+export declare function writeLauncherFile(options?: LauncherSourceOptions): string;

package/dist/utils/launcher.js

@@ -0,0 +1,82 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { PATHS } from "./config.js";
+const DEFAULT_PACKAGE_SPEC = "@mkterswingman/5mghost-yonder@latest";
+export function buildLauncherCommand(launcherPath = PATHS.launcherJs) {
+    return {
+        command: "node",
+        args: [launcherPath, "serve"],
+    };
+}
+export function isRepairableNpxFailure(stderr) {
+    const lower = stderr.toLowerCase();
+    const referencesNpxDir = lower.includes("_npx/") || lower.includes("_npx\\");
+    return referencesNpxDir && (lower.includes("enotempty") || lower.includes("rename"));
+}
+export function buildLauncherSource(options = {}) {
+    const packageSpec = options.packageSpec ?? DEFAULT_PACKAGE_SPEC;
+    const npmCacheDir = options.npmCacheDir ?? PATHS.npmCacheDir;
+    return `#!/usr/bin/env node
+import { existsSync, mkdirSync, renameSync } from "node:fs";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+
+const packageSpec = ${JSON.stringify(packageSpec)};
+const npmCacheDir = ${JSON.stringify(npmCacheDir)};
+const args = process.argv.slice(2);
+const targetArgs = args.length > 0 ? args : ["serve"];
+
+function isRepairableNpxFailure(stderr) {
+  const lower = stderr.toLowerCase();
+  return (lower.includes("_npx/") || lower.includes("_npx\\"))
+    && (lower.includes("enotempty") || lower.includes("rename"));
+}
+
+function runNpx(subArgs, captureStdErrOnly = false) {
+  mkdirSync(npmCacheDir, { recursive: true });
+  const npxBin = process.platform === "win32" ? "npx.cmd" : "npx";
+  return spawnSync(npxBin, ["--yes", packageSpec, ...subArgs], {
+    env: { ...process.env, npm_config_cache: npmCacheDir },
+    // Why: probe runs before MCP starts; stdout must stay silent or it will corrupt stdio transport.
+    stdio: captureStdErrOnly ? ["ignore", "ignore", "pipe"] : "inherit",
+  });
+}
+
+function rotateNpxDir() {
+  const npxDir = join(npmCacheDir, "_npx");
+  if (!existsSync(npxDir)) return false;
+  const backup = \`\${npxDir}.bad.\${new Date().toISOString().replace(/[^0-9]/g, "").slice(0, 14)}\`;
+  renameSync(npxDir, backup);
+  process.stderr.write(\`[yt-mcp launcher] repaired corrupted npx cache: \${backup}\\n\`);
+  return true;
+}
+
+function ensurePackageReady() {
+  const first = runNpx(["version"], true);
+  if ((first.status ?? 1) === 0) return;
+
+  const stderr = first.stderr ? String(first.stderr) : "";
+  if (!isRepairableNpxFailure(stderr) || !rotateNpxDir()) {
+    if (stderr) process.stderr.write(stderr);
+    process.exit(first.status ?? 1);
+  }
+
+  const second = runNpx(["version"], true);
+  const secondStderr = second.stderr ? String(second.stderr) : "";
+  if ((second.status ?? 1) !== 0) {
+    if (secondStderr) process.stderr.write(secondStderr);
+    process.exit(second.status ?? 1);
+  }
+}
+
+ensurePackageReady();
+const finalRun = runNpx(targetArgs, false);
+process.exit(finalRun.status ?? 0);
+`;
+}
+export function writeLauncherFile(options = {}) {
+    mkdirSync(dirname(PATHS.launcherJs), { recursive: true });
+    const source = buildLauncherSource(options);
+    writeFileSync(PATHS.launcherJs, source, { encoding: "utf8", mode: 0o755 });
+    return PATHS.launcherJs;
+}

package/dist/utils/mcpRegistration.d.ts

@@ -0,0 +1,7 @@
+export declare const MCP_REGISTER_TIMEOUT_MS = 5000;
+export type RegistrationFailureKind = "already_exists" | "authentication" | "timeout" | "other";
+export interface RegistrationFailure {
+    kind: RegistrationFailureKind;
+    output: string;
+}
+export declare function classifyRegistrationFailure(err: unknown): RegistrationFailure;

package/dist/utils/mcpRegistration.js

@@ -0,0 +1,23 @@
+export const MCP_REGISTER_TIMEOUT_MS = 5000;
+function readOutput(err) {
+    if (!(err instanceof Error))
+        return "";
+    const stderr = "stderr" in err ? String(err.stderr ?? "") : "";
+    const stdout = "stdout" in err ? String(err.stdout ?? "") : "";
+    return `${stderr}${stdout}`;
+}
+export function classifyRegistrationFailure(err) {
+    const output = readOutput(err);
+    const lower = output.toLowerCase();
+    if (lower.includes("already exists")) {
+        return { kind: "already_exists", output };
+    }
+    if (lower.includes("waiting for authentication")) {
+        return { kind: "authentication", output };
+    }
+    if (err instanceof Error &&
+        ("code" in err && err.code === "ETIMEDOUT")) {
+        return { kind: "timeout", output };
+    }
+    return { kind: "other", output };
+}

package/dist/utils/videoInput.d.ts

@@ -0,0 +1,5 @@
+export declare function resolveVideoInput(input: string): string | null;
+export declare function normalizeVideoInputs(inputs: string[]): {
+    resolvedIds: string[];
+    invalidInputs: string[];
+};

package/dist/utils/videoInput.js

@@ -0,0 +1,55 @@
+const VIDEO_ID_RE = /^[A-Za-z0-9_-]{11}$/;
+function toValidVideoId(value) {
+    const v = value.trim();
+    return VIDEO_ID_RE.test(v) ? v : null;
+}
+function extractFromUrl(raw) {
+    let url;
+    try {
+        url = new URL(raw.trim());
+    }
+    catch {
+        return null;
+    }
+    const host = url.hostname.toLowerCase();
+    const normalizedHost = host.startsWith("www.") ? host.slice(4) : host;
+    if (normalizedHost === "youtu.be") {
+        const id = url.pathname.split("/").filter(Boolean)[0] ?? "";
+        return toValidVideoId(id);
+    }
+    if (normalizedHost === "youtube.com" || normalizedHost === "m.youtube.com") {
+        if (url.pathname === "/watch") {
+            return toValidVideoId(url.searchParams.get("v") ?? "");
+        }
+        const parts = url.pathname.split("/").filter(Boolean);
+        if (parts.length >= 2 && ["shorts", "live", "embed"].includes(parts[0])) {
+            return toValidVideoId(parts[1]);
+        }
+    }
+    return null;
+}
+export function resolveVideoInput(input) {
+    const candidate = input.trim();
+    if (!candidate) {
+        return null;
+    }
+    const directId = toValidVideoId(candidate);
+    return directId ?? extractFromUrl(candidate);
+}
+export function normalizeVideoInputs(inputs) {
+    const resolvedIds = [];
+    const invalidInputs = [];
+    const seen = new Set();
+    for (const raw of inputs) {
+        const parsedId = resolveVideoInput(raw);
+        if (!parsedId) {
+            invalidInputs.push(raw);
+            continue;
+        }
+        if (!seen.has(parsedId)) {
+            seen.add(parsedId);
+            resolvedIds.push(parsedId);
+        }
+    }
+    return { resolvedIds, invalidInputs };
+}

package/dist/utils/ytdlp.d.ts

@@ -0,0 +1,7 @@
+export interface YtDlpResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    durationMs: number;
+}
+export declare function runYtDlp(args: string[], timeoutMs?: number): Promise<YtDlpResult>;

package/dist/utils/ytdlp.js

@@ -0,0 +1,52 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { PATHS } from "./config.js";
+import { getYtDlpPath } from "./ytdlpPath.js";
+export function runYtDlp(args, timeoutMs = 45_000) {
+    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 proc = spawn(getYtDlpPath(), finalArgs, {
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        proc.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
+        proc.stderr.on("data", (chunk) => stderrChunks.push(chunk));
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (!settled) {
+                settled = true;
+                proc.kill("SIGKILL");
+                resolve({
+                    exitCode: -1,
+                    stdout: Buffer.concat(stdoutChunks).toString("utf8"),
+                    stderr: `yt-dlp timed out after ${timeoutMs}ms`,
+                    durationMs: Date.now() - start,
+                });
+            }
+        }, timeoutMs);
+        proc.on("close", (code) => {
+            clearTimeout(timer);
+            if (!settled) {
+                settled = true;
+                resolve({
+                    exitCode: code ?? 1,
+                    stdout: Buffer.concat(stdoutChunks).toString("utf8"),
+                    stderr: Buffer.concat(stderrChunks).toString("utf8"),
+                    durationMs: Date.now() - start,
+                });
+            }
+        });
+        proc.on("error", (err) => {
+            clearTimeout(timer);
+            if (!settled) {
+                settled = true;
+                reject(err);
+            }
+        });
+    });
+}

package/dist/utils/ytdlpPath.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Resolve the yt-dlp binary path.
+ *
+ * Priority:
+ *   1. YT_DLP_PATH env var (explicit override)
+ *   2. Bundled binary at <pkg>/bin/yt-dlp (downloaded by postinstall)
+ *   3. "yt-dlp" — fall back to system PATH
+ */
+/**
+ * Returns the absolute path to the yt-dlp binary, or the bare command name
+ * "yt-dlp" if only available on system PATH.
+ */
+export declare function getYtDlpPath(): string;
+export interface YtDlpVersionInfo {
+    version: string;
+    source: "bundled" | "system" | "env";
+}
+/**
+ * Get the version string and source of the resolved yt-dlp binary.
+ * Returns null if yt-dlp is not available at all.
+ *
+ * Uses a 30s timeout because macOS Gatekeeper performs a network verification
+ * on first run of ad-hoc signed binaries (~15-20s). The result is cached by
+ * the OS, so subsequent calls return instantly.
+ */
+export declare function getYtDlpVersion(binPath?: string): YtDlpVersionInfo | null;

package/dist/utils/ytdlpPath.js

@@ -0,0 +1,78 @@
+/**
+ * Resolve the yt-dlp binary path.
+ *
+ * Priority:
+ *   1. YT_DLP_PATH env var (explicit override)
+ *   2. Bundled binary at <pkg>/bin/yt-dlp (downloaded by postinstall)
+ *   3. "yt-dlp" — fall back to system PATH
+ */
+import { existsSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+// From dist/utils/ → package root is ../../
+const pkgRoot = join(__dirname, "..", "..");
+function bundledPath() {
+    const name = process.platform === "win32" ? "yt-dlp.exe" : "yt-dlp";
+    return join(pkgRoot, "bin", name);
+}
+/**
+ * Returns the absolute path to the yt-dlp binary, or the bare command name
+ * "yt-dlp" if only available on system PATH.
+ */
+export function getYtDlpPath() {
+    // 1. Explicit env override
+    const envPath = process.env.YT_DLP_PATH;
+    if (envPath && existsSync(envPath))
+        return envPath;
+    // 2. Bundled binary
+    const bundled = bundledPath();
+    if (existsSync(bundled))
+        return bundled;
+    // 3. System PATH
+    return "yt-dlp";
+}
+/**
+ * Get the version string and source of the resolved yt-dlp binary.
+ * Returns null if yt-dlp is not available at all.
+ *
+ * Uses a 30s timeout because macOS Gatekeeper performs a network verification
+ * on first run of ad-hoc signed binaries (~15-20s). The result is cached by
+ * the OS, so subsequent calls return instantly.
+ */
+export function getYtDlpVersion(binPath) {
+    const resolved = binPath ?? getYtDlpPath();
+    let source;
+    if (process.env.YT_DLP_PATH && resolved === process.env.YT_DLP_PATH) {
+        source = "env";
+    }
+    else if (resolved === bundledPath()) {
+        source = "bundled";
+    }
+    else {
+        source = "system";
+    }
+    try {
+        // macOS Gatekeeper: try clearing quarantine xattr before first execution.
+        // This helps in some environments; in others the OS re-applies it.
+        if (process.platform === "darwin" && resolved !== "yt-dlp") {
+            try {
+                execFileSync("xattr", ["-cr", resolved], { stdio: "ignore" });
+            }
+            catch {
+                // non-fatal
+            }
+        }
+        const ver = execFileSync(resolved, ["--version"], {
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 30_000,
+        })
+            .toString()
+            .trim();
+        return { version: ver, source };
+    }
+    catch {
+        return null;
+    }
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@mkterswingman/5mghost-yonder",
+  "version": "0.0.1",
+  "description": "Internal MCP client with local data tools and remote API proxy",
+  "type": "module",
+  "bin": {
+    "yt-mcp": "dist/cli/index.js"
+  },
+  "exports": {
+    ".": "./dist/server.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsx src/cli/index.ts",
+    "start": "node dist/cli/index.js",
+    "postinstall": "node scripts/download-ytdlp.mjs"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.28.0",
+    "playwright": "^1.58.0",
+    "zod": "^4.3.6"
+  },
+  "optionalDependencies": {
+    "puppeteer-core": "^24.0.0"
+  },
+  "keywords": [
+    "mkterswingman",
+    "ghost",
+    "cli"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist/",
+    "scripts/download-ytdlp.mjs",
+    "README.md"
+  ],
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  }
+}