youtube-data-cli 0.0.1 → 1.0.0

package/dist/commands/captions.js

@@ -0,0 +1,152 @@
+import { writeFileSync } from "fs";
+import { loadCredentials } from "../auth.js";
+import { callApi, uploadFile } from "../api.js";
+import { output, fatal } from "../utils.js";
+export function registerCaptionCommands(program) {
+    program
+        .command("captions")
+        .description("List caption tracks for a video")
+        .requiredOption("--video-id <id>", "Video ID")
+        .option("--id <id>", "Caption track ID(s), comma-separated")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const params = {
+                part: "snippet",
+                videoId: opts.videoId,
+            };
+            if (opts.id)
+                params.id = opts.id;
+            const data = await callApi("/captions", { creds, params, requireOAuth: true });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+    program
+        .command("captions-insert")
+        .description("Upload a caption track (OAuth required)")
+        .requiredOption("--video-id <id>", "Video ID")
+        .requiredOption("--file <path>", "Path to caption file (SRT, VTT, etc.)")
+        .requiredOption("--language <lang>", "Caption language (BCP-47)")
+        .requiredOption("--name <name>", "Caption track name")
+        .option("--content-type <type>", "Caption file MIME type", "application/octet-stream")
+        .option("--is-draft", "Mark as draft")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const snippet = {
+                videoId: opts.videoId,
+                language: opts.language,
+                name: opts.name,
+            };
+            if (opts.isDraft)
+                snippet.isDraft = true;
+            const data = await uploadFile({
+                creds,
+                endpoint: "/captions",
+                params: { part: "snippet" },
+                filePath: opts.file,
+                contentType: opts.contentType,
+                body: { snippet },
+            });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+    program
+        .command("captions-update")
+        .description("Update a caption track (OAuth required)")
+        .requiredOption("--id <id>", "Caption track ID")
+        .option("--file <path>", "Path to new caption file")
+        .option("--content-type <type>", "Caption file MIME type", "application/octet-stream")
+        .option("--is-draft <bool>", "Mark as draft (true/false)")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const body = { id: opts.id };
+            if (opts.isDraft !== undefined) {
+                body.snippet = { isDraft: opts.isDraft === "true" };
+            }
+            if (opts.file) {
+                const data = await uploadFile({
+                    creds,
+                    endpoint: "/captions",
+                    params: { part: "snippet" },
+                    method: "PUT",
+                    filePath: opts.file,
+                    contentType: opts.contentType,
+                    body,
+                });
+                output(data, program.opts().format);
+            }
+            else {
+                const data = await callApi("/captions", {
+                    creds,
+                    params: { part: "snippet" },
+                    method: "PUT",
+                    body,
+                });
+                output(data, program.opts().format);
+            }
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+    program
+        .command("captions-download")
+        .description("Download a caption track (OAuth required)")
+        .requiredOption("--id <id>", "Caption track ID")
+        .option("--tfmt <format>", "Caption format (sbv, scc, srt, ttml, vtt)")
+        .option("--tlang <lang>", "Translation language (BCP-47)")
+        .option("--output <path>", "Output file path (default: stdout)")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const params = {};
+            if (opts.tfmt)
+                params.tfmt = opts.tfmt;
+            if (opts.tlang)
+                params.tlang = opts.tlang;
+            const res = await callApi(`/captions/${opts.id}`, {
+                creds,
+                params,
+                requireOAuth: true,
+                rawResponse: true,
+            });
+            const text = await res.text();
+            if (opts.output) {
+                writeFileSync(opts.output, text);
+                output({ downloaded: opts.output }, program.opts().format);
+            }
+            else {
+                process.stdout.write(text);
+            }
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+    program
+        .command("captions-delete")
+        .description("Delete a caption track (OAuth required)")
+        .requiredOption("--id <id>", "Caption track ID")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const data = await callApi("/captions", {
+                creds,
+                params: { id: opts.id },
+                method: "DELETE",
+            });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+}

package/dist/commands/channel-banners.js

@@ -0,0 +1,25 @@
+import { loadCredentials } from "../auth.js";
+import { uploadFileSimple } from "../api.js";
+import { output, fatal } from "../utils.js";
+export function registerChannelBannerCommands(program) {
+    program
+        .command("channel-banners-insert")
+        .description("Upload a channel banner image (OAuth required)")
+        .requiredOption("--file <path>", "Path to image file (JPEG, PNG, max 6MB)")
+        .option("--content-type <type>", "Image MIME type", "image/jpeg")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const data = await uploadFileSimple({
+                creds,
+                endpoint: "/channelBanners/insert",
+                filePath: opts.file,
+                contentType: opts.contentType,
+            });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+}

