@mkterswingman/5mghost-yonder 0.0.26 → 0.0.27

package/dist/tools/downloads.js

@@ -1,220 +0,0 @@
-import { z } from "zod";
-import { MEDIA_ROOT_DIR } from "../utils/config.js";
-import { downloadOneItem } from "../download/downloader.js";
-import { buildMediaOutputPaths } from "../utils/mediaPaths.js";
-import { resolveVideoInput } from "../utils/videoInput.js";
-const AUTH_REQUIRED_MSG = "❌ 未认证。请先登录：\n• OAuth: npx @mkterswingman/5mghost-yonder setup\n• PAT: 设置环境变量 YT_MCP_TOKEN 或在 https://mkterswingman.com/pat/login 生成 token";
-const DOWNLOAD_MODES = ["video", "subtitles", "both"];
-const VIDEO_QUALITIES = ["1080p", "max"];
-const SUBTITLE_FORMATS = ["vtt", "srt", "ttml", "srv3", "csv"];
-const MAX_DOWNLOAD_VIDEOS = 5;
-class DownloadToolError extends Error {
-    code;
-    constructor(code, message) {
-        super(message);
-        this.code = code;
-        this.name = "DownloadToolError";
-    }
-}
-function toolOk(payload) {
-    return {
-        structuredContent: payload,
-        content: [
-            {
-                type: "text",
-                text: JSON.stringify(payload),
-            },
-        ],
-    };
-}
-function toolErr(code, message) {
-    const payload = { status: "failed", error: { code, message } };
-    return {
-        structuredContent: payload,
-        isError: true,
-        content: [{ type: "text", text: JSON.stringify(payload) }],
-    };
-}
-function todayDateStr() {
-    const d = new Date();
-    const yyyy = d.getFullYear();
-    const mm = String(d.getMonth() + 1).padStart(2, "0");
-    const dd = String(d.getDate()).padStart(2, "0");
-    return `${yyyy}-${mm}-${dd}`;
-}
-function dedupeValues(values) {
-    return values == null ? undefined : [...new Set(values)];
-}
-function toSourceUrl(input, videoId) {
-    const trimmed = input.trim();
-    if (/^https?:\/\//u.test(trimmed)) {
-        return trimmed;
-    }
-    return `https://www.youtube.com/watch?v=${videoId}`;
-}
-function normalizeSubtitleFormats(mode, subtitleFormats) {
-    if (mode === "video") {
-        return [];
-    }
-    const normalized = dedupeValues(subtitleFormats) ?? ["srt"];
-    if (normalized.length === 0) {
-        throw new DownloadToolError("INVALID_INPUT", "subtitle_formats must include at least one format when mode includes subtitles");
-    }
-    return normalized;
-}
-function buildJobInput(videos, mode, videoQuality, subtitleFormats, deps) {
-    const invalidInputs = [];
-    const resolvedVideos = [];
-    const seenIds = new Set();
-    const dateStr = deps.nowDate?.() ?? todayDateStr();
-    const mediaRootDir = deps.mediaRootDir ?? MEDIA_ROOT_DIR;
-    for (const rawInput of videos) {
-        const videoId = resolveVideoInput(rawInput);
-        if (!videoId) {
-            invalidInputs.push(rawInput);
-            continue;
-        }
-        if (seenIds.has(videoId)) {
-            continue;
-        }
-        seenIds.add(videoId);
-        resolvedVideos.push({
-            video_id: videoId,
-            // Why: yt-dlp should keep the original URL when the user passed one so polls reflect the submitted source.
-            source_url: toSourceUrl(rawInput, videoId),
-            title: videoId,
-            output_dir: buildMediaOutputPaths(mediaRootDir, dateStr, videoId).outputDir,
-        });
-    }
-    if (resolvedVideos.length === 0) {
-        throw new DownloadToolError("INVALID_INPUT", `无法解析任何视频 ID。无效输入: ${invalidInputs.join(", ")}`);
-    }
-    return {
-        jobInput: {
-            videos: resolvedVideos,
-            mode,
-            video_quality: mode === "subtitles" ? undefined : videoQuality,
-            subtitle_formats: normalizeSubtitleFormats(mode, subtitleFormats),
-        },
-        invalidInputs,
-    };
-}
-async function runDownloadJob(manager, snapshot, subtitleLanguages, defaultSubtitleLanguages, deps) {
-    const executeItem = deps.executeItem ?? downloadOneItem;
-    for (const item of snapshot.items) {
-        try {
-            await executeItem({
-                jobManager: manager,
-                jobId: snapshot.job_id,
-                item,
-                mode: snapshot.mode,
-                videoQuality: snapshot.video_quality,
-                subtitleFormats: snapshot.subtitle_formats,
-                subtitleLanguages,
-                defaultSubtitleLanguages,
-            });
-        }
-        catch {
-            // downloadOneItem already records per-item failures in the manager.
-        }
-    }
-    const latest = manager.pollJob(snapshot.job_id);
-    if (latest.status !== "completed" && latest.status !== "failed") {
-        const stalledItems = latest.items.filter((item) => item.status === "queued");
-        for (const item of stalledItems) {
-            manager.failItem(snapshot.job_id, item.video_id, "Download job stopped before this item started");
-        }
-    }
-}
-export function registerDownloadTools(server, config, tokenManager, manager, deps = {}) {
-    const pendingJobs = [];
-    let draining = false;
-    async function requireAuth() {
-        const token = await tokenManager.getValidToken();
-        if (!token)
-            return AUTH_REQUIRED_MSG;
-        return null;
-    }
-    async function drainQueue() {
-        if (draining) {
-            return;
-        }
-        draining = true;
-        try {
-            while (pendingJobs.length > 0) {
-                const nextJob = pendingJobs.shift();
-                if (!nextJob) {
-                    continue;
-                }
-                await runDownloadJob(manager, nextJob.snapshot, nextJob.subtitleLanguages, nextJob.defaultSubtitleLanguages, deps);
-            }
-        }
-        finally {
-            draining = false;
-            if (pendingJobs.length > 0) {
-                void drainQueue();
-            }
-        }
-    }
-    function enqueueDownloadJob(snapshot, subtitleLanguages, defaultSubtitleLanguages) {
-        pendingJobs.push({
-            snapshot,
-            subtitleLanguages,
-            defaultSubtitleLanguages,
-        });
-        void drainQueue();
-    }
-    server.registerTool("start_download_job", {
-        description: "Start a local media download job for up to 5 YouTube videos. Supports video, subtitles, or both and returns a job snapshot for polling.",
-        inputSchema: {
-            videos: z.array(z.string().min(1)).min(1).max(MAX_DOWNLOAD_VIDEOS),
-            mode: z.enum(DOWNLOAD_MODES).optional(),
-            video_quality: z.enum(VIDEO_QUALITIES).optional(),
-            subtitle_formats: z.array(z.enum(SUBTITLE_FORMATS)).min(1).optional(),
-            subtitle_languages: z.array(z.string().min(1)).min(1).optional(),
-        },
-    }, async ({ videos, mode, video_quality, subtitle_formats, subtitle_languages }) => {
-        const authErr = await requireAuth();
-        if (authErr)
-            return toolErr("AUTH_REQUIRED", authErr);
-        if (!Array.isArray(videos) || videos.length === 0) {
-            return toolErr("INVALID_INPUT", "videos must include at least one input");
-        }
-        try {
-            const resolvedMode = mode ?? "both";
-            const { jobInput, invalidInputs } = buildJobInput(videos, resolvedMode, video_quality, subtitle_formats, deps);
-            const snapshot = manager.createJob(jobInput);
-            enqueueDownloadJob(snapshot, dedupeValues(subtitle_languages), resolvedMode === "video" ? undefined : [...config.default_languages]);
-            const queuedSnapshot = manager.pollJob(snapshot.job_id);
-            return toolOk({
-                ...queuedSnapshot,
-                invalid_inputs: invalidInputs.length > 0 ? invalidInputs : undefined,
-            });
-        }
-        catch (error) {
-            if (error instanceof DownloadToolError) {
-                return toolErr(error.code, error.message);
-            }
-            return toolErr("INTERNAL_ERROR", error instanceof Error ? error.message : String(error));
-        }
-    });
-    server.registerTool("poll_download_job", {
-        description: "Poll a local media download job and return the current whole-job snapshot.",
-        inputSchema: {
-            job_id: z.string().min(1),
-        },
-    }, async ({ job_id }) => {
-        const authErr = await requireAuth();
-        if (authErr)
-            return toolErr("AUTH_REQUIRED", authErr);
-        if (!job_id) {
-            return toolErr("INVALID_INPUT", "job_id is required");
-        }
-        try {
-            return toolOk(manager.pollJob(job_id));
-        }
-        catch (error) {
-            return toolErr("JOB_NOT_FOUND", error instanceof Error ? error.message : String(error));
-        }
-    });
-}

