@mkterswingman/5mghost-yonder 0.0.1 → 0.0.3

package/dist/cli/setup.js

@@ -1,18 +1,16 @@
-import { existsSync } from "node:fs";
-import { execSync } from "node:child_process";
+import { execFileSync, execSync } from "node:child_process";
 import { createInterface } from "node:readline";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
 import { loadConfig, saveConfig, PATHS, ensureConfigDir } from "../utils/config.js";
 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 { checkAll } from "../runtime/installers.js";
+import { getOpenClawConfigPath, isOpenClawInstallLikelyInstalled, writeOpenClawConfig, } from "../utils/openClaw.js";
 import { MCP_REGISTER_TIMEOUT_MS, classifyRegistrationFailure, } from "../utils/mcpRegistration.js";
 function detectCli(name) {
     try {
-        execSync(`${name} --version`, { stdio: "pipe" });
+        execFileSync(name, ["--version"], { stdio: "pipe" });
         return true;
     }
     catch {
@@ -21,7 +19,7 @@ function detectCli(name) {
 }
 function tryRegisterMcp(cmd, label) {
     try {
-        execSync(cmd, { stdio: "pipe", timeout: MCP_REGISTER_TIMEOUT_MS });
+        execFileSync(cmd.file, cmd.args, { stdio: "pipe", timeout: MCP_REGISTER_TIMEOUT_MS });
         console.log(`  ✅ MCP registered in ${label}`);
         return true;
     }
@@ -42,15 +40,6 @@ function tryRegisterMcp(cmd, label) {
         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.
@@ -103,40 +92,20 @@ export async function runSetup() {
     if (!hasBrowser) {
         console.log("  ℹ️  Cloud/headless environment detected — using PAT mode\n");
     }
-    // ── Step 1: Check yt-dlp ──
-    console.log("Step 1/5: Checking subtitle engine...");
-    const ytdlpPath = getYtDlpPath();
-    const bundledExists = existsSync(ytdlpPath) && ytdlpPath !== "yt-dlp";
-    const ytdlpInfo = getYtDlpVersion();
-    if (ytdlpInfo) {
-        console.log(`  ✅ Subtitle engine ready`);
-    }
-    else if (bundledExists) {
-        // Binary exists but execFileSync("--version") timed out.
-        // Cause: macOS Gatekeeper network verification on first run (~15-20s).
-        console.log("  ✅ yt-dlp ready");
-    }
-    else {
-        // Binary truly missing — download it
-        process.stdout.write("  ⏳ Preparing subtitle engine...");
-        try {
-            execSync("node scripts/download-ytdlp.mjs", {
-                cwd: join(dirname(fileURLToPath(import.meta.url)), "..", ".."),
-                stdio: "pipe",
-                env: { ...process.env, YT_MCP_QUIET: "1" },
-            });
-            const retryInfo = getYtDlpVersion();
-            if (retryInfo) {
-                console.log(`\r  ✅ Subtitle engine ready                `);
-            }
-            else {
-                console.log(`\r  ✅ Subtitle engine ready                `);
-            }
+    // ── Step 1: Runtime check ──
+    console.log("Step 1/5: Checking required runtimes...");
+    const runtimeSummary = await checkAll();
+    for (const component of runtimeSummary.components) {
+        if (component.status === "installed") {
+            console.log(`  ✅ ${component.name}: ${component.source}${component.version ? ` (${component.version})` : ""}`);
         }
-        catch {
-            console.log(`\r  ⚠️  Subtitle engine setup failed — subtitles will be unavailable`);
+        else {
+            console.log(`  ⚠️  ${component.name}: missing${component.message ? ` — ${component.message}` : ""}`);
         }
     }
+    if (runtimeSummary.components.some((component) => component.status !== "installed")) {
+        console.log("  💡 Install missing runtimes with: yt-mcp runtime install");
+    }
     // ── Step 2: Config ──
     console.log("Step 2/5: Initializing config...");
     const config = loadConfig();
@@ -144,6 +113,7 @@ export async function runSetup() {
     writeLauncherFile();
     console.log(`  ✅ Config: ${PATHS.configJson}`);
     console.log(`  ✅ Launcher: ${PATHS.launcherJs}`);
+    console.log(`  ✅ Shared auth: ${PATHS.sharedAuthJson}`);
     // ── Step 3: Authentication ──
     console.log("Step 3/5: Authentication...");
     const tokenManager = new TokenManager(config.auth_url);
@@ -151,7 +121,7 @@ export async function runSetup() {
     if (pat) {
         // Explicit PAT provided via env var
         await tokenManager.savePAT(pat);
-        console.log("  ✅ PAT saved from YT_MCP_TOKEN");
+        console.log(`  ✅ PAT saved from YT_MCP_TOKEN to shared auth`);
     }
     else if (hasBrowser) {
         // Local or cloud desktop — let user choose auth method
@@ -172,7 +142,7 @@ export async function runSetup() {
             const patInput = await prompt("  粘贴你的 PAT token (pat_xxx): ");
             if (patInput) {
                 await tokenManager.savePAT(patInput);
-                console.log("  ✅ PAT saved");
+                console.log("  ✅ PAT saved to shared auth");
             }
             else {
                 console.log("  ⚠️  未输入 token，稍后可通过环境变量配置：");
@@ -189,6 +159,7 @@ export async function runSetup() {
                 const tokens = await runOAuthFlow(config.auth_url);
                 await tokenManager.saveTokens(tokens.accessToken, tokens.refreshToken, tokens.expiresIn, tokens.clientId);
                 console.log("  ✅ OAuth login successful");
+                console.log("  ℹ️  Other first-party local MCPs on this machine can reuse this login.");
             }
             catch (err) {
                 // OAuth failed — auto fallback to PAT
@@ -202,7 +173,7 @@ export async function runSetup() {
                 const patInput = await prompt("  粘贴你的 PAT token (pat_xxx), 或直接回车跳过: ");
                 if (patInput) {
                     await tokenManager.savePAT(patInput);
-                    console.log("  ✅ PAT saved");
+                    console.log("  ✅ PAT saved to shared auth");
                 }
                 else {
                     console.log("  ⚠️  稍后可通过环境变量配置：");
@@ -220,7 +191,7 @@ export async function runSetup() {
         const patInput = await prompt("  粘贴你的 PAT token (pat_xxx), 或直接回车跳过: ");
         if (patInput) {
             await tokenManager.savePAT(patInput);
-            console.log("  ✅ PAT saved");
+            console.log("  ✅ PAT saved to shared auth");
         }
         else {
             console.log("  ⚠️  稍后可通过环境变量配置：");
@@ -253,35 +224,32 @@ export async function runSetup() {
     // ── Step 5: MCP Registration ──
     console.log("Step 5/5: Registering MCP in AI clients...");
     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
         { bin: "claude-internal", label: "Claude Code (internal)",
-            cmd: (b, a) => `${b} mcp add -s user yt-mcp -- ${a}` },
+            cmd: (b, launcher) => ({ file: b, args: ["mcp", "add", "-s", "user", "yt-mcp", "--", launcher.command, ...launcher.args] }) },
         { bin: "claude", label: "Claude Code",
-            cmd: (b, a) => `${b} mcp add -s user yt-mcp -- ${a}` },
+            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, a) => `${b} mcp add yt-mcp -- ${a}` },
+            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, a) => `${b} mcp add -s user yt-mcp ${a}` },
+            cmd: (b, launcher) => ({ file: b, args: ["mcp", "add", "-s", "user", "yt-mcp", launcher.command, ...launcher.args] }) },
         { bin: "gemini", label: "Gemini CLI",
-            cmd: (b, a) => `${b} mcp add -s user yt-mcp ${a}` },
+            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, a) => `${b} mcp add yt-mcp -- ${a}` },
-        { bin: "openclaw", label: "OpenClaw",
-            cmd: (b, a) => `${b} mcp add yt-mcp -- ${a}` },
+            cmd: (b, launcher) => ({ file: b, args: ["mcp", "add", "yt-mcp", "--", launcher.command, ...launcher.args] }) },
     ];
     for (const { bin, label, cmd } of cliCandidates) {
         if (!detectCli(bin))
             continue;
-        const command = cmd(bin, mcpArgs);
+        const command = cmd(bin, launcherCommand);
         if (!command) {
             // CLI detected but doesn't support auto-registration
             console.log(`  ⚠️  ${label} detected but requires manual MCP config.`);
@@ -291,6 +259,17 @@ export async function runSetup() {
             registered = true;
         }
     }
+    if (isOpenClawInstallLikelyInstalled(detectCli)) {
+        try {
+            const status = writeOpenClawConfig("yt-mcp", launcherCommand);
+            const suffix = status === "created" ? "created" : "updated";
+            console.log(`  ✅ MCP registered in OpenClaw (${suffix} mcporter.json)`);
+            registered = true;
+        }
+        catch (err) {
+            console.log(`  ⚠️  OpenClaw auto-register failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     if (!registered) {
         console.log("  ℹ️  No supported CLI found. Add manually to your AI client:");
     }
@@ -307,6 +286,26 @@ export async function runSetup() {
     }
   }
 `);
+    console.log(`  OpenClaw mcporter config: ${getOpenClawConfigPath()}`);
+    console.log("  OpenClaw manual config:");
+    console.log(`
+  {
+    "servers": {
+      "yt-mcp": {
+        "transport": "stdio",
+        "command": "node",
+        "args": [${JSON.stringify(PATHS.launcherJs)}, "serve"]
+      }
+    }
+  }
+`);
+    console.log(`  OpenClaw uses ${PATHS.sharedAuthJson} for PAT/JWT, so env.YT_MCP_TOKEN is optional after setup.`);
+    console.log("  Media downloads:");
+    console.log("  - `start_download_job` / `poll_download_job` are job-based local tools");
+    console.log("  - Batch limit: 5 YouTube videos per job");
+    console.log("  - Output path: ~/Downloads/yt-mcp/YYYY-MM-DD_<video_id>");
+    console.log("  - `ffmpeg` is required for video download modes");
+    console.log("");
     console.log("✅ Setup complete!");
     if (hasBrowser) {
         console.log('   Open your AI client and try: "搜索 Python 教程"');

package/dist/cli/setupCookies.js

@@ -104,7 +104,7 @@ export async function runSetupCookies() {
         chromium = pw.chromium;
     }
     catch {
-        throw new Error("Playwright is not installed.\nRun: npm install playwright");
+        throw new Error("Playwright runtime is not installed.\nRun: yt-mcp runtime install");
     }
     const channel = await detectBrowserChannel(chromium);
     console.log(`Using browser: ${CHANNEL_LABELS[channel] ?? channel}`);
@@ -123,7 +123,7 @@ export async function runSetupCookies() {
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         if (channel === "chromium" && msg.includes("Executable doesn't exist")) {
-            throw new Error("Chromium browser not found.\nRun: npx playwright install chromium");
+            throw new Error("Chromium browser runtime not found.\nRun: yt-mcp runtime install");
         }
         throw err;
     }

package/dist/cli/smoke.d.ts

@@ -0,0 +1,27 @@
+export interface SmokeOptions {
+    subtitles: boolean;
+}
+export interface SmokeSummary {
+    remote: {
+        video_id: string;
+        title: string;
+    };
+    subtitles?: {
+        valid: true;
+    };
+}
+interface SmokeClient {
+    listTools(): Promise<{
+        tools: Array<{
+            name: string;
+        }>;
+    }>;
+    callTool(params: {
+        name: string;
+        arguments: Record<string, unknown>;
+    }): Promise<Record<string, unknown>>;
+}
+export declare function parseSmokeArgs(argv: string[]): SmokeOptions;
+export declare function runSmokeChecks(client: SmokeClient, options: SmokeOptions): Promise<SmokeSummary>;
+export declare function runSmoke(argv: string[]): Promise<void>;
+export {};

package/dist/cli/smoke.js

@@ -0,0 +1,108 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+function toSmokeToolResult(value) {
+    return value;
+}
+export function parseSmokeArgs(argv) {
+    return {
+        subtitles: argv.includes("--subtitles"),
+    };
+}
+function extractPayload(result) {
+    if (result.structuredContent && typeof result.structuredContent === "object") {
+        return result.structuredContent;
+    }
+    const text = result.content?.find((item) => item.type === "text" && typeof item.text === "string")?.text;
+    if (!text) {
+        throw new Error("Tool returned no readable payload");
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new Error(`Tool returned non-JSON text: ${text.slice(0, 200)}`);
+    }
+}
+function requireTool(tools, name) {
+    if (!tools.some((tool) => tool.name === name)) {
+        throw new Error(`Required tool not registered: ${name}`);
+    }
+}
+export async function runSmokeChecks(client, options) {
+    const listed = await client.listTools();
+    requireTool(listed.tools, "search_videos");
+    if (options.subtitles) {
+        requireTool(listed.tools, "validate_cookies");
+    }
+    const remoteResult = await client.callTool({
+        name: "search_videos",
+        arguments: { query: "OpenAI", max_results: 1 },
+    });
+    const remotePayload = extractPayload(remoteResult);
+    const remoteItems = Array.isArray(remotePayload.items) ? remotePayload.items : [];
+    const firstItem = remoteItems[0];
+    if (!firstItem || typeof firstItem !== "object") {
+        throw new Error("Remote smoke returned no videos");
+    }
+    const videoId = typeof firstItem.video_id === "string" ? firstItem.video_id : null;
+    const title = typeof firstItem.title === "string" ? firstItem.title : null;
+    if (!videoId || !title) {
+        throw new Error("Remote smoke returned malformed video data");
+    }
+    const summary = {
+        remote: {
+            video_id: videoId,
+            title,
+        },
+    };
+    if (options.subtitles) {
+        const subtitleResult = await client.callTool({
+            name: "validate_cookies",
+            arguments: {},
+        });
+        const subtitlePayload = extractPayload(subtitleResult);
+        if (subtitlePayload.valid !== true) {
+            const error = typeof subtitlePayload.error === "string"
+                ? subtitlePayload.error
+                : "Subtitle validation failed";
+            throw new Error(error);
+        }
+        summary.subtitles = { valid: true };
+    }
+    return summary;
+}
+export async function runSmoke(argv) {
+    const options = parseSmokeArgs(argv);
+    const stderrChunks = [];
+    const transport = new StdioClientTransport({
+        command: process.execPath,
+        args: [process.argv[1], "serve"],
+        stderr: "pipe",
+        env: Object.fromEntries(Object.entries(process.env).filter((entry) => typeof entry[1] === "string")),
+    });
+    if (transport.stderr) {
+        transport.stderr.on("data", (chunk) => {
+            stderrChunks.push(String(chunk));
+        });
+    }
+    const client = new Client({ name: "yt-mcp-smoke", version: "1.0.0" }, { capabilities: {} });
+    try {
+        await client.connect(transport);
+        const summary = await runSmokeChecks({
+            listTools: () => client.listTools(),
+            callTool: async (params) => toSmokeToolResult(await client.callTool(params)),
+        }, options);
+        console.log(`✅ MCP smoke passed: ${summary.remote.video_id} — ${summary.remote.title}`);
+        if (summary.subtitles?.valid) {
+            console.log("✅ Subtitle smoke passed via validate_cookies");
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const stderr = stderrChunks.join("").trim();
+        throw new Error(stderr ? `${message}\n${stderr}` : message);
+    }
+    finally {
+        await transport.close().catch(() => undefined);
+    }
+}

package/dist/cli/uninstall.d.ts

@@ -0,0 +1 @@
+export declare function runUninstall(): Promise<void>;

package/dist/cli/uninstall.js

@@ -0,0 +1,67 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, rmSync } from "node:fs";
+import { PATHS } from "../utils/config.js";
+import { getOpenClawConfigPath, removeOpenClawConfig } from "../utils/openClaw.js";
+function detectCli(name) {
+    try {
+        execFileSync(name, ["--version"], { stdio: "pipe" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function tryRemoveMcp(command, label) {
+    try {
+        execFileSync(command.file, command.args, { stdio: "pipe" });
+        console.log(`  ✅ Removed MCP registration from ${label}`);
+        return "removed";
+    }
+    catch (err) {
+        const details = err && typeof err === "object" && "stderr" in err
+            ? String(err.stderr ?? "")
+            : "";
+        const lower = details.toLowerCase();
+        if (lower.includes("not found") || lower.includes("no server") || lower.includes("unknown")) {
+            console.log(`  ℹ️  ${label} did not have yt-mcp registered`);
+            return "missing";
+        }
+        console.log(`  ⚠️  Failed to remove MCP registration from ${label}`);
+        return "failed";
+    }
+}
+export async function runUninstall() {
+    console.log("\n🧹 yt-mcp uninstall\n");
+    console.log("Removing MCP client registrations...");
+    const cliCandidates = [
+        { 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"] } },
+        { bin: "gemini-internal", label: "Gemini CLI (internal)", command: { file: "gemini-internal", args: ["mcp", "remove", "-s", "user", "yt-mcp"] } },
+        { 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)
+            continue;
+        tryRemoveMcp(candidate.command, candidate.label);
+    }
+    const openClawStatus = removeOpenClawConfig("yt-mcp");
+    if (openClawStatus === "removed") {
+        console.log(`  ✅ Removed MCP registration from OpenClaw (${getOpenClawConfigPath()})`);
+    }
+    else {
+        console.log("  ℹ️  OpenClaw 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 });
+        console.log(`  ✅ Removed local yt-mcp config: ${PATHS.configDir}`);
+    }
+    else {
+        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");
+    console.log("");
+}

package/dist/download/downloader.d.ts

@@ -0,0 +1,64 @@
+import type { DownloadJobManager } from "./jobManager.js";
+import type { DownloadJobItemSnapshot, DownloadMode } from "./types.js";
+import type { PreflightVideoMetadata } from "../utils/videoMetadata.js";
+type DownloadingStep = "download_video" | "download_subtitles" | "merge";
+export interface DownloadOneItemProgressUpdate {
+    step: DownloadingStep;
+    progressPercent: number | null;
+}
+export interface DownloadOneItemResult {
+    video_file: string | null;
+    metadata_file: string;
+    final_file_size: string | null;
+    subtitle_files: Record<string, string[]>;
+    metadata: PreflightVideoMetadata;
+}
+export interface DownloadOneItemInput {
+    item: Pick<DownloadJobItemSnapshot, "video_id" | "source_url" | "title" | "output_dir">;
+    mode: DownloadMode;
+    videoQuality?: string | null;
+    subtitleFormats: string[];
+    subtitleLanguages?: string[];
+    defaultSubtitleLanguages?: string[];
+    jobManager?: Pick<DownloadJobManager, "startItem" | "updateItemProgress" | "completeItem" | "failItem">;
+    jobId?: string;
+    deps?: Partial<DownloadOneItemDeps>;
+}
+interface DownloadOneItemDeps {
+    hasYtDlp: () => boolean;
+    hasFfmpeg: () => boolean;
+    fetchMetadata: (input: {
+        sourceUrl: string;
+        videoId: string;
+        title: string;
+    }) => Promise<PreflightVideoMetadata>;
+    downloadVideo: (input: {
+        sourceUrl: string;
+        outputFile: string;
+        videoQuality: string;
+        onProgress: (update: DownloadOneItemProgressUpdate) => void;
+    }) => Promise<string>;
+    downloadSubtitles: (input: {
+        videoId: string;
+        sourceUrl: string;
+        subtitlesDir: string;
+        formats: string[];
+        languages: string[];
+        skipMissingLanguages: boolean;
+        onProgress: (update: DownloadOneItemProgressUpdate) => void;
+    }) => Promise<Record<string, string[]>>;
+    mkdir: (path: string, options: {
+        recursive: true;
+    }) => Promise<void>;
+    rm: (path: string, options: {
+        recursive: true;
+        force: true;
+    }) => Promise<void>;
+    stat: (path: string) => Promise<{
+        size: number;
+    }>;
+    writeMetadata: (path: string, contents: string) => Promise<void>;
+}
+export declare function downloadOneItem(input: DownloadOneItemInput): Promise<DownloadOneItemResult>;
+export declare function resolveYtDlpOutputPath(expectedPath: string, stdout: string): string;
+export {};