package/dist/commands/channel-sections.js

@@ -0,0 +1,139 @@
+import { loadCredentials } from "../auth.js";
+import { callApi } from "../api.js";
+import { output, fatal } from "../utils.js";
+export function registerChannelSectionCommands(program) {
+    program
+        .command("channel-sections")
+        .description("List channel sections")
+        .option("--channel-id <id>", "Channel ID")
+        .option("--id <id>", "Section ID(s), comma-separated")
+        .option("--mine", "List authenticated user's sections (OAuth required)")
+        .option("--part <parts>", "Parts to include", "snippet,contentDetails")
+        .option("--hl <lang>", "Language for localized text (ISO 639-1)")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const params = {
+                part: opts.part,
+            };
+            const requireOAuth = !!opts.mine || (!opts.id && !opts.channelId);
+            if (opts.id) {
+                params.id = opts.id;
+            }
+            else if (opts.channelId) {
+                params.channelId = opts.channelId;
+            }
+            else {
+                params.mine = "true";
+            }
+            if (opts.hl)
+                params.hl = opts.hl;
+            const data = await callApi("/channelSections", { creds, params, requireOAuth });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+    program
+        .command("channel-sections-insert")
+        .description("Add a channel section (OAuth required)")
+        .requiredOption("--type <type>", "Section type (singlePlaylist, multiplePlaylists, allPlaylists, recentActivity, etc.)")
+        .option("--title <title>", "Section title")
+        .option("--position <n>", "Section position (0-based)")
+        .option("--playlist-ids <ids>", "Playlist ID(s), comma-separated")
+        .option("--channel-ids <ids>", "Channel ID(s), comma-separated")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const snippet = {
+                type: opts.type,
+            };
+            if (opts.title)
+                snippet.title = opts.title;
+            if (opts.position !== undefined)
+                snippet.position = parseInt(opts.position, 10);
+            const body = { snippet };
+            const parts = ["snippet"];
+            if (opts.playlistIds || opts.channelIds) {
+                const contentDetails = {};
+                if (opts.playlistIds)
+                    contentDetails.playlists = opts.playlistIds.split(",");
+                if (opts.channelIds)
+                    contentDetails.channels = opts.channelIds.split(",");
+                body.contentDetails = contentDetails;
+                parts.push("contentDetails");
+            }
+            const data = await callApi("/channelSections", {
+                creds,
+                params: { part: parts.join(",") },
+                method: "POST",
+                body,
+            });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+    program
+        .command("channel-sections-update")
+        .description("Update a channel section (OAuth required)")
+        .requiredOption("--id <id>", "Section ID")
+        .requiredOption("--type <type>", "Section type")
+        .option("--title <title>", "Section title")
+        .option("--position <n>", "Section position (0-based)")
+        .option("--playlist-ids <ids>", "Playlist ID(s), comma-separated")
+        .option("--channel-ids <ids>", "Channel ID(s), comma-separated")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const snippet = {
+                type: opts.type,
+            };
+            if (opts.title)
+                snippet.title = opts.title;
+            if (opts.position !== undefined)
+                snippet.position = parseInt(opts.position, 10);
+            const body = { id: opts.id, snippet };
+            const parts = ["snippet"];
+            if (opts.playlistIds || opts.channelIds) {
+                const contentDetails = {};
+                if (opts.playlistIds)
+                    contentDetails.playlists = opts.playlistIds.split(",");
+                if (opts.channelIds)
+                    contentDetails.channels = opts.channelIds.split(",");
+                body.contentDetails = contentDetails;
+                parts.push("contentDetails");
+            }
+            const data = await callApi("/channelSections", {
+                creds,
+                params: { part: parts.join(",") },
+                method: "PUT",
+                body,
+            });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+    program
+        .command("channel-sections-delete")
+        .description("Delete a channel section (OAuth required)")
+        .requiredOption("--id <id>", "Section ID")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const data = await callApi("/channelSections", {
+                creds,
+                params: { id: opts.id },
+                method: "DELETE",
+            });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+}

package/dist/commands/channels.js

@@ -26,4 +26,50 @@ export function registerChannelCommands(program) {
             fatal(err.message);
         }
     });
