youtube-data-cli 0.0.1

package/dist/auth.js

@@ -0,0 +1,72 @@
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+const DEFAULT_PATH = join(homedir(), ".config", "youtube-data-cli", "credentials.json");
+export function loadCredentials(credentialsPath) {
+    // 1. --credentials flag
+    if (credentialsPath) {
+        return readJSON(credentialsPath);
+    }
+    // 2. Environment variables
+    const envCreds = {};
+    if (process.env.YOUTUBE_API_KEY)
+        envCreds.api_key = process.env.YOUTUBE_API_KEY;
+    if (process.env.YOUTUBE_CLIENT_ID)
+        envCreds.client_id = process.env.YOUTUBE_CLIENT_ID;
+    if (process.env.YOUTUBE_CLIENT_SECRET)
+        envCreds.client_secret = process.env.YOUTUBE_CLIENT_SECRET;
+    if (process.env.YOUTUBE_REFRESH_TOKEN)
+        envCreds.refresh_token = process.env.YOUTUBE_REFRESH_TOKEN;
+    if (Object.keys(envCreds).length > 0) {
+        return envCreds;
+    }
+    // 3. Default credentials file
+    if (existsSync(DEFAULT_PATH)) {
+        return readJSON(DEFAULT_PATH);
+    }
+    throw new Error(`No credentials found. Provide one of:\n` +
+        `  1. --credentials <path> flag\n` +
+        `  2. YOUTUBE_API_KEY and/or YOUTUBE_CLIENT_ID, YOUTUBE_CLIENT_SECRET, YOUTUBE_REFRESH_TOKEN env vars\n` +
+        `  3. ${DEFAULT_PATH}`);
+}
+function readJSON(path) {
+    const raw = readFileSync(path, "utf-8");
+    const data = JSON.parse(raw);
+    if (typeof data !== "object" || data === null || Array.isArray(data)) {
+        throw new Error(`credentials file must be a JSON object: ${path}`);
+    }
+    if (!data.api_key && !data.client_id) {
+        throw new Error(`credentials file must contain at least "api_key" or "client_id": ${path}`);
+    }
+    return data;
+}
+let cachedAccessToken = null;
+export async function getAccessToken(creds) {
+    if (!creds.client_id || !creds.client_secret || !creds.refresh_token) {
+        throw new Error("OAuth credentials required (client_id, client_secret, refresh_token). " +
+            "API key alone is not sufficient for this command.");
+    }
+    // Return cached token if still valid (with 60s buffer)
+    if (cachedAccessToken && Date.now() < cachedAccessToken.expiresAt - 60_000) {
+        return cachedAccessToken.token;
+    }
+    const res = await fetch("https://oauth2.googleapis.com/token", {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({
+            client_id: creds.client_id,
+            client_secret: creds.client_secret,
+            refresh_token: creds.refresh_token,
+            grant_type: "refresh_token",
+        }),
+    });
+    const json = (await res.json());
+    if (!res.ok || !json.access_token) {
+        throw new Error(json.error_description ?? json.error ?? `Token refresh failed: HTTP ${res.status}`);
+    }
+    cachedAccessToken = {
+        token: json.access_token,
+        expiresAt: Date.now() + (json.expires_in ?? 3600) * 1000,
+    };
+    return json.access_token;
+}

package/dist/commands/channels.js

