bb-fca 2.0.4 → 2.0.7

package/src/deltas/apis/posting/post.ts

@@ -13,6 +13,7 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
    * @param {string} options.message - The text content of the post.
    * @param {string} [options.privacy="SELF"] - Privacy setting: "EVERYONE", "FRIENDS", or "SELF".
    * @param {Array<string>} [options.photos] - Array of photo IDs to attach.
+   * @param {string} [options.video] - Video ID from uploadVideo() to attach.
    * @param {Function} [callback] - Optional callback function.
    * @returns {Promise<object>} The server's response containing post details.
    */
@@ -22,6 +23,7 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
       let postMessage = '';
       let privacy = 'SELF';
       let photos = [];
+      let videoId: string | null = null;
 
       if (typeof options === 'string') {
         postMessage = options;
@@ -29,6 +31,7 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
         postMessage = options.message || '';
         privacy = options.privacy || 'SELF';
         photos = options.photos || [];
+        videoId = options.video || null;
       } else {
         throw new Error('Invalid input: expected string or object.');
       }
@@ -118,6 +121,15 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
         isWorkSharedDraft: false,
         hashtag: null,
         canUserManageOffers: false,
+        __relay_internal__pv__CometUFIShareActionMigrationrelayprovider: true,
+        __relay_internal__pv__CometUFI_dedicated_comment_routable_dialog_gkrelayprovider: false,
+        __relay_internal__pv__CometUFICommentAutoTranslationTyperelayprovider: 'ORIGINAL',
+        __relay_internal__pv__IsWorkUserrelayprovider: false,
+        __relay_internal__pv__CometUFIReactionsEnableShortNamerelayprovider: false,
+        __relay_internal__pv__FBReels_deprecate_short_form_video_context_gkrelayprovider: true,
+        __relay_internal__pv__StoriesArmadilloReplyEnabledrelayprovider: true,
+        __relay_internal__pv__WorkCometIsEmployeeGKProviderrelayprovider: false,
+        __relay_internal__pv__IsMergQAPollsrelayprovider: false,
       };
       // Add photo attachments if provided
       if (photos && photos.length > 0) {
@@ -129,6 +141,26 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
             },
           }));
       }
+
+      // Add video attachment if provided
+      if (videoId) {
+        variables.input.attachments = [
+          {
+            video: {
+              audio_descriptions: null,
+              id: String(videoId),
+              additional_video_metadata: {
+                translatedAudioMetadata: [],
+              },
+              notify_when_processed: true,
+              transcriptions: null,
+              was_created_via_unified_video_flow: {
+                was_created_via_unified_video_flow: true,
+              },
+            },
+          },
+        ];
+      }
       const form = {
         av: ctx.userID,
         __user: ctx.userID,
@@ -147,7 +179,7 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
         fb_api_req_friendly_name: 'ComposerStoryCreateMutation',
         variables: JSON.stringify(variables),
         server_timestamps: 'true',
-        doc_id: '35233514182914739',
+        doc_id: videoId ? '26937332182536553' : '35233514182914739',
       };
 
       const postResult = await defaultFuncs
@@ -590,10 +622,416 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
     return returnPromise;
   }
 
