@mkterswingman/5mghost-yonder 0.0.1

package/dist/tools/remote.js

@@ -0,0 +1,230 @@
+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: "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

@@ -0,0 +1,4 @@
+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 registerSubtitleTools(server: McpServer, config: YtMcpConfig, tokenManager: TokenManager): void;