@@ -0,0 +1,29 @@
+import { loadCredentials } from "../auth.js";
+import { callApi } from "../api.js";
+import { output, fatal } from "../utils.js";
+export function registerChannelCommands(program) {
+    program
+        .command("channels [channel-id]")
+        .description("Get channel details (omit ID for authenticated user's channel)")
+        .option("--part <parts>", "Parts to include", "snippet,statistics,contentDetails")
+        .action(async (channelId, opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const params = {
+                part: opts.part,
+            };
+            const requireOAuth = !channelId;
+            if (channelId) {
+                params.id = channelId;
+            }
+            else {
+                params.mine = "true";
+            }
+            const data = await callApi("/channels", { creds, params, requireOAuth });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+}

package/dist/commands/comment-threads.js

@@ -0,0 +1,73 @@
+import { loadCredentials } from "../auth.js";
+import { callApi } from "../api.js";
+import { output, fatal } from "../utils.js";
+export function registerCommentThreadCommands(program) {
+    program
+        .command("comment-threads")
+        .description("List comment threads for a video, channel, or by ID")
+        .option("--video-id <id>", "Video ID to list comments for")
+        .option("--channel-id <id>", "Channel ID to list comments for")
+        .option("--id <id>", "Comment thread ID(s), comma-separated")
+        .option("--part <parts>", "Parts to include", "snippet,replies")
+        .option("--max-results <n>", "Max results (1-100)", "20")
+        .option("--page-token <token>", "Pagination token")
+        .option("--order <order>", "Sort order (time, relevance)", "relevance")
+        .option("--search-terms <q>", "Filter by search terms")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const params = {
+                part: opts.part,
+                maxResults: opts.maxResults,
+                order: opts.order,
+            };
+            if (opts.videoId)
+                params.videoId = opts.videoId;
+            else if (opts.channelId)
+                params.channelId = opts.channelId;
+            else if (opts.id)
+                params.id = opts.id;
+            else {
+                fatal("One of --video-id, --channel-id, or --id is required.");
+            }
+            if (opts.pageToken)
+                params.pageToken = opts.pageToken;
+            if (opts.searchTerms)
+                params.searchTerms = opts.searchTerms;
+            const data = await callApi("/commentThreads", { creds, params });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+    program
+        .command("comment-threads-insert")
+        .description("Post a top-level comment on a video (OAuth required)")
+        .requiredOption("--video-id <id>", "Video ID to comment on")
+        .requiredOption("--text <text>", "Comment text")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const data = await callApi("/commentThreads", {
+                creds,
+                params: { part: "snippet" },
+                method: "POST",
+                body: {
+                    snippet: {
+                        videoId: opts.videoId,
+                        topLevelComment: {
+                            snippet: {
+                                textOriginal: opts.text,
+                            },
+                        },
+                    },
+                },
+            });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+}

package/dist/commands/comments.js

@@ -0,0 +1,97 @@
+import { loadCredentials } from "../auth.js";
+import { callApi } from "../api.js";
+import { output, fatal } from "../utils.js";
+export function registerCommentCommands(program) {
+    program
+        .command("comments")
+        .description("List replies to a comment thread")
+        .requiredOption("--parent-id <id>", "Parent comment ID to list replies for")
+        .option("--part <parts>", "Parts to include", "snippet")
+        .option("--max-results <n>", "Max results (1-100)", "20")
+        .option("--page-token <token>", "Pagination token")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const params = {
+                part: opts.part,
+                parentId: opts.parentId,
+                maxResults: opts.maxResults,
+            };
+            if (opts.pageToken)
+                params.pageToken = opts.pageToken;
+            const data = await callApi("/comments", { creds, params });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+    program
+        .command("comments-insert")
+        .description("Reply to a comment (OAuth required)")
+        .requiredOption("--parent-id <id>", "Parent comment ID to reply to")
+        .requiredOption("--text <text>", "Reply text")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const data = await callApi("/comments", {
+                creds,
+                params: { part: "snippet" },
+                method: "POST",
+                body: {
+                    snippet: {
+                        parentId: opts.parentId,
+                        textOriginal: opts.text,
+                    },
+                },
+            });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+    program
+        .command("comments-update")
+        .description("Update a comment (OAuth required)")
+        .requiredOption("--id <id>", "Comment ID")
+        .requiredOption("--text <text>", "Updated comment text")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const data = await callApi("/comments", {
+                creds,
+                params: { part: "snippet" },
+                method: "PUT",
+                body: {
+                    id: opts.id,
+                    snippet: {
+                        textOriginal: opts.text,
+                    },
+                },
+            });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+    program
+        .command("comments-delete")
+        .description("Delete a comment (OAuth required)")
+        .requiredOption("--id <id>", "Comment ID")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const data = await callApi("/comments", {
+                creds,
+                params: { id: opts.id },
+                method: "DELETE",
+            });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+}

package/dist/commands/playlist-items.js

@@ -0,0 +1,113 @@
+import { loadCredentials } from "../auth.js";
+import { callApi } from "../api.js";
+import { output, fatal } from "../utils.js";
+export function registerPlaylistItemCommands(program) {
+    program
+        .command("playlist-items")
+        .description("List items in a playlist")
+        .requiredOption("--playlist-id <id>", "Playlist ID")
+        .option("--part <parts>", "Parts to include", "snippet,contentDetails")
+        .option("--max-results <n>", "Max results (1-50)", "25")
+        .option("--page-token <token>", "Pagination token")
+        .option("--video-id <id>", "Filter by specific video ID")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const params = {
+                part: opts.part,
+                playlistId: opts.playlistId,
+                maxResults: opts.maxResults,
+            };
+            if (opts.pageToken)
+                params.pageToken = opts.pageToken;
+            if (opts.videoId)
+                params.videoId = opts.videoId;
+            const data = await callApi("/playlistItems", { creds, params });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+    program
+        .command("playlist-items-insert")
+        .description("Add a video to a playlist (OAuth required)")
+        .requiredOption("--playlist-id <id>", "Playlist ID")
+        .requiredOption("--video-id <id>", "Video ID to add")
+        .option("--position <n>", "Position in the playlist (0-based)")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const snippet = {
+                playlistId: opts.playlistId,
+                resourceId: {
+                    kind: "youtube#video",
+                    videoId: opts.videoId,
+                },
+            };
+            if (opts.position !== undefined) {
+                snippet.position = parseInt(opts.position, 10);
+            }
+            const data = await callApi("/playlistItems", {
+                creds,
+                params: { part: "snippet" },
+                method: "POST",
+                body: { snippet },
+            });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+    program
+        .command("playlist-items-update")
+        .description("Update a playlist item (OAuth required)")
+        .requiredOption("--id <id>", "Playlist item ID")
+        .requiredOption("--playlist-id <id>", "Playlist ID")
+        .requiredOption("--video-id <id>", "Video ID")
+        .option("--position <n>", "New position in the playlist (0-based)")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const snippet = {
+                playlistId: opts.playlistId,
+                resourceId: {
+                    kind: "youtube#video",
+                    videoId: opts.videoId,
+                },
+            };
+            if (opts.position !== undefined) {
+                snippet.position = parseInt(opts.position, 10);
+            }
+            const data = await callApi("/playlistItems", {
+                creds,
+                params: { part: "snippet" },
+                method: "PUT",
+                body: { id: opts.id, snippet },
+            });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+    program
+        .command("playlist-items-delete")
+        .description("Remove an item from a playlist (OAuth required)")
+        .requiredOption("--id <id>", "Playlist item ID")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const data = await callApi("/playlistItems", {
+                creds,
+                params: { id: opts.id },
+                method: "DELETE",
+            });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+}

package/dist/commands/playlists.js

@@ -0,0 +1,126 @@
+import { loadCredentials } from "../auth.js";
+import { callApi } from "../api.js";
+import { output, fatal } from "../utils.js";
+export function registerPlaylistCommands(program) {
+    program
+        .command("playlists")
+        .description("List playlists by ID, channel, or authenticated user")
+        .option("--id <id>", "Playlist ID(s), comma-separated")
+        .option("--channel-id <id>", "Channel ID to list playlists for")
+        .option("--mine", "List authenticated user's playlists (OAuth required)")
+        .option("--part <parts>", "Parts to include", "snippet,contentDetails")
+        .option("--max-results <n>", "Max results (1-50)", "25")
+        .option("--page-token <token>", "Pagination token")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const params = {
+                part: opts.part,
+                maxResults: opts.maxResults,
+            };
+            const requireOAuth = !!opts.mine;
+            if (opts.id) {
+                params.id = opts.id;
+            }
+            else if (opts.channelId) {
+                params.channelId = opts.channelId;
+            }
+            else {
+                params.mine = "true";
+            }
+            if (opts.pageToken)
+                params.pageToken = opts.pageToken;
+            const data = await callApi("/playlists", { creds, params, requireOAuth });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+    program
+        .command("playlists-insert")
+        .description("Create a new playlist (OAuth required)")
+        .requiredOption("--title <title>", "Playlist title")
+        .option("--description <desc>", "Playlist description")
+        .option("--privacy <status>", "Privacy status (public, private, unlisted)", "private")
+        .option("--default-language <lang>", "Default language (ISO 639-1)")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const body = {
+                snippet: {
+                    title: opts.title,
+                    ...(opts.description && { description: opts.description }),
+                    ...(opts.defaultLanguage && { defaultLanguage: opts.defaultLanguage }),
+                },
+                status: {
+                    privacyStatus: opts.privacy,
+                },
+            };
+            const data = await callApi("/playlists", {
+                creds,
+                params: { part: "snippet,status" },
+                method: "POST",
+                body,
+            });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+    program
+        .command("playlists-update")
+        .description("Update a playlist (OAuth required)")
+        .requiredOption("--id <id>", "Playlist ID")
+        .requiredOption("--title <title>", "Playlist title")
+        .option("--description <desc>", "Playlist description")
+        .option("--privacy <status>", "Privacy status (public, private, unlisted)")
+        .option("--default-language <lang>", "Default language (ISO 639-1)")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const body = {
+                id: opts.id,
+                snippet: {
+                    title: opts.title,
+                    ...(opts.description && { description: opts.description }),
+                    ...(opts.defaultLanguage && { defaultLanguage: opts.defaultLanguage }),
+                },
+            };
+            const parts = ["snippet"];
+            if (opts.privacy) {
+                body.status = { privacyStatus: opts.privacy };
+                parts.push("status");
+            }
+            const data = await callApi("/playlists", {
+                creds,
+                params: { part: parts.join(",") },
+                method: "PUT",
+                body,
+            });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+    program
+        .command("playlists-delete")
+        .description("Delete a playlist (OAuth required)")
+        .requiredOption("--id <id>", "Playlist ID")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const data = await callApi("/playlists", {
+                creds,
+                params: { id: opts.id },
+                method: "DELETE",
+            });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+}

package/dist/commands/search.js

@@ -0,0 +1,68 @@
+import { loadCredentials } from "../auth.js";
+import { callApi } from "../api.js";
+import { output, fatal } from "../utils.js";
+export function registerSearchCommands(program) {
+    program
+        .command("search")
+        .description("Search YouTube for videos, channels, and playlists")
+        .requiredOption("--q <query>", "Search query")
+        .option("--type <type>", "Resource type filter (video, channel, playlist)", "video,channel,playlist")
+        .option("--max-results <n>", "Max results (1-50)", "5")
+        .option("--order <order>", "Sort order (relevance, date, rating, title, videoCount, viewCount)", "relevance")
+        .option("--channel-id <id>", "Limit results to a specific channel")
+        .option("--page-token <token>", "Pagination token")
+        .option("--published-after <datetime>", "Filter results published after this date (RFC 3339)")
+        .option("--published-before <datetime>", "Filter results published before this date (RFC 3339)")
+        .option("--region-code <code>", "ISO 3166-1 alpha-2 country code")
+        .option("--relevance-language <lang>", "ISO 639-1 language code")
+        .option("--safe-search <level>", "Safe search filtering (none, moderate, strict)")
+        .option("--video-duration <duration>", "Video duration filter (any, short, medium, long)")
+        .option("--video-definition <def>", "Video definition filter (any, high, standard)")
+        .option("--video-type <type>", "Video type filter (any, episode, movie)")
+        .option("--event-type <type>", "Event type filter (completed, live, upcoming)")
+        .option("--topic-id <id>", "Freebase topic ID filter")
+        .option("--video-category-id <id>", "Video category ID filter")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const params = {
+                part: "snippet",
+                q: opts.q,
+                type: opts.type,
+                maxResults: opts.maxResults,
+                order: opts.order,
+            };
+            if (opts.channelId)
+                params.channelId = opts.channelId;
+            if (opts.pageToken)
+                params.pageToken = opts.pageToken;
+            if (opts.publishedAfter)
+                params.publishedAfter = opts.publishedAfter;
+            if (opts.publishedBefore)
+                params.publishedBefore = opts.publishedBefore;
+            if (opts.regionCode)
+                params.regionCode = opts.regionCode;
+            if (opts.relevanceLanguage)
+                params.relevanceLanguage = opts.relevanceLanguage;
+            if (opts.safeSearch)
+                params.safeSearch = opts.safeSearch;
+            if (opts.videoDuration)
+                params.videoDuration = opts.videoDuration;
+            if (opts.videoDefinition)
+                params.videoDefinition = opts.videoDefinition;
+            if (opts.videoType)
+                params.videoType = opts.videoType;
+            if (opts.eventType)
+                params.eventType = opts.eventType;
+            if (opts.topicId)
+                params.topicId = opts.topicId;
+            if (opts.videoCategoryId)
+                params.videoCategoryId = opts.videoCategoryId;
+            const data = await callApi("/search", { creds, params });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+}

package/dist/commands/subscriptions.js

@@ -0,0 +1,90 @@
+import { loadCredentials } from "../auth.js";
+import { callApi } from "../api.js";
+import { output, fatal } from "../utils.js";
+export function registerSubscriptionCommands(program) {
+    program
+        .command("subscriptions")
+        .description("List subscriptions (OAuth required)")
+        .option("--channel-id <id>", "List subscriptions for a channel")
+        .option("--id <id>", "Subscription ID(s), comma-separated")
+        .option("--mine", "List authenticated user's subscriptions")
+        .option("--part <parts>", "Parts to include", "snippet,contentDetails")
+        .option("--max-results <n>", "Max results (1-50)", "25")
+        .option("--page-token <token>", "Pagination token")
+        .option("--order <order>", "Sort order (alphabetical, relevance, unread)")
+        .option("--for-channel-id <id>", "Filter by subscribed channel ID(s)")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const params = {
+                part: opts.part,
+                maxResults: opts.maxResults,
+            };
+            const requireOAuth = !!opts.mine || (!opts.channelId && !opts.id);
+            if (opts.id) {
+                params.id = opts.id;
+            }
+            else if (opts.channelId) {
+                params.channelId = opts.channelId;
+            }
+            else {
+                params.mine = "true";
+            }
+            if (opts.pageToken)
+                params.pageToken = opts.pageToken;
+            if (opts.order)
+                params.order = opts.order;
+            if (opts.forChannelId)
+                params.forChannelId = opts.forChannelId;
+            const data = await callApi("/subscriptions", { creds, params, requireOAuth });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+    program
+        .command("subscriptions-insert")
+        .description("Subscribe to a channel (OAuth required)")
+        .requiredOption("--channel-id <id>", "Channel ID to subscribe to")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const data = await callApi("/subscriptions", {
+                creds,
+                params: { part: "snippet" },
+                method: "POST",
+                body: {
+                    snippet: {
+                        resourceId: {
+                            kind: "youtube#channel",
+                            channelId: opts.channelId,
+                        },
+                    },
+                },
+            });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+    program
+        .command("subscriptions-delete")
+        .description("Unsubscribe (OAuth required)")
+        .requiredOption("--id <id>", "Subscription ID")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const data = await callApi("/subscriptions", {
+                creds,
+                params: { id: opts.id },
+                method: "DELETE",
+            });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+}