+  /**
+   * Upload a video to Facebook using the 7-step resumable upload flow.
+   * Returns video_id which can be attached to a post via createPost.
+   * @param {string} videoPath - File path to the video file
+   * @param {Function} [callback] - Optional callback function
+   * @returns {Promise<object>} Object containing video ID and metadata
+   */
+  async function uploadVideo(videoPath, callback) {
+    let resolveFunc: Function = function() {};
+    let rejectFunc: Function = function() {};
+
+    const returnPromise = new Promise<any>(function(resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    callback =
+      callback ||
+      function(err, data) {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+
+    try {
+      if (!videoPath) {
+        throw new Error('Video path is required.');
+      }
+      if (typeof videoPath !== 'string') {
+        throw new Error('Video path must be a string.');
+      }
+      if (!fs.existsSync(videoPath)) {
+        throw new Error(`Video file not found: ${videoPath}`);
+      }
+
+      const path = require('path');
+      const crypto = require('crypto');
+
+      const fileBuffer = fs.readFileSync(videoPath);
+      const fileSize = fileBuffer.length;
+      const fileName = path.basename(videoPath);
+      const fileExtension = path
+        .extname(videoPath)
+        .replace('.', '')
+        .toLowerCase();
+
+      // Validate extension
+      const allowedExtensions = [
+        'gif',
+        'mov',
+        'mp4',
+        'avi',
+        'mkv',
+        'webm',
+        'wmv',
+        'flv',
+        'mpg',
+        'mpeg',
+        '3gp',
+        '3g2',
+        'm4v',
+        'ogv',
+      ];
+      if (!allowedExtensions.includes(fileExtension)) {
+        throw new Error(
+          `Unsupported video format: .${fileExtension}. Supported: ${allowedExtensions.join(
+            ', ',
+          )}`,
+        );
+      }
+
+      // Determine MIME type
+      const mimeTypes = {
+        mov: 'video/quicktime',
+        mp4: 'video/mp4',
+        avi: 'video/x-msvideo',
+        mkv: 'video/x-matroska',
+        webm: 'video/webm',
+        wmv: 'video/x-ms-wmv',
+        flv: 'video/x-flv',
+        mpg: 'video/mpeg',
+        mpeg: 'video/mpeg',
+        '3gp': 'video/3gpp',
+        '3g2': 'video/3gpp2',
+        m4v: 'video/x-m4v',
+        gif: 'image/gif',
+        ogv: 'video/ogg',
+      };
+      const mimeType = mimeTypes[fileExtension] || 'video/mp4';
+
+      // Generate IDs
+      const waterfallId = crypto.randomBytes(16).toString('hex');
+      const fileHash = crypto
+        .createHash('md5')
+        .update(fileBuffer)
+        .digest('hex');
+
+      // Common form params
+      const baseForm = {
+        av: ctx.userID,
+        __user: ctx.userID,
+        __a: '1',
+        __req: '1',
+        __ccg: 'EXCELLENT',
+        __comet_req: '15',
+        fb_dtsg: ctx.fb_dtsg,
+        jazoest: ctx.jazoest,
+        lsd: ctx.fb_dtsg,
+        fb_api_caller_class: 'RelayModern',
+      };
+
+      // ===== Step 1: Get Composer Video Uploader Config =====
+      const configForm = {
+        ...baseForm,
+        fb_api_req_friendly_name: 'useComposerVideoUploaderConfigQuery',
+        variables: JSON.stringify({
+          actorID: ctx.userID,
+          entryPoint: 'feed',
+          targetID: '',
+        }),
+        doc_id: '9734072893355148',
+      };
+
+      const configRes = await defaultFuncs
+        .post('https://www.facebook.com/api/graphql/', ctx.jar, configForm, {})
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+
+
+      // Extract config (endpoints, service info)
+      // NOTE: config is returned as a JSON string under data.viewer
+      let startUri =
+        'https://vupload2.facebook.com/ajax/video/upload/requests/start/';
+      let receiveUri =
+        'https://vupload2.facebook.com/ajax/video/upload/requests/receive/';
+      let ruploadServiceName = 'rupload-hkg1-2.up';
+      let ruploadServiceDomain = 'facebook.com';
+
+      try {
+        const configRaw =
+          configRes?.data?.viewer?.comet_composer_video_uploader_config;
+        if (configRaw) {
+          const configData =
+            typeof configRaw === 'string' ? JSON.parse(configRaw) : configRaw;
+          startUri = configData.start_uri || startUri;
+          receiveUri = configData.receive_uri || receiveUri;
+          ruploadServiceName =
+            configData.resumable_service_name || ruploadServiceName;
+          ruploadServiceDomain =
+            configData.resumable_service_domain || ruploadServiceDomain;
+        } else {
+        }
+      } catch (e) {
+        // Config parse error, use defaults
+      }
+
+      // ===== Step 2: Get Server Validation Config (optional, for validation) =====
+      const validationForm = {
+        ...baseForm,
+        fb_api_req_friendly_name:
+          'MediaUploadFBDefaultServerConfigurationRetrieverQuery',
+        variables: JSON.stringify({ source_type: 'newsfeed_composer' }),
+        doc_id: '24229633186643574',
+      };
+
+      const validationRes = await defaultFuncs
+        .post(
+          'https://www.facebook.com/api/graphql/',
+          ctx.jar,
+          validationForm,
+          {},
+        )
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+
+
+      // ===== Step 3: Initialize Upload Session =====
+      // Browser sends: POST vupload2.facebook.com/ajax/video/upload/requests/start/?__a=1
+      // Cross-subdomain: must manually extract cookies + send full auth params
+      const startRequestUrl = startUri + '?__a=1';
+
+      const startForm = {
+        // Upload-specific params
+        waterfall_id: waterfallId,
+        target_id: ctx.userID,
+        source: 'newsfeed_composer',
+        composer_entry_point_ref: 'feed',
+        supports_chunking: 'true',
+        supports_file_api: 'true',
+        file_size: String(fileSize),
+        file_extension: fileExtension,
+        partition_start_offset: '0',
+        partition_end_offset: String(fileSize),
+        composer_dialog_version: 'V2',
+        video_publisher_action_source: '',
+        // Auth params (must be explicit for cross-subdomain)
+        __aaid: '0',
+        __user: ctx.userID,
+        __a: '1',
+        __req: '1',
+        __hs: ctx.hs || '',
+        dpr: '2',
+        __ccg: 'EXCELLENT',
+        __rev: ctx.revision,
+        __comet_req: '15',
+        fb_dtsg: ctx.fb_dtsg,
+        jazoest: ctx.jazoest,
+        lsd: ctx.lsd,
+        av: ctx.userID,
+      };
+
+
+
+      const startRes = await utils
+        .post(startRequestUrl, ctx.jar, startForm, ctx.globalOptions, ctx, {
+          X_fb_video_waterfall_id: waterfallId,
+          Origin: 'https://www.facebook.com',
+          Referer: 'https://www.facebook.com/',
+          'Content-Type': 'application/x-www-form-urlencoded',
+          'Sec-Fetch-Dest': 'empty',
+          'Sec-Fetch-Mode': 'cors',
+          'Sec-Fetch-Site': 'same-site',
+        })
+
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+
+
+      const videoId = startRes?.payload?.video_id || startRes?.video_id;
+      const uploadSessionId =
+        startRes?.payload?.upload_session_id || startRes?.upload_session_id;
+      const startOffset =
+        startRes?.payload?.start_offset ?? startRes?.start_offset ?? 0;
+      const endOffset =
+        startRes?.payload?.end_offset ?? startRes?.end_offset ?? fileSize;
+
+      if (!videoId) {
+        throw new Error(
+          'Failed to get video_id from upload session init. Response: ' +
+            JSON.stringify(startRes),
+        );
+      }
+
+      // ===== Step 4: Probe rupload server =====
+      // Browser sends ALL auth params as query string on rupload URLs
+      const ruploadHost = `${ruploadServiceName}.${ruploadServiceDomain}`;
+      const ruploadPath = `/fb_video/${fileHash}-${startOffset}-${endOffset}`;
+      const ruploadAuthParams = new URLSearchParams({
+        __aaid: '0',
+        __user: ctx.userID,
+        __a: '1',
+        __req: '1',
+        dpr: '2',
+        __ccg: 'EXCELLENT',
+        __rev: ctx.revision || '',
+        __comet_req: '15',
+        fb_dtsg: ctx.fb_dtsg,
+        jazoest: ctx.jazoest,
+        lsd: ctx.lsd || '',
+      }).toString();
+      const ruploadBaseUrl = `https://${ruploadHost}${ruploadPath}?${ruploadAuthParams}`;
+
+      const corsHeaders = {
+        Origin: 'https://www.facebook.com',
+        Referer: 'https://www.facebook.com/',
+        'Sec-Fetch-Dest': 'empty',
+        'Sec-Fetch-Mode': 'cors',
+        'Sec-Fetch-Site': 'same-site',
+      };
+
+
+      const probeRes = await utils.get(
+        ruploadBaseUrl,
+        ctx.jar,
+        undefined,
+        ctx.globalOptions,
+        ctx,
+        corsHeaders,
+      );
+
+
+      // ===== Step 5: Upload Binary Data =====
+      const uploadHeaders = {
+        'Content-Type': 'application/octet-stream',
+        Product_media_id: String(videoId),
+        Id: String(uploadSessionId),
+        Start_offset: String(startOffset),
+        End_offset: String(endOffset),
+        Offset: String(startOffset),
+        'X-Entity-Length': String(fileSize),
+        'X-Total-Asset-Size': String(fileSize),
+        'X-Entity-Type': mimeType,
+        'X-Entity-Name': encodeURIComponent(fileName),
+        Composer_session_id: waterfallId,
+        ...corsHeaders,
+      };
+
+
+      const uploadRes = await utils.postRaw(
+        ruploadBaseUrl,
+        ctx.jar,
+        fileBuffer,
+        ctx.globalOptions,
+        ctx,
+        uploadHeaders,
+      );
+
+      let fileHandle: string | null = null;
+      try {
+        const uploadBody =
+          typeof uploadRes.body === 'string'
+            ? JSON.parse(uploadRes.body)
+            : uploadRes.body;
+        fileHandle = uploadBody?.h || null;
+      } catch (_) {
+        /* parse error */
+      }
+
+      if (!fileHandle) {
+        throw new Error(
+          'Failed to get file handle from binary upload. Response: ' +
+            JSON.stringify(uploadRes.body),
+        );
+      }
+
+      // ===== Step 6: Confirm Upload (Receive) =====
+      // Browser sends auth in form body, URL just has ?__a=1
+      const receiveUrl = new URL(receiveUri);
+      receiveUrl.searchParams.append('__a', '1');
+
+      const receiveForm = {
+        waterfall_id: waterfallId,
+        target_id: ctx.userID,
+        video_id: String(videoId),
+        source: 'newsfeed_composer',
+        composer_entry_point_ref: 'feed',
+        supports_chunking: 'true',
+        supports_upload_service: 'true',
+        partition_start_offset: String(startOffset),
+        partition_end_offset: String(endOffset),
+        start_offset: String(startOffset),
+        end_offset: String(endOffset),
+        upload_speed: '0',
+        fbuploader_video_file_chunk: fileHandle,
+        composer_dialog_version: 'V2',
+        // Auth params in form body (matching browser)
+        __aaid: '0',
+        __user: ctx.userID,
+        __a: '1',
+        __ccg: 'EXCELLENT',
+        __comet_req: '15',
+        fb_dtsg: ctx.fb_dtsg,
+        jazoest: ctx.jazoest,
+        lsd: ctx.lsd || '',
+      };
+
+
+      const receiveRes = await utils
+        .post(
+          receiveUrl.toString(),
+          ctx.jar,
+          receiveForm,
+          ctx.globalOptions,
+          ctx,
+          {
+            X_fb_video_waterfall_id: waterfallId,
+            ...corsHeaders,
+          },
+        )
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      // Verify upload complete: start_offset should equal end_offset
+      const recvStart =
+        receiveRes?.payload?.start_offset ?? receiveRes?.start_offset;
+      const recvEnd = receiveRes?.payload?.end_offset ?? receiveRes?.end_offset;
+      if (
+        recvStart !== undefined &&
+        recvEnd !== undefined &&
+        recvStart !== recvEnd
+      ) {
+        utils.warn(
+          'uploadVideo',
+          `Upload may be incomplete: start_offset=${recvStart}, end_offset=${recvEnd}`,
+        );
+      }
+
+      const result = {
+        success: true,
+        videoID: String(videoId),
+        videoId: String(videoId),
+        uploadID: waterfallId,
+        uploadSessionID: String(uploadSessionId),
+        fileHandle: fileHandle,
+        data: receiveRes,
+      };
+
+      callback(null, result);
+    } catch (err) {
+      utils.error('uploadVideo', err);
+      callback(err);
+    }
+
+    return returnPromise;
+  }
+
   return {
     create: createPost,
+    createPost: createPost,
     delete: deletePost,
     getComments: getPostComments,
     uploadPhoto: uploadPhoto,
+    uploadVideo: uploadVideo,
   };
 }

package/src/deltas/apis/posting/story.ts

@@ -1,3 +1,4 @@
+import * as fs from 'fs';
 import utils = require('../../../utils');
 import { URL } from 'url';
 
@@ -178,6 +179,140 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
     }
   }
 