+    program
+        .command("channels-update")
+        .description("Update a channel's metadata (OAuth required)")
+        .requiredOption("--id <id>", "Channel ID")
+        .option("--description <desc>", "Channel description")
+        .option("--keywords <kw>", "Channel keywords")
+        .option("--default-language <lang>", "Default language (ISO 639-1)")
+        .option("--country <code>", "Channel country (ISO 3166-1 alpha-2)")
+        .option("--made-for-kids <bool>", "Self-declared made for kids (true/false)")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const body = { id: opts.id };
+            const parts = [];
+            const brandingChannel = {};
+            if (opts.description !== undefined)
+                brandingChannel.description = opts.description;
+            if (opts.keywords !== undefined)
+                brandingChannel.keywords = opts.keywords;
+            if (opts.defaultLanguage)
+                brandingChannel.defaultLanguage = opts.defaultLanguage;
+            if (opts.country)
+                brandingChannel.country = opts.country;
+            if (Object.keys(brandingChannel).length > 0) {
+                body.brandingSettings = { channel: brandingChannel };
+                parts.push("brandingSettings");
+            }
+            if (opts.madeForKids !== undefined) {
+                body.status = { selfDeclaredMadeForKids: opts.madeForKids === "true" };
+                parts.push("status");
+            }
+            if (parts.length === 0) {
+                fatal("At least one field to update is required.");
+            }
+            const data = await callApi("/channels", {
+                creds,
+                params: { part: parts.join(",") },
+                method: "PUT",
+                body,
+            });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
 }

package/dist/commands/comment-threads.js

@@ -24,7 +24,7 @@ export function registerCommentThreadCommands(program) {
             if (opts.videoId)
                 params.videoId = opts.videoId;
             else if (opts.channelId)
-                params.channelId = opts.channelId;
+                params.allThreadsRelatedToChannelId = opts.channelId;
             else if (opts.id)
                 params.id = opts.id;
             else {

package/dist/commands/comments.js

@@ -94,4 +94,31 @@ export function registerCommentCommands(program) {
             fatal(err.message);
         }
     });
+    program
+        .command("comments-set-moderation-status")
+        .description("Set moderation status of comments (OAuth required)")
+        .requiredOption("--id <ids>", "Comment ID(s), comma-separated")
+        .requiredOption("--moderation-status <status>", "Status: published, heldForReview, rejected")
+        .option("--ban-author", "Ban the comment author from making future comments")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const params = {
+                id: opts.id,
+                moderationStatus: opts.moderationStatus,
+            };
+            if (opts.banAuthor)
+                params.banAuthor = "true";
+            const data = await callApi("/comments/setModerationStatus", {
+                creds,
+                params,
+                method: "POST",
+                requireOAuth: true,
+            });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
 }

package/dist/commands/i18n.js

@@ -0,0 +1,39 @@
+import { loadCredentials } from "../auth.js";
+import { callApi } from "../api.js";
+import { output, fatal } from "../utils.js";
+export function registerI18nCommands(program) {
+    program
+        .command("i18n-languages")
+        .description("List supported languages")
+        .option("--hl <lang>", "Language for localized text (ISO 639-1)")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const params = { part: "snippet" };
+            if (opts.hl)
+                params.hl = opts.hl;
+            const data = await callApi("/i18nLanguages", { creds, params });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+    program
+        .command("i18n-regions")
+        .description("List supported regions")
+        .option("--hl <lang>", "Language for localized text (ISO 639-1)")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const params = { part: "snippet" };
+            if (opts.hl)
+                params.hl = opts.hl;
+            const data = await callApi("/i18nRegions", { creds, params });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+}

package/dist/commands/members.js

