my-youtube-api 1.0.5 → 1.0.6

package/dist/youtube-handlers/youtube-video-poster.d.ts

@@ -1,4 +1,3 @@
-import { youtube_v3 } from "googleapis";
 export interface VideoMetadata {
     title: string;
     description?: string;
@@ -9,15 +8,35 @@ export interface VideoMetadata {
     license?: "youtube" | "creativeCommon";
     embeddable?: boolean;
     publicStatsViewable?: boolean;
+    playlistId?: string;
+    notifySubscribers?: boolean;
+}
+export interface YouTubeUploadResult {
+    id: string;
+    status: string;
+    url: string;
+    title: string;
+    description?: string;
+    thumbnailUrl?: string;
 }
 export declare class YoutubeVideoPoster {
-    private access_token;
+    private accessToken;
     private youtube;
-    constructor(access_token: string);
+    constructor(accessToken: string);
+    /**
+     * Upload a video from a Cloudinary URL to YouTube using direct API calls
+     */
+    uploadFromCloudUrl(videoUrl: string, metadata: VideoMetadata): Promise<YouTubeUploadResult>;
+    /**
+     * Wait for video processing to complete using direct API calls
+     */
+    private waitForVideoProcessing;
+    /**
+     * Alternative method using direct axios calls (if Google client still has issues)
+     */
+    uploadFromCloudUrlDirect(videoUrl: string, metadata: VideoMetadata): Promise<YouTubeUploadResult>;
     /**
-     * Upload a video from a Cloudinary URL to YouTube
-     * @param videoUrl URL of the video on Cloudinary
-     * @param metadata Video metadata
+     * Wait for processing using direct API calls
      */
-    uploadFromCloudUrl(videoUrl: string, metadata: VideoMetadata): Promise<youtube_v3.Schema$Video>;
+    private waitForVideoProcessingDirect;
 }

package/dist/youtube-handlers/youtube-video-poster.js

@@ -1,47 +1,275 @@
+// src/youtube-handlers/youtube-video-poster.ts
 import { google } from "googleapis";
 import axios from "axios";
+import { Readable } from "stream";
+import { YouTubeApiError, YouTubeAuthenticationError, YouTubeQuotaError, YouTubeMediaError, YouTubeUploadError, YouTubeValidationError, YouTubeProcessingError, YouTubeTimeoutError } from "../errors/youtube-api-errors";
 export class YoutubeVideoPoster {
-    constructor(access_token) {
-        this.access_token = access_token;
-        this.youtube = google.youtube({ version: "v3", auth: this.access_token });
+    constructor(accessToken) {
+        if (!accessToken) {
+            throw new YouTubeAuthenticationError('Access token is required');
+        }
+        this.accessToken = accessToken;
+        // ✅ CORRECT: Create OAuth2 client and set credentials
+        const oauth2Client = new google.auth.OAuth2();
+        oauth2Client.setCredentials({
+            access_token: accessToken
+        });
+        this.youtube = google.youtube({
+            version: "v3",
+            auth: oauth2Client
+        });
     }
     /**
-     * Upload a video from a Cloudinary URL to YouTube
-     * @param videoUrl URL of the video on Cloudinary
-     * @param metadata Video metadata
+     * Upload a video from a Cloudinary URL to YouTube using direct API calls
      */
     async uploadFromCloudUrl(videoUrl, metadata) {
+        let videoStream = null;
         try {
-            // Fetch video as stream from Cloudinary
-            const response = await axios.get(videoUrl, { responseType: "stream" });
-            const videoStream = response.data;
-            // Prepare metadata payload
-            const metadataPayload = {
+            console.log(`📹 Fetching video from: ${videoUrl}`);
+            // Fetch video stream
+            const response = await axios.get(videoUrl, {
+                responseType: "stream",
+                timeout: 30000,
+                maxContentLength: 1024 * 1024 * 1024, // 1GB max
+            });
+            videoStream = response.data;
+            if (!videoStream || !(videoStream instanceof Readable)) {
+                throw new YouTubeMediaError('Invalid video stream received from URL');
+            }
+            // Prepare metadata
+            const requestBody = {
+                snippet: {
+                    title: metadata.title.substring(0, 100),
+                    description: (metadata.description || "").substring(0, 5000),
+                    tags: metadata.tags || [],
+                    categoryId: metadata.categoryId || "22"
+                },
+                status: {
+                    privacyStatus: metadata.privacyStatus || "private",
+                    embeddable: metadata.embeddable !== false,
+                    publicStatsViewable: metadata.publicStatsViewable !== false,
+                    license: metadata.license || "youtube",
+                    selfDeclaredMadeForKids: metadata.madeForKids || false
+                }
+            };
+            console.log(`🚀 Uploading video to YouTube: "${metadata.title}"`);
+            // Upload using Google APIs client with OAuth2
+            const uploadResponse = await this.youtube.videos.insert({
                 part: ["snippet", "status"],
-                requestBody: {
-                    snippet: {
-                        title: metadata.title.substring(0, 100),
-                        description: (metadata.description || "").substring(0, 5000),
-                        tags: (metadata.tags || []).slice(0, 5),
-                        categoryId: metadata.categoryId || "22"
-                    },
-                    status: {
-                        privacyStatus: metadata.privacyStatus || "private",
-                        embeddable: metadata.embeddable !== false,
-                        publicStatsViewable: metadata.publicStatsViewable !== false,
-                        license: metadata.license || "youtube",
-                        selfDeclaredMadeForKids: metadata.madeForKids || false
-                    }
+                requestBody: requestBody,
+                media: {
+                    body: videoStream,
+                    mimeType: 'video/*'
+                },
+                notifySubscribers: metadata.notifySubscribers !== false
+            });
+            const videoId = uploadResponse.data.id;
+            if (!videoId) {
+                throw new YouTubeUploadError('Video ID not returned from YouTube API');
+            }
+            console.log(`✅ Video uploaded successfully: ${videoId}`);
+            // Wait for processing to complete
+            await this.waitForVideoProcessing(videoId);
+            const result = {
+                id: videoId,
+                status: 'processed',
+                url: `https://www.youtube.com/watch?v=${videoId}`,
+                title: metadata.title,
+                description: metadata.description,
+            };
+            console.log(`🎉 YouTube video published successfully: ${result.url}`);
+            return result;
+        }
+        catch (error) {
+            // Clean up stream
+            if (videoStream) {
+                videoStream.destroy();
+            }
+            console.error("YouTube upload failed:", error);
+            // Handle specific Google API errors
+            if (error.code === 401) {
+                throw new YouTubeAuthenticationError('Authentication failed. Please reconnect your YouTube account. ' +
+                    'The access token may have expired or is invalid.');
+            }
+            else if (error.code === 403) {
+                if (error.message?.includes('quota')) {
+                    throw new YouTubeQuotaError('YouTube API quota exceeded. Please try again tomorrow.');
+                }
+                else {
+                    throw new YouTubeAuthenticationError('Access denied. Please check your YouTube permissions.');
+                }
+            }
+            else if (error.code === 400) {
+                throw new YouTubeValidationError(`Invalid request: ${error.message}`);
+            }
+            else if (error.code === 503) {
+                throw new YouTubeProcessingError('YouTube service temporarily unavailable. Please try again.');
+            }
+            else {
+                throw new YouTubeApiError(`YouTube API error: ${error.message}`);
+            }
+        }
+    }
+    /**
+     * Wait for video processing to complete using direct API calls
+     */
+    async waitForVideoProcessing(videoId, timeoutMs = 300000) {
+        const startTime = Date.now();
+        const maxAttempts = 30;
+        let attempts = 0;
+        console.log(`⏳ Waiting for video processing: ${videoId}`);
+        while (attempts < maxAttempts && Date.now() - startTime < timeoutMs) {
+            attempts++;
+            try {
+                const statusResponse = await this.youtube.videos.list({
+                    part: ['status'],
+                    id: [videoId]
+                });
+                const video = statusResponse.data.items?.[0];
+                if (!video) {
+                    throw new YouTubeProcessingError(`Video ${videoId} not found after upload`);
+                }
+                const status = video.status?.uploadStatus;
+                switch (status) {
+                    case 'processed':
+                        console.log(`✅ Video processing completed: ${videoId}`);
+                        return;
+                    case 'failed':
+                        const failureReason = video.status?.failureReason || 'Unknown failure reason';
+                        throw new YouTubeProcessingError(`Video processing failed: ${failureReason}`);
+                    case 'rejected':
+                        const rejectionReason = video.status?.rejectionReason || 'Unknown rejection reason';
+                        throw new YouTubeProcessingError(`Video was rejected: ${rejectionReason}`);
+                    case 'uploaded':
+                    case 'processing':
+                        const waitTime = Math.min(1000 * Math.pow(2, attempts), 10000);
+                        console.log(`⏳ Video status: ${status}, waiting ${waitTime}ms...`);
+                        await new Promise(resolve => setTimeout(resolve, waitTime));
+                        break;
+                    default:
+                        await new Promise(resolve => setTimeout(resolve, 5000));
+                        break;
+                }
+            }
+            catch (error) {
+                if (error instanceof YouTubeApiError) {
+                    throw error;
+                }
+                // Continue waiting on network errors
+                console.warn(`Error checking video status (attempt ${attempts}):`, error.message);
+                await new Promise(resolve => setTimeout(resolve, 5000));
+            }
+        }
+        throw new YouTubeTimeoutError(`Video processing timed out after ${timeoutMs}ms`);
+    }
+    /**
+     * Alternative method using direct axios calls (if Google client still has issues)
+     */
+    async uploadFromCloudUrlDirect(videoUrl, metadata) {
+        try {
+            console.log(`📹 Using direct upload method for: ${videoUrl}`);
+            // First, get the video file as buffer
+            const videoResponse = await axios.get(videoUrl, {
+                responseType: 'arraybuffer',
+                timeout: 30000,
+            });
+            const videoBuffer = Buffer.from(videoResponse.data);
+            // Prepare the metadata
+            const metadataPayload = {
+                snippet: {
+                    title: metadata.title.substring(0, 100),
+                    description: (metadata.description || "").substring(0, 5000),
+                    tags: metadata.tags || [],
+                    categoryId: metadata.categoryId || "22"
                 },
-                media: { body: videoStream }
+                status: {
+                    privacyStatus: metadata.privacyStatus || "private",
+                    embeddable: metadata.embeddable !== false,
+                    publicStatsViewable: metadata.publicStatsViewable !== false,
+                    license: metadata.license || "youtube",
+                    selfDeclaredMadeForKids: metadata.madeForKids || false
+                }
+            };
+            // Upload using direct multipart request
+            const formData = new FormData();
+            formData.append('metadata', JSON.stringify(metadataPayload));
+            formData.append('video', new Blob([videoBuffer]), 'video.mp4');
+            const uploadResponse = await axios.post('https://www.googleapis.com/upload/youtube/v3/videos?part=snippet,status', formData, {
+                headers: {
+                    'Authorization': `Bearer ${this.accessToken}`,
+                    'Content-Type': 'multipart/related',
+                },
+                maxContentLength: Infinity,
+                maxBodyLength: Infinity,
+                timeout: 60000,
+            });
+            const videoId = uploadResponse.data.id;
+            if (!videoId) {
+                throw new YouTubeUploadError('Video ID not returned from YouTube API');
+            }
+            console.log(`✅ Video uploaded successfully via direct method: ${videoId}`);
+            // Wait for processing
+            await this.waitForVideoProcessingDirect(videoId);
+            return {
+                id: videoId,
+                status: 'processed',
+                url: `https://www.youtube.com/watch?v=${videoId}`,
+                title: metadata.title,
+                description: metadata.description,
             };
-            // Upload video
-            const res = await this.youtube.videos.insert(metadataPayload);
-            return res.data;
         }
         catch (error) {
-            console.error("YouTube upload failed:", error.response?.data || error.message);
-            throw new Error(`YouTube upload failed: ${error.response?.data?.error?.message || error.message}`);
+            console.error("Direct YouTube upload failed:", error.response?.data || error.message);
+            if (error.response?.status === 401) {
+                throw new YouTubeAuthenticationError('Authentication failed. Please reconnect your YouTube account.');
+            }
+            else if (error.response?.status === 403) {
+                throw new YouTubeQuotaError('YouTube API quota exceeded.');
+            }
+            else {
+                throw new YouTubeApiError(`Upload failed: ${error.message}`);
+            }
+        }
+    }
+    /**
+     * Wait for processing using direct API calls
+     */
+    async waitForVideoProcessingDirect(videoId, timeoutMs = 300000) {
+        const startTime = Date.now();
+        let attempts = 0;
+        while (Date.now() - startTime < timeoutMs) {
+            attempts++;
+            try {
+                const response = await axios.get(`https://www.googleapis.com/youtube/v3/videos?part=status&id=${videoId}`, {
+                    headers: {
+                        'Authorization': `Bearer ${this.accessToken}`
+                    }
+                });
+                const video = response.data.items?.[0];
+                if (!video) {
+                    throw new YouTubeProcessingError(`Video ${videoId} not found`);
+                }
+                const status = video.status?.uploadStatus;
+                if (status === 'processed') {
+                    console.log(`✅ Video processing completed: ${videoId}`);
+                    return;
+                }
+                else if (status === 'failed') {
+                    throw new YouTubeProcessingError(`Video processing failed: ${video.status?.failureReason}`);
+                }
+                else if (status === 'rejected') {
+                    throw new YouTubeProcessingError(`Video rejected: ${video.status?.rejectionReason}`);
+                }
+                // Wait with exponential backoff
+                const waitTime = Math.min(1000 * Math.pow(2, attempts), 10000);
+                console.log(`⏳ Video status: ${status}, waiting ${waitTime}ms...`);
+                await new Promise(resolve => setTimeout(resolve, waitTime));
+            }
+            catch (error) {
+                console.warn(`Error checking video status (attempt ${attempts}):`, error.message);
+                await new Promise(resolve => setTimeout(resolve, 5000));
+            }
         }
+        throw new YouTubeTimeoutError(`Video processing timed out after ${timeoutMs}ms`);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "my-youtube-api",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "main": "dist/index.js",
   "scripts": {
     "prepublishOnly": "npm run build",

package/src/youtube-handlers/youtube-video-poster.ts

@@ -1,6 +1,18 @@
+// src/youtube-handlers/youtube-video-poster.ts
 import { google, youtube_v3 } from "googleapis";
 import axios from "axios";
 import { Readable } from "stream";
+import {
+    YouTubeApiError,
+    YouTubeAuthenticationError,
+    YouTubeQuotaError,
+    YouTubeRateLimitError,
+    YouTubeMediaError,
+    YouTubeUploadError,
+    YouTubeValidationError,
+    YouTubeProcessingError,
+    YouTubeTimeoutError
+} from "../errors/youtube-api-errors";
 
 export interface VideoMetadata {
     title: string;
@@ -9,57 +21,340 @@ export interface VideoMetadata {
     categoryId?: string;
     privacyStatus?: "public" | "private" | "unlisted";
     madeForKids?: boolean;
-    license?: "youtube" | "creativeCommon"; 
+    license?: "youtube" | "creativeCommon";
     embeddable?: boolean;
     publicStatsViewable?: boolean;
+    playlistId?: string;
+    notifySubscribers?: boolean;
+}
+
+export interface YouTubeUploadResult {
+    id: string;
+    status: string;
+    url: string;
+    title: string;
+    description?: string;
+    thumbnailUrl?: string;
 }
 
 export class YoutubeVideoPoster {
+    private accessToken: string;
     private youtube: youtube_v3.Youtube;
 
-    constructor(private access_token: string) {
-        this.youtube = google.youtube({ version: "v3", auth: this.access_token });
+    constructor(accessToken: string) {
+        if (!accessToken) {
+            throw new YouTubeAuthenticationError('Access token is required');
+        }
+        this.accessToken = accessToken;
+        
+        // ✅ CORRECT: Create OAuth2 client and set credentials
+        const oauth2Client = new google.auth.OAuth2();
+        oauth2Client.setCredentials({
+            access_token: accessToken
+        });
+        
+        this.youtube = google.youtube({
+            version: "v3",
+            auth: oauth2Client
+        });
     }
 
     /**
-     * Upload a video from a Cloudinary URL to YouTube
-     * @param videoUrl URL of the video on Cloudinary
-     * @param metadata Video metadata
+     * Upload a video from a Cloudinary URL to YouTube using direct API calls
      */
-    public async uploadFromCloudUrl(videoUrl: string, metadata: VideoMetadata): Promise<youtube_v3.Schema$Video> {
+    public async uploadFromCloudUrl(videoUrl: string, metadata: VideoMetadata): Promise<YouTubeUploadResult> {
+        let videoStream: Readable | null = null;
+
         try {
-            // Fetch video as stream from Cloudinary
-            const response = await axios.get(videoUrl, { responseType: "stream" });
-            const videoStream = response.data as Readable;
+            console.log(`📹 Fetching video from: ${videoUrl}`);
+
+            // Fetch video stream
+            const response = await axios.get(videoUrl, {
+                responseType: "stream",
+                timeout: 30000,
+                maxContentLength: 1024 * 1024 * 1024, // 1GB max
+            });
+
+            videoStream = response.data;
+
+            if (!videoStream || !(videoStream instanceof Readable)) {
+                throw new YouTubeMediaError('Invalid video stream received from URL');
+            }
 
-            // Prepare metadata payload
-            const metadataPayload: youtube_v3.Params$Resource$Videos$Insert = {
+            // Prepare metadata
+            const requestBody = {
+                snippet: {
+                    title: metadata.title.substring(0, 100),
+                    description: (metadata.description || "").substring(0, 5000),
+                    tags: metadata.tags || [],
+                    categoryId: metadata.categoryId || "22"
+                },
+                status: {
+                    privacyStatus: metadata.privacyStatus || "private",
+                    embeddable: metadata.embeddable !== false,
+                    publicStatsViewable: metadata.publicStatsViewable !== false,
+                    license: metadata.license || "youtube",
+                    selfDeclaredMadeForKids: metadata.madeForKids || false
+                }
+            };
+
+            console.log(`🚀 Uploading video to YouTube: "${metadata.title}"`);
+
+            // Upload using Google APIs client with OAuth2
+            const uploadResponse = await this.youtube.videos.insert({
                 part: ["snippet", "status"],
-                requestBody: {
-                    snippet: {
-                        title: metadata.title.substring(0, 100),
-                        description: (metadata.description || "").substring(0, 5000),
-                        tags: (metadata.tags || []).slice(0, 5),
-                        categoryId: metadata.categoryId || "22"
-                    },
-                    status: {
-                        privacyStatus: metadata.privacyStatus || "private",
-                        embeddable: metadata.embeddable !== false,
-                        publicStatsViewable: metadata.publicStatsViewable !== false,
-                        license: metadata.license || "youtube",
-                        selfDeclaredMadeForKids: metadata.madeForKids || false
-                    }
+                requestBody: requestBody,
+                media: {
+                    body: videoStream,
+                    mimeType: 'video/*'
                 },
-                media: { body: videoStream }
+                notifySubscribers: metadata.notifySubscribers !== false
+            });
+
+            const videoId = uploadResponse.data.id;
+
+            if (!videoId) {
+                throw new YouTubeUploadError('Video ID not returned from YouTube API');
+            }
+
+            console.log(`✅ Video uploaded successfully: ${videoId}`);
+
+            // Wait for processing to complete
+            await this.waitForVideoProcessing(videoId);
+
+            const result: YouTubeUploadResult = {
+                id: videoId,
+                status: 'processed',
+                url: `https://www.youtube.com/watch?v=${videoId}`,
+                title: metadata.title,
+                description: metadata.description,
             };
 
-            // Upload video
-            const res = await this.youtube.videos.insert(metadataPayload);
-            return res.data;
+            console.log(`🎉 YouTube video published successfully: ${result.url}`);
+
+            return result;
 
         } catch (error: any) {
-            console.error("YouTube upload failed:", error.response?.data || error.message);
-            throw new Error(`YouTube upload failed: ${error.response?.data?.error?.message || error.message}`);
+            // Clean up stream
+            if (videoStream) {
+                videoStream.destroy();
+            }
+
+            console.error("YouTube upload failed:", error);
+
+            // Handle specific Google API errors
+            if (error.code === 401) {
+                throw new YouTubeAuthenticationError(
+                    'Authentication failed. Please reconnect your YouTube account. ' +
+                    'The access token may have expired or is invalid.'
+                );
+            } else if (error.code === 403) {
+                if (error.message?.includes('quota')) {
+                    throw new YouTubeQuotaError('YouTube API quota exceeded. Please try again tomorrow.');
+                } else {
+                    throw new YouTubeAuthenticationError('Access denied. Please check your YouTube permissions.');
+                }
+            } else if (error.code === 400) {
+                throw new YouTubeValidationError(`Invalid request: ${error.message}`);
+            } else if (error.code === 503) {
+                throw new YouTubeProcessingError('YouTube service temporarily unavailable. Please try again.');
+            } else {
+                throw new YouTubeApiError(`YouTube API error: ${error.message}`);
+            }
         }
     }
-}
+
+    /**
+     * Wait for video processing to complete using direct API calls
+     */
+    private async waitForVideoProcessing(videoId: string, timeoutMs: number = 300000): Promise<void> {
+        const startTime = Date.now();
+        const maxAttempts = 30;
+        let attempts = 0;
+
+        console.log(`⏳ Waiting for video processing: ${videoId}`);
+
+        while (attempts < maxAttempts && Date.now() - startTime < timeoutMs) {
+            attempts++;
+
+            try {
+                const statusResponse = await this.youtube.videos.list({
+                    part: ['status'],
+                    id: [videoId]
+                });
+
+                const video = statusResponse.data.items?.[0];
+                if (!video) {
+                    throw new YouTubeProcessingError(`Video ${videoId} not found after upload`);
+                }
+
+                const status = video.status?.uploadStatus;
+
+                switch (status) {
+                    case 'processed':
+                        console.log(`✅ Video processing completed: ${videoId}`);
+                        return;
+                    case 'failed':
+                        const failureReason = video.status?.failureReason || 'Unknown failure reason';
+                        throw new YouTubeProcessingError(`Video processing failed: ${failureReason}`);
+                    case 'rejected':
+                        const rejectionReason = video.status?.rejectionReason || 'Unknown rejection reason';
+                        throw new YouTubeProcessingError(`Video was rejected: ${rejectionReason}`);
+                    case 'uploaded':
+                    case 'processing':
+                        const waitTime = Math.min(1000 * Math.pow(2, attempts), 10000);
+                        console.log(`⏳ Video status: ${status}, waiting ${waitTime}ms...`);
+                        await new Promise(resolve => setTimeout(resolve, waitTime));
+                        break;
+                    default:
+                        await new Promise(resolve => setTimeout(resolve, 5000));
+                        break;
+                }
+            } catch (error: any) {
+                if (error instanceof YouTubeApiError) {
+                    throw error;
+                }
+                // Continue waiting on network errors
+                console.warn(`Error checking video status (attempt ${attempts}):`, error.message);
+                await new Promise(resolve => setTimeout(resolve, 5000));
+            }
+        }
+
+        throw new YouTubeTimeoutError(`Video processing timed out after ${timeoutMs}ms`);
+    }
+
+    /**
+     * Alternative method using direct axios calls (if Google client still has issues)
+     */
+    public async uploadFromCloudUrlDirect(videoUrl: string, metadata: VideoMetadata): Promise<YouTubeUploadResult> {
+        try {
+            console.log(`📹 Using direct upload method for: ${videoUrl}`);
+
+            // First, get the video file as buffer
+            const videoResponse = await axios.get(videoUrl, {
+                responseType: 'arraybuffer',
+                timeout: 30000,
+            });
+
+            const videoBuffer = Buffer.from(videoResponse.data);
+
+            // Prepare the metadata
+            const metadataPayload = {
+                snippet: {
+                    title: metadata.title.substring(0, 100),
+                    description: (metadata.description || "").substring(0, 5000),
+                    tags: metadata.tags || [],
+                    categoryId: metadata.categoryId || "22"
+                },
+                status: {
+                    privacyStatus: metadata.privacyStatus || "private",
+                    embeddable: metadata.embeddable !== false,
+                    publicStatsViewable: metadata.publicStatsViewable !== false,
+                    license: metadata.license || "youtube",
+                    selfDeclaredMadeForKids: metadata.madeForKids || false
+                }
+            };
+
+            // Upload using direct multipart request
+            const formData = new FormData();
+            formData.append('metadata', JSON.stringify(metadataPayload));
+            formData.append('video', new Blob([videoBuffer]), 'video.mp4');
+
+            const uploadResponse = await axios.post(
+                'https://www.googleapis.com/upload/youtube/v3/videos?part=snippet,status',
+                formData,
+                {
+                    headers: {
+                        'Authorization': `Bearer ${this.accessToken}`,
+                        'Content-Type': 'multipart/related',
+                    },
+                    maxContentLength: Infinity,
+                    maxBodyLength: Infinity,
+                    timeout: 60000,
+                }
+            );
+
+            const videoId = uploadResponse.data.id;
+
+            if (!videoId) {
+                throw new YouTubeUploadError('Video ID not returned from YouTube API');
+            }
+
+            console.log(`✅ Video uploaded successfully via direct method: ${videoId}`);
+
+            // Wait for processing
+            await this.waitForVideoProcessingDirect(videoId);
+
+            return {
+                id: videoId,
+                status: 'processed',
+                url: `https://www.youtube.com/watch?v=${videoId}`,
+                title: metadata.title,
+                description: metadata.description,
+            };
+
+        } catch (error: any) {
+            console.error("Direct YouTube upload failed:", error.response?.data || error.message);
+            
+            if (error.response?.status === 401) {
+                throw new YouTubeAuthenticationError(
+                    'Authentication failed. Please reconnect your YouTube account.'
+                );
+            } else if (error.response?.status === 403) {
+                throw new YouTubeQuotaError('YouTube API quota exceeded.');
+            } else {
+                throw new YouTubeApiError(`Upload failed: ${error.message}`);
+            }
+        }
+    }
+
+    /**
+     * Wait for processing using direct API calls
+     */
+    private async waitForVideoProcessingDirect(videoId: string, timeoutMs: number = 300000): Promise<void> {
+        const startTime = Date.now();
+        let attempts = 0;
+
+        while (Date.now() - startTime < timeoutMs) {
+            attempts++;
+
+            try {
+                const response = await axios.get(
+                    `https://www.googleapis.com/youtube/v3/videos?part=status&id=${videoId}`,
+                    {
+                        headers: {
+                            'Authorization': `Bearer ${this.accessToken}`
+                        }
+                    }
+                );
+
+                const video = response.data.items?.[0];
+                if (!video) {
+                    throw new YouTubeProcessingError(`Video ${videoId} not found`);
+                }
+
+                const status = video.status?.uploadStatus;
+
+                if (status === 'processed') {
+                    console.log(`✅ Video processing completed: ${videoId}`);
+                    return;
+                } else if (status === 'failed') {
+                    throw new YouTubeProcessingError(`Video processing failed: ${video.status?.failureReason}`);
+                } else if (status === 'rejected') {
+                    throw new YouTubeProcessingError(`Video rejected: ${video.status?.rejectionReason}`);
+                }
+
+                // Wait with exponential backoff
+                const waitTime = Math.min(1000 * Math.pow(2, attempts), 10000);
+                console.log(`⏳ Video status: ${status}, waiting ${waitTime}ms...`);
+                await new Promise(resolve => setTimeout(resolve, waitTime));
+
+            } catch (error: any) {
+                console.warn(`Error checking video status (attempt ${attempts}):`, error.message);
+                await new Promise(resolve => setTimeout(resolve, 5000));
+            }
+        }
+
+        throw new YouTubeTimeoutError(`Video processing timed out after ${timeoutMs}ms`);
+    }
+}