+  /**
+   * Uploads a photo for story usage.
+   * Uses waterfallxapp=comet_stories to target the stories upload endpoint.
+   * @param {string} photoPath Absolute path to the photo file.
+   * @returns {Promise<{success: boolean, photoID: string, photoId: string, imageSrc: string, data: object}>}
+   */
+  async function uploadStoryPhoto(photoPath) {
+    if (!photoPath) {
+      throw new Error('Photo path is required.');
+    }
+    if (typeof photoPath !== 'string') {
+      throw new Error('Photo path must be a string.');
+    }
+    if (!fs.existsSync(photoPath)) {
+      throw new Error(`Photo file not found: ${photoPath}`);
+    }
+
+    const photoStream = fs.createReadStream(photoPath);
+
+    const url = new URL(
+      'https://upload.facebook.com/ajax/react_composer/attachments/photo/upload',
+    );
+    url.searchParams.append('av', ctx.userID);
+    url.searchParams.append('__aaid', '0');
+    url.searchParams.append('__user', ctx.userID);
+    url.searchParams.append('__a', '1');
+    url.searchParams.append('dpr', '1');
+    url.searchParams.append('__ccg', 'EXCELLENT');
+    url.searchParams.append('__comet_req', '15');
+    url.searchParams.append('fb_dtsg', ctx.fb_dtsg);
+    url.searchParams.append('jazoest', ctx.jazoest);
+    url.searchParams.append('lsd', ctx.fb_dtsg);
+
+    const form = {
+      source: '8',
+      profile_id: ctx.userID,
+      waterfallxapp: 'comet_stories',
+      farr: photoStream,
+    };
+
+    const uploadResponse = await utils.postFormData(
+      url.toString(),
+      ctx.jar,
+      form,
+      ctx.globalOptions,
+      ctx,
+    );
+
+    const uploadResult = JSON.parse(
+      uploadResponse.body.toString().replace(/^for \(;;\);/, ''),
+    );
+
+    if (uploadResult.error || uploadResult.errors) {
+      throw new Error(
+        JSON.stringify(uploadResult.error || uploadResult.errors),
+      );
+    }
+
+    const photoID =
+      uploadResult.payload?.photoID || uploadResult.payload?.fbid || null;
+
+    if (!photoID) {
+      throw new Error('Could not extract photoID from upload response.');
+    }
+
+    return {
+      success: true,
+      photoID: String(photoID),
+      photoId: String(photoID),
+      imageSrc: uploadResult.payload?.imageSrc || null,
+      data: uploadResult.payload,
+    };
+  }
+
+  /**
+   * Creates a new image-based story.
+   * @param {string} photoPath Absolute path to the photo file.
+   * @returns {Promise<{success: boolean, storyID: string}>} A promise that resolves with the new story's ID.
+   */
+  async function createImageStory(photoPath) {
+    // Step 1: Upload photo for story
+    const uploadResult = await uploadStoryPhoto(photoPath);
+
+    // Step 2: Create story with the uploaded photo
+    const variables = {
+      input: {
+        audiences: [{ stories: { self: { target_id: ctx.userID } } }],
+        audiences_is_complete: true,
+        logging: {
+          composer_session_id: 'createStoriesImage-' + Date.now(),
+        },
+        navigation_data: {
+          attribution_id_v2: 'StoriesCreateRoot.react,comet.stories.create',
+        },
+        source: 'WWW',
+        attachments: [
+          {
+            photo: {
+              id: uploadResult.photoID,
+              overlays: [],
+            },
+          },
+        ],
+        tracking: [null],
+        actor_id: ctx.userID,
+        client_mutation_id: '1',
+      },
+    };
+
+    const form = {
+      __a: '1',
+      fb_api_caller_class: 'RelayModern',
+      fb_api_req_friendly_name: 'StoriesCreateMutation',
+      variables: JSON.stringify(variables),
+      doc_id: '24226878183562473',
+    };
+
+    const res = await defaultFuncs.post(
+      'https://www.facebook.com/api/graphql/',
+      ctx.jar,
+      form,
+      {},
+    );
+    if (res.data.errors) throw new Error(JSON.stringify(res.data.errors));
+
+    const storyNode =
+      res.data?.data?.story_create?.viewer?.actor?.story_bucket?.nodes[0]
+        ?.first_story_to_show;
+    if (!storyNode || !storyNode.id)
+      throw new Error('Could not find the storyCardID in the response.');
+
+    return { success: true, storyID: storyNode.id };
+  }
+
   return {
     /**
      * Creates a new text-based story.
@@ -187,6 +322,18 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
      * @returns {Promise<{success: boolean, storyID: string}>}
      */
     create,
+    /**
+     * Uploads a photo for use in an image story.
+     * @param {string} photoPath Absolute path to the photo file.
+     * @returns {Promise<{success: boolean, photoID: string, photoId: string, imageSrc: string, data: object}>}
+     */
+    uploadStoryPhoto,
+    /**
+     * Creates a new image-based story. Handles upload + publish in one call.
+     * @param {string} photoPath Absolute path to the photo file.
+     * @returns {Promise<{success: boolean, storyID: string}>}
+     */
+    createImageStory,
     /**
      * Reacts to a story with a specific emoji.
      * @param {string} storyIdOrUrl The ID or full URL of the story to react to.