@classytic/social 0.1.0

package/dist/providers/youtube.mjs

@@ -0,0 +1,902 @@
+import { t as PlatformProvider } from "../base-Bw7e52V8.mjs";
+import { t as SocialError } from "../errors-Cm6LeKf7.mjs";
+import { t as YouTubeCredentialsSchema } from "../youtube-Bs0fdY7H.mjs";
+import { google } from "googleapis";
+import { createReadStream } from "fs";
+import { stat } from "fs/promises";
+import { Readable } from "stream";
+
+//#region src/providers/youtube/index.ts
+/**
+* YouTube Platform Provider
+* =========================
+* YouTube integration with OAuth2, video upload, and content management.
+*
+* Features:
+* - OAuth2 authorization flow
+* - Resumable video uploads
+* - Upload progress tracking
+* - Video CRUD (get, list, update, delete)
+* - Credential validation
+*/
+var YouTubeProvider = class extends PlatformProvider {
+	defaultRedirectUri;
+	scopes;
+	constructor(config = {}) {
+		super(config);
+		this.name = "youtube";
+		this.displayName = "YouTube";
+		this.authType = "oauth2";
+		this.defaultRedirectUri = config.redirectUri || `http://localhost:${config.port || 4e3}/api/oauth/youtube/callback`;
+		this.scopes = [
+			"https://www.googleapis.com/auth/youtube.upload",
+			"https://www.googleapis.com/auth/youtube",
+			"https://www.googleapis.com/auth/userinfo.profile"
+		];
+	}
+	/**
+	* Create OAuth2 client with dynamic credentials
+	* @private
+	*/
+	_createOAuthClient(clientId, clientSecret, redirectUri) {
+		return new google.auth.OAuth2(clientId, clientSecret, redirectUri || this.defaultRedirectUri);
+	}
+	/**
+	* Get OAuth authorization URL
+	* @param state - State parameter for CSRF protection
+	* @param credentials - OAuth credentials {clientId, clientSecret}
+	*/
+	getAuthUrl(state, credentials = {}, _options) {
+		return this._createOAuthClient(credentials.clientId, credentials.clientSecret, credentials.redirectUri).generateAuthUrl({
+			access_type: "offline",
+			scope: this.scopes,
+			state,
+			prompt: "consent"
+		});
+	}
+	/**
+	* Exchange authorization code for tokens
+	* @param code - Authorization code
+	* @param credentials - OAuth credentials {clientId, clientSecret}
+	*/
+	async exchangeCode(code, credentials = {}) {
+		const { tokens } = await this._createOAuthClient(credentials.clientId, credentials.clientSecret, credentials.redirectUri).getToken(code);
+		return {
+			access_token: tokens.access_token,
+			refresh_token: tokens.refresh_token,
+			expires_in: tokens.expiry_date,
+			scope: tokens.scope,
+			token_type: tokens.token_type
+		};
+	}
+	/**
+	* Refresh access token
+	* @param refreshToken - Refresh token
+	* @param credentials - OAuth credentials {clientId, clientSecret}
+	*/
+	async refreshToken(refreshToken, credentials = {}) {
+		const client = this._createOAuthClient(credentials.clientId, credentials.clientSecret, credentials.redirectUri);
+		client.setCredentials({ refresh_token: refreshToken });
+		const tokenResponse = await client.getAccessToken();
+		const newCreds = client.credentials;
+		return {
+			access_token: tokenResponse.token ?? newCreds.access_token,
+			expires_in: newCreds.expiry_date,
+			token_type: newCreds.token_type
+		};
+	}
+	/**
+	* Get account information
+	* @param accessToken - Access token
+	* @param credentials - OAuth credentials {clientId, clientSecret}
+	*/
+	async getAccountInfo(accessToken, credentials = {}) {
+		const client = this._createOAuthClient(credentials.clientId, credentials.clientSecret, credentials.redirectUri);
+		client.setCredentials({ access_token: accessToken });
+		const youtube = google.youtube({
+			version: "v3",
+			auth: client
+		});
+		try {
+			const response = await youtube.channels.list({
+				part: [
+					"snippet",
+					"contentDetails",
+					"statistics"
+				],
+				mine: true
+			});
+			if (!response.data.items || response.data.items.length === 0) throw new SocialError("youtube", "No YouTube channel found for this account", {
+				statusCode: 400,
+				hint: "Make sure your Google account has a YouTube channel."
+			});
+			const channel = response.data.items[0];
+			return {
+				id: channel.id,
+				name: channel.snippet.title,
+				description: channel.snippet.description,
+				customUrl: channel.snippet.customUrl,
+				profileImage: channel.snippet.thumbnails?.default?.url,
+				subscriberCount: channel.statistics?.subscriberCount,
+				videoCount: channel.statistics?.videoCount,
+				viewCount: channel.statistics?.viewCount
+			};
+		} catch (error) {
+			throw new SocialError("youtube", `Failed to get account info: ${error.message}`, { originalError: error });
+		}
+	}
+	/**
+	* Test credential validity
+	*/
+	async testCredential(credentialData) {
+		try {
+			if (credentialData.oauthTokenData) {
+				const tokenData = JSON.parse(credentialData.oauthTokenData);
+				const accountInfo = await this.getAccountInfo(tokenData.access_token);
+				return {
+					status: "OK",
+					message: "YouTube credential is valid",
+					data: {
+						channelId: accountInfo.id,
+						channelTitle: accountInfo.name,
+						subscriberCount: accountInfo.subscriberCount
+					}
+				};
+			}
+			if (!this.config.clientId || !this.config.clientSecret) return {
+				status: "Error",
+				message: "YouTube OAuth credentials not configured"
+			};
+			return {
+				status: "OK",
+				message: "Credential needs OAuth authorization",
+				authUrl: this.getAuthUrl("test")
+			};
+		} catch (error) {
+			return {
+				status: "Error",
+				message: error.message || "Failed to validate YouTube credential"
+			};
+		}
+	}
+	/**
+	* Build video metadata for YouTube uploads.
+	* Shared between initUploadSession() and uploadVideo().
+	*
+	* Supports all YouTube Data API v3 fields:
+	* - snippet: title, description, tags, categoryId, defaultLanguage
+	* - status: privacyStatus, publishAt, license, embeddable, publicStatsViewable, selfDeclaredMadeForKids
+	* - recordingDetails: recordingDate
+	*/
+	_buildVideoMetadata(params) {
+		const { title, description = "", tags = [], privacy = "private", categoryId = "22", scheduledAt, options } = params;
+		const metadata = {
+			snippet: {
+				title: title.substring(0, 100),
+				description: description.substring(0, 5e3),
+				tags: tags.slice(0, 500),
+				categoryId
+			},
+			status: { privacyStatus: scheduledAt ? "private" : privacy }
+		};
+		if (options?.defaultLanguage) metadata.snippet.defaultLanguage = options.defaultLanguage;
+		if (options?.license !== void 0) metadata.status.license = options.license;
+		if (options?.embeddable !== void 0) metadata.status.embeddable = options.embeddable;
+		if (options?.publicStatsViewable !== void 0) metadata.status.publicStatsViewable = options.publicStatsViewable;
+		if (options?.selfDeclaredMadeForKids !== void 0) metadata.status.selfDeclaredMadeForKids = options.selfDeclaredMadeForKids;
+		if (options?.recordingDate) metadata.recordingDetails = { recordingDate: options.recordingDate };
+		if (scheduledAt) {
+			const publishDate = new Date(scheduledAt);
+			if (publishDate <= /* @__PURE__ */ new Date()) throw new SocialError("youtube", "Scheduled time must be in the future", {
+				statusCode: 400,
+				retryable: false
+			});
+			metadata.status.publishAt = publishDate.toISOString();
+		}
+		return metadata;
+	}
+	/**
+	* Initialize a resumable upload session (metadata only, no file).
+	* Returns a self-authenticating upload URI that the frontend can PUT to directly.
+	*
+	* Flow: Server calls this → returns uploadUri → Frontend PUTs file to uploadUri
+	* The upload URI is valid for ~24 hours and requires no additional auth.
+	*/
+	async initUploadSession(params) {
+		const { title, description, tags, privacy, categoryId, scheduledAt, credentials, tokens, options } = params;
+		try {
+			const videoMetadata = this._buildVideoMetadata({
+				title,
+				description,
+				tags,
+				privacy,
+				categoryId,
+				scheduledAt,
+				options
+			});
+			const initResponse = await fetch("https://www.googleapis.com/upload/youtube/v3/videos?uploadType=resumable&part=snippet,status,recordingDetails", {
+				method: "POST",
+				headers: {
+					"Authorization": `Bearer ${tokens.access_token}`,
+					"Content-Type": "application/json; charset=UTF-8"
+				},
+				body: JSON.stringify(videoMetadata)
+			});
+			if (!initResponse.ok) throw new SocialError("youtube", `Upload session init failed: ${(await initResponse.json().catch(() => ({ error: { message: initResponse.statusText } }))).error?.message || initResponse.statusText}`, { statusCode: initResponse.status });
+			const uploadUri = initResponse.headers.get("location");
+			if (!uploadUri) throw new SocialError("youtube", "No resumable upload URI returned by YouTube", { statusCode: 502 });
+			return { uploadUri };
+		} catch (error) {
+			if (error instanceof SocialError) throw error;
+			throw new SocialError("youtube", `Upload session init failed: ${error.message}`, { originalError: error });
+		}
+	}
+	/**
+	* Upload video to YouTube (server-side).
+	*
+	* Supports two modes:
+	* - filePath: Read from local file (original behavior)
+	* - videoUrl: Stream-through from URL (no disk IO, for GCS-stored media)
+	*/
+	async uploadVideo(params) {
+		const { filePath, videoUrl, title, description = "", tags = [], privacy = "private", categoryId = "22", credentials, tokens, scheduledAt, onProgress } = params;
+		try {
+			const client = this._createOAuthClient(credentials.clientId, credentials.clientSecret, credentials.redirectUri);
+			client.setCredentials({
+				access_token: tokens.access_token,
+				refresh_token: tokens.refresh_token
+			});
+			const youtube = google.youtube({
+				version: "v3",
+				auth: client
+			});
+			let mediaBody;
+			let fileSize;
+			if (filePath) {
+				fileSize = (await stat(filePath)).size;
+				mediaBody = createReadStream(filePath);
+			} else if (videoUrl) {
+				const response = await fetch(videoUrl);
+				if (!response.ok) throw new SocialError("youtube", `Failed to fetch video from URL: ${response.status} ${response.statusText}`, { statusCode: 502 });
+				const contentLength = response.headers.get("content-length");
+				fileSize = contentLength ? parseInt(contentLength, 10) : void 0;
+				mediaBody = Readable.fromWeb(response.body);
+			} else throw new SocialError("youtube", "uploadVideo requires either filePath or videoUrl", { statusCode: 400 });
+			const videoMetadata = this._buildVideoMetadata({
+				title: title || "",
+				description,
+				tags,
+				privacy,
+				categoryId,
+				scheduledAt
+			});
+			const notifySubscribers = params.notifySubscribers;
+			const video = (await youtube.videos.insert({
+				part: [
+					"snippet",
+					"status",
+					"recordingDetails"
+				],
+				notifySubscribers: notifySubscribers !== void 0 ? notifySubscribers : true,
+				requestBody: videoMetadata,
+				media: { body: mediaBody }
+			}, { onUploadProgress: (evt) => {
+				if (onProgress && evt.bytesRead && fileSize) onProgress(evt.bytesRead / fileSize * 100);
+			} })).data;
+			return {
+				platformVideoId: video.id,
+				platformUrl: `https://www.youtube.com/watch?v=${video.id}`,
+				status: scheduledAt ? "scheduled" : "published",
+				uploadedAt: /* @__PURE__ */ new Date(),
+				scheduledAt: scheduledAt ? new Date(scheduledAt) : null,
+				metadata: {
+					title: video.snippet.title,
+					privacy: video.status.privacyStatus,
+					publishAt: video.status.publishAt || null
+				}
+			};
+		} catch (error) {
+			if (error instanceof SocialError) throw error;
+			console.error("[YouTubeProvider] Upload failed:", error.message);
+			throw new SocialError("youtube", `Upload failed: ${error.message}`, { originalError: error });
+		}
+	}
+	/**
+	* Parse a YouTube API video item into a normalized YouTubeVideo.
+	*/
+	_parseVideoItem(item) {
+		return {
+			id: item.id,
+			title: item.snippet?.title ?? "",
+			description: item.snippet?.description ?? "",
+			publishedAt: item.snippet?.publishedAt ?? "",
+			thumbnailUrl: item.snippet?.thumbnails?.default?.url ?? null,
+			channelId: item.snippet?.channelId ?? "",
+			channelTitle: item.snippet?.channelTitle ?? "",
+			tags: item.snippet?.tags ?? [],
+			categoryId: item.snippet?.categoryId ?? "",
+			privacyStatus: item.status?.privacyStatus ?? "",
+			duration: item.contentDetails?.duration ?? null,
+			viewCount: item.statistics?.viewCount ?? null,
+			likeCount: item.statistics?.likeCount ?? null,
+			commentCount: item.statistics?.commentCount ?? null,
+			defaultLanguage: item.snippet?.defaultLanguage,
+			embeddable: item.status?.embeddable,
+			license: item.status?.license,
+			madeForKids: item.status?.madeForKids,
+			publishAt: item.status?.publishAt ?? null,
+			favoriteCount: item.statistics?.favoriteCount ?? null
+		};
+	}
+	/**
+	* Get a single video by ID.
+	*
+	* @param accessToken - OAuth access token
+	* @param videoId - YouTube video ID
+	* @param credentials - OAuth credentials { clientId, clientSecret }
+	* @returns Normalized video data with snippet, stats, and content details
+	*/
+	async getVideo(accessToken, videoId, credentials = {}) {
+		const client = this._createOAuthClient(credentials.clientId, credentials.clientSecret, credentials.redirectUri);
+		client.setCredentials({ access_token: accessToken });
+		const youtube = google.youtube({
+			version: "v3",
+			auth: client
+		});
+		try {
+			const items = (await youtube.videos.list({
+				part: [
+					"snippet",
+					"contentDetails",
+					"statistics",
+					"status"
+				],
+				id: [videoId]
+			})).data.items;
+			if (!items || items.length === 0) throw new SocialError("youtube", `Video not found: ${videoId}`, {
+				statusCode: 404,
+				hint: "Check that the video ID is correct and the video is accessible with your credentials."
+			});
+			return this._parseVideoItem(items[0]);
+		} catch (error) {
+			if (error instanceof SocialError) throw error;
+			throw new SocialError("youtube", `Failed to get video: ${error.message}`, { originalError: error });
+		}
+	}
+	/**
+	* List videos from the authenticated channel.
+	*
+	* Uses playlistItems.list on the channel's uploads playlist (1 quota unit per call)
+	* instead of search.list (100 quota units per call — avoid).
+	*
+	* For text search within videos use videos.list with a separate search flow.
+	*/
+	async listVideos(accessToken, credentials = {}, options = {}) {
+		const { maxResults = 10, pageToken } = options;
+		const client = this._createOAuthClient(credentials.clientId, credentials.clientSecret, credentials.redirectUri);
+		client.setCredentials({ access_token: accessToken });
+		const youtube = google.youtube({
+			version: "v3",
+			auth: client
+		});
+		try {
+			const uploadsPlaylistId = (await youtube.channels.list({
+				part: ["contentDetails"],
+				mine: true
+			})).data.items?.[0]?.contentDetails?.relatedPlaylists?.uploads;
+			if (!uploadsPlaylistId) return {
+				videos: [],
+				nextPageToken: null,
+				prevPageToken: null,
+				totalResults: 0
+			};
+			const playlistData = (await youtube.playlistItems.list({
+				part: ["snippet", "contentDetails"],
+				playlistId: uploadsPlaylistId,
+				maxResults: Math.min(maxResults, 50),
+				pageToken
+			})).data;
+			const videoIds = (playlistData.items ?? []).map((item) => item.contentDetails?.videoId).filter(Boolean);
+			if (videoIds.length === 0) return {
+				videos: [],
+				nextPageToken: null,
+				prevPageToken: null,
+				totalResults: 0
+			};
+			const videos = ((await youtube.videos.list({
+				part: [
+					"snippet",
+					"contentDetails",
+					"statistics",
+					"status"
+				],
+				id: videoIds
+			})).data.items ?? []).map((item) => this._parseVideoItem(item));
+			return {
+				videos,
+				nextPageToken: playlistData.nextPageToken ?? null,
+				prevPageToken: playlistData.prevPageToken ?? null,
+				totalResults: playlistData.pageInfo?.totalResults ?? videos.length
+			};
+		} catch (error) {
+			if (error instanceof SocialError) throw error;
+			throw new SocialError("youtube", `Failed to list videos: ${error.message}`, { originalError: error });
+		}
+	}
+	/**
+	* Update video metadata (title, description, tags, category, privacy).
+	*
+	* Only the fields provided in `params` are updated. Omitted fields are left unchanged.
+	* Note: You must have ownership of the video.
+	*
+	* @param accessToken - OAuth access token
+	* @param videoId - YouTube video ID to update
+	* @param params - Fields to update
+	* @param credentials - OAuth credentials { clientId, clientSecret }
+	*/
+	async updateVideo(accessToken, videoId, params, credentials = {}) {
+		const client = this._createOAuthClient(credentials.clientId, credentials.clientSecret, credentials.redirectUri);
+		client.setCredentials({ access_token: accessToken });
+		const youtube = google.youtube({
+			version: "v3",
+			auth: client
+		});
+		try {
+			const requestBody = {
+				id: videoId,
+				snippet: {},
+				status: {}
+			};
+			if (params.title !== void 0) requestBody.snippet.title = params.title;
+			if (params.description !== void 0) requestBody.snippet.description = params.description;
+			if (params.tags !== void 0) requestBody.snippet.tags = params.tags;
+			if (params.categoryId !== void 0) requestBody.snippet.categoryId = params.categoryId;
+			if (params.defaultLanguage !== void 0) requestBody.snippet.defaultLanguage = params.defaultLanguage;
+			if (params.privacy !== void 0) requestBody.status.privacyStatus = params.privacy;
+			if (params.embeddable !== void 0) requestBody.status.embeddable = params.embeddable;
+			if (params.license !== void 0) requestBody.status.license = params.license;
+			if (params.publicStatsViewable !== void 0) requestBody.status.publicStatsViewable = params.publicStatsViewable;
+			if (params.selfDeclaredMadeForKids !== void 0) requestBody.status.selfDeclaredMadeForKids = params.selfDeclaredMadeForKids;
+			const item = (await youtube.videos.update({
+				part: ["snippet", "status"],
+				requestBody
+			})).data;
+			return {
+				id: item.id,
+				title: item.snippet?.title ?? "",
+				description: item.snippet?.description ?? "",
+				publishedAt: "",
+				thumbnailUrl: null,
+				channelId: "",
+				channelTitle: "",
+				tags: item.snippet?.tags ?? [],
+				categoryId: item.snippet?.categoryId ?? "",
+				privacyStatus: item.status?.privacyStatus ?? "",
+				duration: null,
+				viewCount: null,
+				likeCount: null,
+				commentCount: null
+			};
+		} catch (error) {
+			if (error instanceof SocialError) throw error;
+			throw new SocialError("youtube", `Failed to update video: ${error.message}`, { originalError: error });
+		}
+	}
+	/**
+	* Delete a video by ID.
+	*
+	* @param accessToken - OAuth access token
+	* @param videoId - YouTube video ID to delete
+	* @param credentials - OAuth credentials { clientId, clientSecret }
+	*/
+	async deleteVideo(accessToken, videoId, credentials = {}) {
+		const client = this._createOAuthClient(credentials.clientId, credentials.clientSecret, credentials.redirectUri);
+		client.setCredentials({ access_token: accessToken });
+		const youtube = google.youtube({
+			version: "v3",
+			auth: client
+		});
+		try {
+			await youtube.videos.delete({ id: videoId });
+		} catch (error) {
+			if (error instanceof SocialError) throw error;
+			throw new SocialError("youtube", `Failed to delete video: ${error.message}`, { originalError: error });
+		}
+	}
+	_parsePlaylist(item) {
+		return {
+			id: item.id,
+			title: item.snippet?.title ?? "",
+			description: item.snippet?.description ?? "",
+			publishedAt: item.snippet?.publishedAt ?? "",
+			channelId: item.snippet?.channelId ?? "",
+			thumbnailUrl: item.snippet?.thumbnails?.default?.url ?? null,
+			itemCount: item.contentDetails?.itemCount ?? 0,
+			privacyStatus: item.status?.privacyStatus ?? "",
+			defaultLanguage: item.snippet?.defaultLanguage
+		};
+	}
+	_parsePlaylistItem(item) {
+		return {
+			id: item.id,
+			playlistId: item.snippet?.playlistId ?? "",
+			videoId: item.snippet?.resourceId?.videoId ?? "",
+			title: item.snippet?.title ?? "",
+			description: item.snippet?.description ?? "",
+			thumbnailUrl: item.snippet?.thumbnails?.default?.url ?? null,
+			position: item.snippet?.position ?? 0
+		};
+	}
+	async createPlaylist(accessToken, params, credentials = {}) {
+		const client = this._createOAuthClient(credentials.clientId, credentials.clientSecret, credentials.redirectUri);
+		client.setCredentials({ access_token: accessToken });
+		const youtube = google.youtube({
+			version: "v3",
+			auth: client
+		});
+		try {
+			const requestBody = {
+				snippet: { title: params.title },
+				status: {}
+			};
+			if (params.description !== void 0) requestBody.snippet.description = params.description;
+			if (params.tags) requestBody.snippet.tags = params.tags;
+			if (params.defaultLanguage) requestBody.snippet.defaultLanguage = params.defaultLanguage;
+			if (params.privacy) requestBody.status.privacyStatus = params.privacy;
+			const response = await youtube.playlists.insert({
+				part: ["snippet", "status"],
+				requestBody
+			});
+			return this._parsePlaylist(response.data);
+		} catch (error) {
+			if (error instanceof SocialError) throw error;
+			throw new SocialError("youtube", `Failed to create playlist: ${error.message}`, { originalError: error });
+		}
+	}
+	async getPlaylist(accessToken, playlistId, credentials = {}) {
+		const client = this._createOAuthClient(credentials.clientId, credentials.clientSecret, credentials.redirectUri);
+		client.setCredentials({ access_token: accessToken });
+		const youtube = google.youtube({
+			version: "v3",
+			auth: client
+		});
+		try {
+			const items = (await youtube.playlists.list({
+				part: [
+					"snippet",
+					"contentDetails",
+					"status"
+				],
+				id: [playlistId]
+			})).data.items;
+			if (!items || items.length === 0) throw new SocialError("youtube", `Playlist not found: ${playlistId}`, { statusCode: 404 });
+			return this._parsePlaylist(items[0]);
+		} catch (error) {
+			if (error instanceof SocialError) throw error;
+			throw new SocialError("youtube", `Failed to get playlist: ${error.message}`, { originalError: error });
+		}
+	}
+	async listPlaylists(accessToken, credentials = {}, options = {}) {
+		const { maxResults = 25, pageToken, mine = true, channelId } = options;
+		const client = this._createOAuthClient(credentials.clientId, credentials.clientSecret, credentials.redirectUri);
+		client.setCredentials({ access_token: accessToken });
+		const youtube = google.youtube({
+			version: "v3",
+			auth: client
+		});
+		try {
+			const params = {
+				part: [
+					"snippet",
+					"contentDetails",
+					"status"
+				],
+				maxResults: Math.min(maxResults, 50)
+			};
+			if (channelId) params.channelId = channelId;
+			else if (mine) params.mine = true;
+			if (pageToken) params.pageToken = pageToken;
+			const data = (await youtube.playlists.list(params)).data;
+			return {
+				playlists: (data.items ?? []).map((item) => this._parsePlaylist(item)),
+				nextPageToken: data.nextPageToken ?? null,
+				prevPageToken: data.prevPageToken ?? null,
+				totalResults: data.pageInfo?.totalResults ?? 0
+			};
+		} catch (error) {
+			if (error instanceof SocialError) throw error;
+			throw new SocialError("youtube", `Failed to list playlists: ${error.message}`, { originalError: error });
+		}
+	}
+	async updatePlaylist(accessToken, playlistId, params, credentials = {}) {
+		const client = this._createOAuthClient(credentials.clientId, credentials.clientSecret, credentials.redirectUri);
+		client.setCredentials({ access_token: accessToken });
+		const youtube = google.youtube({
+			version: "v3",
+			auth: client
+		});
+		try {
+			const requestBody = {
+				id: playlistId,
+				snippet: {},
+				status: {}
+			};
+			if (params.title !== void 0) requestBody.snippet.title = params.title;
+			if (params.description !== void 0) requestBody.snippet.description = params.description;
+			if (params.tags !== void 0) requestBody.snippet.tags = params.tags;
+			if (params.defaultLanguage !== void 0) requestBody.snippet.defaultLanguage = params.defaultLanguage;
+			if (params.privacy !== void 0) requestBody.status.privacyStatus = params.privacy;
+			const response = await youtube.playlists.update({
+				part: ["snippet", "status"],
+				requestBody
+			});
+			return this._parsePlaylist(response.data);
+		} catch (error) {
+			if (error instanceof SocialError) throw error;
+			throw new SocialError("youtube", `Failed to update playlist: ${error.message}`, { originalError: error });
+		}
+	}
+	async deletePlaylist(accessToken, playlistId, credentials = {}) {
+		const client = this._createOAuthClient(credentials.clientId, credentials.clientSecret, credentials.redirectUri);
+		client.setCredentials({ access_token: accessToken });
+		const youtube = google.youtube({
+			version: "v3",
+			auth: client
+		});
+		try {
+			await youtube.playlists.delete({ id: playlistId });
+		} catch (error) {
+			if (error instanceof SocialError) throw error;
+			throw new SocialError("youtube", `Failed to delete playlist: ${error.message}`, { originalError: error });
+		}
+	}
+	async addToPlaylist(accessToken, playlistId, videoId, credentials = {}, options = {}) {
+		const client = this._createOAuthClient(credentials.clientId, credentials.clientSecret, credentials.redirectUri);
+		client.setCredentials({ access_token: accessToken });
+		const youtube = google.youtube({
+			version: "v3",
+			auth: client
+		});
+		try {
+			const requestBody = { snippet: {
+				playlistId,
+				resourceId: {
+					kind: "youtube#video",
+					videoId
+				}
+			} };
+			if (options.position !== void 0) requestBody.snippet.position = options.position;
+			if (options.note) requestBody.contentDetails = { note: options.note };
+			const response = await youtube.playlistItems.insert({
+				part: ["snippet", "contentDetails"],
+				requestBody
+			});
+			return this._parsePlaylistItem(response.data);
+		} catch (error) {
+			if (error instanceof SocialError) throw error;
+			throw new SocialError("youtube", `Failed to add to playlist: ${error.message}`, { originalError: error });
+		}
+	}
+	async removeFromPlaylist(accessToken, playlistItemId, credentials = {}) {
+		const client = this._createOAuthClient(credentials.clientId, credentials.clientSecret, credentials.redirectUri);
+		client.setCredentials({ access_token: accessToken });
+		const youtube = google.youtube({
+			version: "v3",
+			auth: client
+		});
+		try {
+			await youtube.playlistItems.delete({ id: playlistItemId });
+		} catch (error) {
+			if (error instanceof SocialError) throw error;
+			throw new SocialError("youtube", `Failed to remove from playlist: ${error.message}`, { originalError: error });
+		}
+	}
+	async listPlaylistItems(accessToken, playlistId, credentials = {}, options = {}) {
+		const { maxResults = 25, pageToken } = options;
+		const client = this._createOAuthClient(credentials.clientId, credentials.clientSecret, credentials.redirectUri);
+		client.setCredentials({ access_token: accessToken });
+		const youtube = google.youtube({
+			version: "v3",
+			auth: client
+		});
+		try {
+			const params = {
+				part: ["snippet", "contentDetails"],
+				playlistId,
+				maxResults: Math.min(maxResults, 50)
+			};
+			if (pageToken) params.pageToken = pageToken;
+			const data = (await youtube.playlistItems.list(params)).data;
+			return {
+				items: (data.items ?? []).map((item) => this._parsePlaylistItem(item)),
+				nextPageToken: data.nextPageToken ?? null,
+				prevPageToken: data.prevPageToken ?? null,
+				totalResults: data.pageInfo?.totalResults ?? 0
+			};
+		} catch (error) {
+			if (error instanceof SocialError) throw error;
+			throw new SocialError("youtube", `Failed to list playlist items: ${error.message}`, { originalError: error });
+		}
+	}
+	/**
+	* Search YouTube videos with comprehensive filters.
+	* Uses a 2-step approach: search.list → videos.list for full details.
+	*/
+	async searchVideos(accessToken, credentials = {}, options = {}) {
+		const { q, publishedAfter, publishedBefore, videoCategoryId, channelId, order = "relevance", safeSearch, videoType, regionCode, maxResults = 25, pageToken } = options;
+		const client = this._createOAuthClient(credentials.clientId, credentials.clientSecret, credentials.redirectUri);
+		client.setCredentials({ access_token: accessToken });
+		const youtube = google.youtube({
+			version: "v3",
+			auth: client
+		});
+		try {
+			const searchParams = {
+				part: ["id"],
+				type: ["video"],
+				maxResults: Math.min(maxResults, 50),
+				order
+			};
+			if (q) searchParams.q = q;
+			if (publishedAfter) searchParams.publishedAfter = publishedAfter;
+			if (publishedBefore) searchParams.publishedBefore = publishedBefore;
+			if (videoCategoryId) searchParams.videoCategoryId = videoCategoryId;
+			if (channelId) searchParams.channelId = channelId;
+			if (safeSearch) searchParams.safeSearch = safeSearch;
+			if (videoType) searchParams.videoType = videoType;
+			if (regionCode) searchParams.regionCode = regionCode;
+			if (pageToken) searchParams.pageToken = pageToken;
+			if (!channelId && !q) searchParams.forMine = true;
+			const searchData = (await youtube.search.list(searchParams)).data;
+			const videoIds = (searchData.items ?? []).map((item) => item.id?.videoId).filter(Boolean);
+			if (videoIds.length === 0) return {
+				videos: [],
+				nextPageToken: null,
+				prevPageToken: null,
+				totalResults: 0
+			};
+			return {
+				videos: ((await youtube.videos.list({
+					part: [
+						"snippet",
+						"contentDetails",
+						"statistics",
+						"status"
+					],
+					id: videoIds
+				})).data.items ?? []).map((item) => this._parseVideoItem(item)),
+				nextPageToken: searchData.nextPageToken ?? null,
+				prevPageToken: searchData.prevPageToken ?? null,
+				totalResults: searchData.pageInfo?.totalResults ?? 0
+			};
+		} catch (error) {
+			if (error instanceof SocialError) throw error;
+			throw new SocialError("youtube", `Search failed: ${error.message}`, { originalError: error });
+		}
+	}
+	/**
+	* Get available video categories for a region.
+	* @param regionCode - ISO 3166-1 alpha-2 country code (e.g. 'US', 'BD')
+	*/
+	async getVideoCategories(accessToken, regionCode, credentials = {}) {
+		const client = this._createOAuthClient(credentials.clientId, credentials.clientSecret, credentials.redirectUri);
+		client.setCredentials({ access_token: accessToken });
+		const youtube = google.youtube({
+			version: "v3",
+			auth: client
+		});
+		try {
+			return ((await youtube.videoCategories.list({
+				part: ["snippet"],
+				regionCode
+			})).data.items ?? []).map((item) => ({
+				id: item.id,
+				title: item.snippet?.title ?? "",
+				assignable: item.snippet?.assignable ?? false
+			}));
+		} catch (error) {
+			if (error instanceof SocialError) throw error;
+			throw new SocialError("youtube", `Failed to get video categories: ${error.message}`, { originalError: error });
+		}
+	}
+	/**
+	* Rate a video (like, dislike, or remove rating).
+	*/
+	async rateVideo(accessToken, videoId, rating, credentials = {}) {
+		const client = this._createOAuthClient(credentials.clientId, credentials.clientSecret, credentials.redirectUri);
+		client.setCredentials({ access_token: accessToken });
+		const youtube = google.youtube({
+			version: "v3",
+			auth: client
+		});
+		try {
+			await youtube.videos.rate({
+				id: videoId,
+				rating
+			});
+		} catch (error) {
+			if (error instanceof SocialError) throw error;
+			throw new SocialError("youtube", `Failed to rate video: ${error.message}`, { originalError: error });
+		}
+	}
+	/**
+	* Return the zod schema for runtime validation. Consumers can call
+	* `z.toJSONSchema(provider.getCredentialZodSchema())` to render UI forms
+	* or generate OpenAPI specs.
+	*/
+	getCredentialZodSchema() {
+		return YouTubeCredentialsSchema;
+	}
+	/**
+	* Get credential schema for UI (legacy CredentialField[] shape).
+	*/
+	getCredentialSchema() {
+		return [{
+			name: "clientId",
+			displayName: "Client ID",
+			type: "text",
+			required: true,
+			description: "Google OAuth2 Client ID from Google Cloud Console"
+		}, {
+			name: "clientSecret",
+			displayName: "Client Secret",
+			type: "password",
+			required: true,
+			description: "Google OAuth2 Client Secret"
+		}];
+	}
+	/**
+	* Get provider metadata for frontend display
+	*/
+	getMetadata() {
+		return {
+			name: this.name,
+			displayName: this.displayName,
+			authType: this.authType,
+			icon: "youtube",
+			brandColor: "#FF0000",
+			supportsScheduling: true,
+			supportsEnvironment: false,
+			description: "Upload and manage videos on YouTube",
+			scopes: this.scopes,
+			scopeDescriptions: {
+				"https://www.googleapis.com/auth/youtube.upload": "Upload videos to your channel",
+				"https://www.googleapis.com/auth/youtube": "Manage your YouTube account",
+				"https://www.googleapis.com/auth/userinfo.profile": "View your basic profile info"
+			},
+			setupGuide: [
+				{
+					step: 1,
+					title: "Create Google Cloud Project",
+					description: "Go to console.cloud.google.com and create a new project or select an existing one"
+				},
+				{
+					step: 2,
+					title: "Enable YouTube Data API v3",
+					description: "Navigate to APIs & Services > Library, search for \"YouTube Data API v3\" and enable it"
+				},
+				{
+					step: 3,
+					title: "Create OAuth Credentials",
+					description: "Go to APIs & Services > Credentials, click \"Create Credentials\" > \"OAuth 2.0 Client ID\" for Web application"
+				},
+				{
+					step: 4,
+					title: "Set Redirect URI",
+					description: `Add this as an authorized redirect URI: ${this.defaultRedirectUri}`
+				},
+				{
+					step: 5,
+					title: "Configure Consent Screen",
+					description: "Set up the OAuth consent screen with your app name and add your email as a test user"
+				}
+			],
+			redirectUriPattern: this.defaultRedirectUri,
+			credentialSchema: this.getCredentialSchema()
+		};
+	}
+};
+
+//#endregion
+export { YouTubeProvider };
+//# sourceMappingURL=youtube.mjs.map