package/dist/tools/remote.d.ts

@@ -1,4 +0,0 @@
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { YtMcpConfig } from "../utils/config.js";
-import type { TokenManager } from "../auth/tokenManager.js";
-export declare function registerRemoteTools(server: McpServer, config: YtMcpConfig, tokenManager: TokenManager): void;

package/dist/tools/remote.js

@@ -1,239 +0,0 @@
-import { z } from "zod";
-function toolErr(code, message) {
-    const payload = { status: "failed", error: { code, message } };
-    return {
-        structuredContent: payload,
-        isError: true,
-        content: [{ type: "text", text: JSON.stringify(payload) }],
-    };
-}
-function createRemoteTool(server, def, tokenManager, apiUrl) {
-    server.registerTool(def.name, {
-        description: def.description,
-        inputSchema: def.schema,
-    }, async (params) => {
-        const token = await tokenManager.getValidToken();
-        if (!token) {
-            return toolErr("AUTH_EXPIRED", "请重新运行 npx @mkterswingman/5mghost-yonder setup");
-        }
-        let res;
-        try {
-            const method = def.method ?? "POST";
-            const url = new URL(`${apiUrl}/${def.remotePath}`);
-            const headers = {
-                Authorization: `Bearer ${token}`,
-            };
-            const fetchOptions = { method, headers };
-            if (method === "GET") {
-                // For GET requests, pass params as query string
-                for (const [key, value] of Object.entries(params)) {
-                    if (value !== undefined && value !== null) {
-                        url.searchParams.set(key, String(value));
-                    }
-                }
-            }
-            else {
-                headers["Content-Type"] = "application/json";
-                fetchOptions.body = JSON.stringify(params);
-            }
-            res = await fetch(url.toString(), fetchOptions);
-        }
-        catch (err) {
-            return toolErr("REMOTE_ERROR", `Network error: ${err instanceof Error ? err.message : String(err)}`);
-        }
-        if (res.status === 401) {
-            return toolErr("AUTH_EXPIRED", "Token 已过期");
-        }
-        if (!res.ok) {
-            const text = await res.text().catch(() => "");
-            return toolErr("REMOTE_ERROR", `服务端错误 ${res.status}: ${text.slice(0, 200)}`);
-        }
-        try {
-            const body = (await res.json());
-            // If the remote already returns MCP-shaped content, pass through
-            if (body.content && Array.isArray(body.content)) {
-                return body;
-            }
-            // Otherwise wrap it
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify(body),
-                    },
-                ],
-            };
-        }
-        catch {
-            return toolErr("REMOTE_ERROR", "服务端返回了非 JSON 内容");
-        }
-    });
-}
-const REMOTE_TOOLS = [
-    {
-        name: "search_videos",
-        description: "Search YouTube videos by keyword. Supports up to 300 results.",
-        schema: {
-            query: z.string().min(1),
-            max_results: z.number().int().min(1).max(300).optional(),
-            order: z
-                .enum([
-                "date",
-                "rating",
-                "relevance",
-                "title",
-                "videoCount",
-                "viewCount",
-            ])
-                .optional(),
-        },
-        remotePath: "api/search",
-    },
-    {
-        name: "get_video_stats",
-        description: "Get YouTube video stats in one request. Accepts up to 1000 video IDs/URLs.",
-        schema: {
-            videos: z.array(z.string().min(1)).min(1).max(1000),
-        },
-        remotePath: "api/video-stats/bulk",
-    },
-    {
-        name: "start_video_stats_job",
-        description: "Start an async YouTube video stats job. Accepts up to 1000 items.",
-        schema: {
-            videos: z.array(z.string().min(1)).min(1).max(1000),
-        },
-        remotePath: "api/video-stats/job/start",
-    },
-    {
-        name: "poll_video_stats_job",
-        description: "Poll job progress and get partial/final results for a job_id.",
-        schema: {
-            job_id: z.string().min(1),
-        },
-        remotePath: "api/video-stats/job/poll",
-    },
-    {
-        name: "resume_video_stats_job",
-        description: "Resume a previously partial job with a resume_token.",
-        schema: {
-            resume_token: z.string().min(1),
-        },
-        remotePath: "api/video-stats/job/resume",
-    },
-    {
-        name: "get_trending",
-        description: "Get official YouTube mostPopular videos. Supports region/category filters.",
-        schema: {
-            region_code: z
-                .string()
-                .regex(/^[A-Za-z]{2}$/)
-                .optional(),
-            category_id: z.string().min(1).max(64).optional(),
-            max_results: z.number().int().min(1).max(300).optional(),
-        },
-        remotePath: "api/trending",
-    },
-    {
-        name: "search_channels",
-        description: "Search YouTube channels by keyword for candidate discovery.",
-        schema: {
-            query: z.string().min(1).max(200),
-            max_results: z.number().int().min(1).max(50).optional(),
-        },
-        remotePath: "api/channel/search",
-    },
-    {
-        name: "get_channel_stats",
-        description: "Get YouTube channel statistics for up to 50 channel inputs.",
-        schema: {
-            channels: z.array(z.string().min(1)).min(1).max(50).optional(),
-            channel_ids: z.array(z.string().min(1)).min(1).max(50).optional(),
-        },
-        remotePath: "api/channel/stats",
-    },
-    {
-        name: "list_channel_uploads",
-        description: "List videos uploaded by a YouTube channel. Supports up to 1000 results.",
-        schema: {
-            channel: z.string().min(1).optional(),
-            channel_id: z.string().min(1).optional(),
-            max_results: z.number().int().min(1).max(1000).optional(),
-        },
-        remotePath: "api/channel/uploads",
-    },
-    {
-        name: "get_comments",
-        description: "Get comments for one YouTube video. max_comments up to 1000.",
-        schema: {
-            video: z.string().min(1),
-            max_comments: z.number().int().min(1).max(1000).optional(),
-            order: z.enum(["time", "relevance"]).optional(),
-            include_replies_preview: z.boolean().optional(),
-            replies_preview_per_comment: z.number().int().min(1).max(5).optional(),
-            replies_preview_parent_limit: z.number().int().min(1).max(25).optional(),
-        },
-        remotePath: "api/comments/sync",
-    },
-    {
-        name: "start_comments_job",
-        description: "Start a comments export job for one YouTube video.",
-        schema: {
-            video: z.string().min(1),
-            max_comments: z.number().int().min(1).max(1000).optional(),
-            order: z.enum(["time", "relevance"]).optional(),
-        },
-        remotePath: "api/comments/start",
-    },
-    {
-        name: "poll_comments_job",
-        description: "Check comments export job progress by job_id.",
-        schema: {
-            job_id: z.string().min(1),
-        },
-        remotePath: "api/comments/poll",
-    },
-    {
-        name: "resume_comments_job",
-        description: "Resume an unfinished comments export job.",
-        schema: {
-            resume_token: z.string().min(1),
-        },
-        remotePath: "api/comments/resume",
-    },
-    {
-        name: "get_comment_replies",
-        description: "Get 2nd-level replies for one top-level comment.",
-        schema: {
-            parent_comment_id: z.string().min(1),
-            max_results: z.number().int().min(1).max(1000).optional(),
-            page_token: z.string().min(1).optional(),
-        },
-        remotePath: "api/comments/replies",
-    },
-    {
-        name: "get_quota_usage",
-        description: "Get YouTube API quota usage for today or a specific date.",
-        schema: {
-            date: z
-                .string()
-                .regex(/^\d{4}-\d{2}-\d{2}$/)
-                .optional(),
-        },
-        remotePath: "api/quota",
-    },
-    {
-        name: "get_patch_notes",
-        description: "Read server patch notes for latest MCP/API updates.",
-        schema: {
-            max_chars: z.number().int().min(500).max(50_000).optional(),
-        },
-        remotePath: "api/patch-notes",
-        method: "GET",
-    },
-];
-export function registerRemoteTools(server, config, tokenManager) {
-    for (const def of REMOTE_TOOLS) {
-        createRemoteTool(server, def, tokenManager, config.api_url);
-    }
-}

