@mkterswingman/yt-mcp 0.3.6 → 0.3.7

package/README.md

@@ -0,0 +1,19 @@
+# yt-mcp
+
+Local MCP server for YouTube workflows.
+
+## Quick Start
+
+```bash
+npx @mkterswingman/yt-mcp setup
+```
+
+The setup command configures auth, optional YouTube cookies, and prints MCP config for supported AI clients.
+
+## Commands
+
+- `setup` — first-time setup
+- `serve` — start the stdio MCP server
+- `setup-cookies` — refresh YouTube cookies
+- `update` — update to the latest npm version
+- `version` — print the installed version

package/dist/cli/setup.js

@@ -8,6 +8,8 @@ import { TokenManager } from "../auth/tokenManager.js";
 import { runOAuthFlow } from "../auth/oauthFlow.js";
 import { hasSIDCookies } from "../utils/cookies.js";
 import { getYtDlpPath, getYtDlpVersion } from "../utils/ytdlpPath.js";
+import { buildLauncherCommand, writeLauncherFile } from "../utils/launcher.js";
+import { MCP_REGISTER_TIMEOUT_MS, classifyRegistrationFailure, } from "../utils/mcpRegistration.js";
 function detectCli(name) {
     try {
         execSync(`${name} --version`, { stdio: "pipe" });
@@ -19,26 +21,36 @@ function detectCli(name) {
 }
 function tryRegisterMcp(cmd, label) {
     try {
-        execSync(cmd, { stdio: "pipe" });
+        execSync(cmd, { stdio: "pipe", timeout: MCP_REGISTER_TIMEOUT_MS });
         console.log(`  ✅ MCP registered in ${label}`);
         return true;
     }
     catch (err) {
-        // "already exists" is still a success — the MCP is configured
-        const stderr = err instanceof Error && "stderr" in err
-            ? String(err.stderr)
-            : "";
-        const stdout = err instanceof Error && "stdout" in err
-            ? String(err.stdout)
-            : "";
-        const output = stderr + stdout;
-        if (output.includes("already exists")) {
+        const failure = classifyRegistrationFailure(err);
+        if (failure.kind === "already_exists") {
             console.log(`  ✅ MCP already registered in ${label}`);
             return true;
         }
+        if (failure.kind === "authentication") {
+            console.log(`  ⚠️  ${label} is waiting for authentication — skipped auto-register.`);
+            return false;
+        }
+        if (failure.kind === "timeout") {
+            console.log(`  ⚠️  ${label} registration timed out after ${MCP_REGISTER_TIMEOUT_MS}ms — skipped auto-register.`);
+            return false;
+        }
         return false;
     }
 }
+function quoteForShell(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function quoteForCmd(value) {
+    return `"${value.replace(/"/g, '""')}"`;
+}
+function quoteArg(value) {
+    return process.platform === "win32" ? quoteForCmd(value) : quoteForShell(value);
+}
 /**
  * Detect if we can open a browser (local machine with display).
  * Cloud environments (SSH, Docker, cloud IDE) typically can't.
@@ -129,7 +141,9 @@ export async function runSetup() {
     console.log("Step 2/5: Initializing config...");
     const config = loadConfig();
     saveConfig(config);
+    writeLauncherFile();
     console.log(`  ✅ Config: ${PATHS.configJson}`);
+    console.log(`  ✅ Launcher: ${PATHS.launcherJs}`);
     // ── Step 3: Authentication ──
     console.log("Step 3/5: Authentication...");
     const tokenManager = new TokenManager(config.auth_url);
@@ -238,7 +252,8 @@ export async function runSetup() {
     }
     // ── Step 5: MCP Registration ──
     console.log("Step 5/5: Registering MCP in AI clients...");
-    const mcpArgs = "npx @mkterswingman/yt-mcp@latest serve";
+    const launcherCommand = buildLauncherCommand();
+    const mcpArgs = [launcherCommand.command, ...launcherCommand.args].map(quoteArg).join(" ");
     let registered = false;
     const cliCandidates = [
         // Claude Code: {bin} mcp add yt-mcp -- npx ... serve
@@ -286,8 +301,8 @@ export async function runSetup() {
   {
     "mcpServers": {
       "yt-mcp": {
-        "command": "npx",
-        "args": ["@mkterswingman/yt-mcp@latest", "serve"]
+        "command": "node",
+        "args": [${JSON.stringify(PATHS.launcherJs)}, "serve"]
       }
     }
   }

package/dist/utils/config.d.ts

@@ -3,6 +3,8 @@ export declare const PATHS: {
     authJson: string;
     cookiesTxt: string;
     browserProfile: string;
+    launcherJs: string;
+    npmCacheDir: string;
     subtitlesDir: string;
     configJson: string;
 };

package/dist/utils/config.js

@@ -8,12 +8,15 @@ export const PATHS = {
     authJson: join(CONFIG_DIR, "auth.json"),
     cookiesTxt: join(CONFIG_DIR, "cookies.txt"),
     browserProfile: join(CONFIG_DIR, "browser-profile"),
+    launcherJs: join(CONFIG_DIR, "launcher.mjs"),
+    npmCacheDir: join(CONFIG_DIR, "npm-cache"),
     subtitlesDir: SUBTITLES_DIR,
     configJson: join(CONFIG_DIR, "config.json"),
 };
 const DEFAULTS = {
     auth_url: "https://mkterswingman.com",
     api_url: "https://mkterswingman.com/mcp/yt",
+    // Fixed list, not probed: --list-subs costs ~10s extra and YouTube has no "source language" concept
     default_languages: ["en", "zh-Hans"],
     batch_sleep_min_ms: 3000,
     batch_sleep_max_ms: 8000,

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/yt-mcp@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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mkterswingman/yt-mcp",
-  "version": "0.3.6",
+  "version": "0.3.7",
   "description": "YouTube MCP client — local subtitles + remote API proxy",
   "type": "module",
   "bin": {

package/scripts/download-ytdlp.mjs

@@ -18,6 +18,8 @@ import { pipeline } from "node:stream/promises";
 
 // ── Constants ────────────────────────────────────────────────────────────────
 
+// Pinned version: upgrade by changing this constant + publishing new npm version.
+// Avoids auto-update breaking compat. postinstall (not optionalDeps) because yt-dlp is a standalone binary.
 const YT_DLP_VERSION = "2026.03.17";
 
 const BASE_URL =