@@ -0,0 +1,51 @@
+import { loadCredentials } from "../auth.js";
+import { callApi } from "../api.js";
+import { output, fatal } from "../utils.js";
+export function registerMemberCommands(program) {
+    program
+        .command("members")
+        .description("List channel members (OAuth required)")
+        .option("--mode <mode>", "Filter mode (all_current, updates)", "all_current")
+        .option("--max-results <n>", "Max results (1-1000)", "25")
+        .option("--page-token <token>", "Pagination token")
+        .option("--has-access-to-level <id>", "Filter by membership level ID")
+        .option("--filter-by-member-channel-id <ids>", "Filter by member channel ID(s)")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const params = {
+                part: "snippet",
+                mode: opts.mode,
+                maxResults: opts.maxResults,
+            };
+            if (opts.pageToken)
+                params.pageToken = opts.pageToken;
+            if (opts.hasAccessToLevel)
+                params.hasAccessToLevel = opts.hasAccessToLevel;
+            if (opts.filterByMemberChannelId)
+                params.filterByMemberChannelId = opts.filterByMemberChannelId;
+            const data = await callApi("/members", { creds, params, requireOAuth: true });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+    program
+        .command("memberships-levels")
+        .description("List channel membership levels (OAuth required)")
+        .action(async () => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const data = await callApi("/membershipsLevels", {
+                creds,
+                params: { part: "snippet,id" },
+                requireOAuth: true,
+            });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+}

package/dist/commands/playlist-images.js

@@ -0,0 +1,107 @@
+import { loadCredentials } from "../auth.js";
+import { callApi, uploadFile } from "../api.js";
+import { output, fatal } from "../utils.js";
+export function registerPlaylistImageCommands(program) {
+    program
+        .command("playlist-images")
+        .description("List playlist images")
+        .requiredOption("--parent <id>", "Playlist ID")
+        .option("--max-results <n>", "Max results", "25")
+        .option("--page-token <token>", "Pagination token")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const params = {
+                part: "snippet",
+                parent: opts.parent,
+                maxResults: opts.maxResults,
+            };
+            if (opts.pageToken)
+                params.pageToken = opts.pageToken;
+            const data = await callApi("/playlistImages", { creds, params, requireOAuth: true });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+    program
+        .command("playlist-images-insert")
+        .description("Upload a playlist image (OAuth required)")
+        .requiredOption("--playlist-id <id>", "Playlist ID")
+        .requiredOption("--file <path>", "Path to image file")
+        .option("--content-type <type>", "Image MIME type", "image/jpeg")
+        .option("--type <type>", "Image type", "hero")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const data = await uploadFile({
+                creds,
+                endpoint: "/playlistImages",
+                params: { part: "snippet" },
+                filePath: opts.file,
+                contentType: opts.contentType,
+                body: {
+                    snippet: {
+                        playlistId: opts.playlistId,
+                        type: opts.type,
+                    },
+                },
+            });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+    program
+        .command("playlist-images-update")
+        .description("Update a playlist image (OAuth required)")
+        .requiredOption("--id <id>", "Playlist image ID")
+        .requiredOption("--playlist-id <id>", "Playlist ID")
+        .requiredOption("--file <path>", "Path to image file")
+        .option("--content-type <type>", "Image MIME type", "image/jpeg")
+        .option("--type <type>", "Image type", "hero")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const data = await uploadFile({
+                creds,
+                endpoint: "/playlistImages",
+                params: { part: "snippet" },
+                method: "PUT",
+                filePath: opts.file,
+                contentType: opts.contentType,
+                body: {
+                    id: opts.id,
+                    snippet: {
+                        playlistId: opts.playlistId,
+                        type: opts.type,
+                    },
+                },
+            });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+    program
+        .command("playlist-images-delete")
+        .description("Delete a playlist image (OAuth required)")
+        .requiredOption("--id <id>", "Playlist image ID")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const data = await callApi("/playlistImages", {
+                creds,
+                params: { id: opts.id },
+                method: "DELETE",
+            });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+}

package/dist/commands/playlists.js

@@ -18,7 +18,7 @@ export function registerPlaylistCommands(program) {
                 part: opts.part,
                 maxResults: opts.maxResults,
             };
-            const requireOAuth = !!opts.mine;
+            const requireOAuth = !!opts.mine || (!opts.id && !opts.channelId);
             if (opts.id) {
                 params.id = opts.id;
             }

package/dist/commands/thumbnails.js

@@ -0,0 +1,27 @@
+import { loadCredentials } from "../auth.js";
+import { uploadFileSimple } from "../api.js";
+import { output, fatal } from "../utils.js";
+export function registerThumbnailCommands(program) {
+    program
+        .command("thumbnails-set")
+        .description("Upload a custom thumbnail for a video (OAuth required)")
+        .requiredOption("--video-id <id>", "Video ID")
+        .requiredOption("--file <path>", "Path to image file (JPEG, PNG, GIF, BMP, WebP)")
+        .option("--content-type <type>", "Image MIME type", "image/jpeg")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const data = await uploadFileSimple({
+                creds,
+                endpoint: "/thumbnails/set",
+                params: { videoId: opts.videoId },
+                filePath: opts.file,
+                contentType: opts.contentType,
+            });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+}

package/dist/commands/video-abuse-report-reasons.js

@@ -0,0 +1,22 @@
+import { loadCredentials } from "../auth.js";
+import { callApi } from "../api.js";
+import { output, fatal } from "../utils.js";
+export function registerVideoAbuseReportReasonCommands(program) {
+    program
+        .command("video-abuse-report-reasons")
+        .description("List video abuse report reasons")
+        .option("--hl <lang>", "Language for localized text (ISO 639-1)")
+        .action(async (opts) => {
+        try {
+            const creds = loadCredentials(program.opts().credentials);
+            const params = { part: "snippet" };
+            if (opts.hl)
+                params.hl = opts.hl;
+            const data = await callApi("/videoAbuseReportReasons", { creds, params });
+            output(data, program.opts().format);
+        }
+        catch (err) {
+            fatal(err.message);
+        }
+    });
+}