package/dist/tools/subtitles.d.ts

@@ -1,29 +0,0 @@
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { YtMcpConfig } from "../utils/config.js";
-import type { TokenManager } from "../auth/tokenManager.js";
-export declare function toReadableSubtitleJobError(error: unknown): string;
-/**
- * Convert VTT subtitle content to clean, human-readable CSV.
- *
- * YouTube auto-captions use a "rolling" VTT format where each cue has two
- * lines: the first line repeats the previous cue's text, and the second line
- * contains new words (marked with <c> tags for word-level timing). This
- * function detects and handles this pattern:
- *
- * 1. Detects auto-caption format (presence of <c> word-timing tags)
- * 2. For auto-captions: extracts only the NEW text from each cue's second
- *    line, skips transition cues, and concatenates into clean sentences
- * 3. For manual subtitles: passes through cleanly with no data loss
- * 4. Outputs: start_time, end_time, text
- */
-export declare function vttToCsv(vtt: string): string;
-export declare function downloadSubtitlesForLanguages(input: {
-    videoId: string;
-    sourceUrl?: string;
-    languages: string[];
-    formats: string[];
-    subtitlesDir: string;
-    skipMissingLanguages?: boolean;
-    onProgress?: (completed: number, total: number) => void;
-}): Promise<Record<string, string[]>>;
-export declare function registerSubtitleTools(server: McpServer, config: YtMcpConfig, tokenManager: TokenManager): void;