bb-fca 2.0.10 → 2.0.12

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

@@ -1,3 +1,4 @@
+import * as fs from 'fs';
 import utils = require('../../../utils');
 
 /**
@@ -632,6 +633,485 @@ export default function (defaultFuncs: any, api: any, ctx: any) {
         hasNextPage: Boolean(pageInfo.has_next_page),
       };
     },
+
+    /**
+     * Resolves a Facebook share URL to the actual group ID.
+     *
+     * Accepts various formats:
+     * - Full URL: `https://www.facebook.com/share/g/14bKqsywAfu/`
+     * - Path only: `/share/g/14bKqsywAfu/`
+     * - Short key: `14bKqsywAfu`
+     *
+     * @param {string} shareUrl The share URL, path, or short key to resolve.
+     * @returns {Promise<{ groupID: string; name: string | null; url: string | null }>}
+     *   The resolved group ID, name (if available), and canonical URL.
+     * @throws {Error} If the shareUrl is missing or the group ID cannot be extracted.
+     *
+     * @example
+     * const result = await api.group.resolveShareUrl('https://www.facebook.com/share/g/14bKqsywAfu/');
+     * console.log(result.groupID); // "1482314963016056"
+     */
+    resolveShareUrl: async function (
+      shareUrl: string,
+    ): Promise<{ groupID: string; name: string | null; url: string | null }> {
+      if (!shareUrl || typeof shareUrl !== 'string') {
+        throw new Error(
+          'resolveShareUrl: shareUrl must be a non-empty string.',
+        );
+      }
+
+      // Normalize input to a full URL
+      let fullUrl: string;
+      if (shareUrl.startsWith('http://') || shareUrl.startsWith('https://')) {
+        fullUrl = shareUrl;
+      } else if (shareUrl.startsWith('/')) {
+        fullUrl = 'https://www.facebook.com' + shareUrl;
+      } else {
+        // Assume it's just the short key
+        fullUrl = `https://www.facebook.com/share/g/${shareUrl}/`;
+      }
+
+      // Fetch the share page - Facebook will embed the group data in the HTML
+      const allJsonData = await utils.json(
+        fullUrl,
+        ctx.jar,
+        null,
+        ctx.globalOptions,
+        ctx,
+      );
+
+      if (!allJsonData || allJsonData.length === 0) {
+        throw new Error(
+          'resolveShareUrl: Could not fetch data from the share URL.',
+        );
+      }
+
+      // Strategy 1: Look for group object with __typename "Group" in the JSON data
+      let groupID: string | null = null;
+      let groupName: string | null = null;
+      let groupUrl: string | null = null;
+
+      const groupObj = deepFind(
+        allJsonData,
+        (val, _key) =>
+          val &&
+          typeof val === 'object' &&
+          val.__typename === 'Group' &&
+          typeof val.id === 'string',
+      );
+
+      if (groupObj) {
+        groupID = groupObj.id;
+        groupName = groupObj.name || null;
+        groupUrl = groupObj.url || null;
+      }
+
+      // Strategy 2: Look for groupID in various data patterns
+      if (!groupID) {
+        const groupIdVal = deepFind(
+          allJsonData,
+          (val, key) =>
+            (key === 'groupID' || key === 'group_id') &&
+            typeof val === 'string' &&
+            /^\d+$/.test(val),
+        );
+        if (groupIdVal) {
+          groupID = groupIdVal;
+        }
+      }
+
+      // Strategy 3: Look for meta property og:url or al:android:url containing group ID
+      if (!groupID) {
+        // Try to find the raw HTML response from the GET request
+        const res = await utils.get(
+          fullUrl,
+          ctx.jar,
+          null,
+          ctx.globalOptions,
+          ctx,
+        );
+        const html = typeof res.body === 'string' ? res.body : String(res.body);
+
+        // Try og:url meta tag: <meta property="og:url" content="https://www.facebook.com/groups/XXXXXXX/" />
+        const ogUrlMatch = html.match(
+          /property="og:url"\s+content="[^"]*\/groups\/(\d+)/,
+        );
+        if (ogUrlMatch) {
+          groupID = ogUrlMatch[1];
+        }
+
+        // Try al:android:url: fb://group/XXXXXXX
+        if (!groupID) {
+          const androidUrlMatch = html.match(
+            /property="al:android:url"\s+content="fb:\/\/group\/(\d+)"/,
+          );
+          if (androidUrlMatch) {
+            groupID = androidUrlMatch[1];
+          }
+        }
+
+        // Try entity_id pattern in the HTML
+        if (!groupID) {
+          const entityIdMatch = html.match(/"entity_id":"(\d+)"/);
+          if (entityIdMatch) {
+            groupID = entityIdMatch[1];
+          }
+        }
+
+        // Try groupID in the URL of the final redirect
+        if (!groupID) {
+          const groupUrlMatch = html.match(
+            /facebook\.com\/groups\/(\d+)/,
+          );
+          if (groupUrlMatch) {
+            groupID = groupUrlMatch[1];
+          }
+        }
+
+        // Extract group name from og:title if available
+        if (!groupName) {
+          const ogTitleMatch = html.match(
+            /property="og:title"\s+content="([^"]*)"/,
+          );
+          if (ogTitleMatch) {
+            groupName = ogTitleMatch[1];
+          }
+        }
+      }
+
+      if (!groupID) {
+        throw new Error(
+          'resolveShareUrl: Could not extract group ID from the share URL. ' +
+            'The link may be invalid, expired, or require authentication.',
+        );
+      }
+
+      if (!groupUrl) {
+        groupUrl = `https://www.facebook.com/groups/${groupID}/`;
+      }
+
+      return {
+        groupID,
+        name: groupName,
+        url: groupUrl,
+      };
+    },
+
+    /**
+     * Uploads a photo to Facebook for use in group posts.
+     *
+     * The photo is uploaded to `upload.facebook.com` with the group discussion
+     * route context (`CometGroupDiscussionRoute`), making it ready to be
+     * attached to a group post via {@link createGroupPost}.
+     *
+     * @param {string | string[]} photoPaths - A single file path or an array of file paths to upload.
+     * @returns {Promise<{ photoID: string; uploadID: string; data: any }[]>}
+     *   Array of upload results, one per photo, each containing:
+     *   - `photoID`  – The Facebook-assigned photo ID (use in `createGroupPost`).
+     *   - `uploadID` – The client-generated upload ID.
+     *   - `data`     – The raw server response payload.
+     * @throws {Error} If any path is missing, not a string, or doesn't exist on disk.
+     *
+     * @example
+     * const [photo] = await api.group.uploadPhoto('/path/to/image.jpg');
+     * const post = await api.group.createGroupPost('123456789', {
+     *   message: 'Check this out!',
+     *   photos: [photo.photoID],
+     * });
+     */
+    uploadPhoto: async function (
+      photoPaths: string | string[],
+    ): Promise<{ photoID: string; uploadID: string; data: any }[]> {
+      const paths = Array.isArray(photoPaths) ? photoPaths : [photoPaths];
+
+      if (paths.length === 0) {
+        throw new Error('uploadPhoto: at least one photo path is required.');
+      }
+
+      const results: { photoID: string; uploadID: string; data: any }[] = [];
+
+      for (const photoPath of paths) {
+        if (!photoPath || typeof photoPath !== 'string') {
+          throw new Error('uploadPhoto: each photo path must be a non-empty string.');
+        }
+        if (!fs.existsSync(photoPath)) {
+          throw new Error(`uploadPhoto: file not found: ${photoPath}`);
+        }
+
+        const photoStream = fs.createReadStream(photoPath);
+
+        const uploadId = `jsc_c_${Math.random().toString(36).substring(2, 11)}`;
+
+        // Build URL with query parameters matching the captured request
+        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('__req', '1');
+        url.searchParams.append('__hs', '20558.HCSV2:comet_pkg.2.1...0');
+        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.lsd || ctx.fb_dtsg);
+        url.searchParams.append('__spin_r', '1037381017');
+        url.searchParams.append('__spin_b', 'trunk');
+        url.searchParams.append('__spin_t', Math.floor(Date.now() / 1000).toString());
+        url.searchParams.append('__crn', 'comet.fbweb.CometGroupDiscussionRoute');
+
+        // Multipart form fields
+        const form = {
+          source: '8',
+          profile_id: ctx.userID,
+          waterfallxapp: 'comet',
+          farr: photoStream,
+          upload_id: uploadId,
+        };
+
+        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?.fbid ||
+          uploadResult.payload?.photoID ||
+          null;
+
+        results.push({
+          photoID: photoId,
+          uploadID: uploadId,
+          data: uploadResult,
+        });
+      }
+
+      return results;
+    },
+
+    /**
+     * Creates a post in a Facebook group, optionally with photo attachments and a title.
+     *
+     * @param {string} groupID - The ID of the group to post in.
+     * @param {object} options - Post options.
+     * @param {string} [options.message=''] - The text content of the post.
+     * @param {string} [options.title] - Optional post title (for groups that support titled posts).
+     * @param {string[]} [options.photos=[]] - Array of photo IDs from {@link uploadPhoto}.
+     * @returns {Promise<{ success: boolean; postID: string | null; url: string | null; data: any }>}
+     * @throws {Error} If groupID is missing or the API request fails.
+     *
+     * @example
+     * // Text-only post
+     * await api.group.createGroupPost('123456789', { message: 'Hello group!' });
+     *
+     * // Post with photos
+     * const photos = await api.group.uploadPhoto(['/path/a.jpg', '/path/b.jpg']);
+     * await api.group.createGroupPost('123456789', {
+     *   message: 'Check these out!',
+     *   photos: photos.map(p => p.photoID),
+     * });
+     *
+     * // Post with title and photos
+     * await api.group.createGroupPost('123456789', {
+     *   message: 'Post body here',
+     *   title: 'My Post Title',
+     *   photos: photos.map(p => p.photoID),
+     * });
+     */
+    createGroupPost: async function (
+      groupID: string,
+      options: { message?: string; title?: string; photos?: string[] } = {},
+    ): Promise<{
+      success: boolean;
+      postID: string | null;
+      url: string | null;
+      data: any;
+    }> {
+      if (!groupID) throw new Error('createGroupPost: groupID is required.');
+
+      const postMessage = options.message || '';
+      const postTitle = options.title || null;
+      const photos = options.photos || [];
+
+      const composerSessionId = createBsid();
+
+      const variables: any = {
+        input: {
+          composer_entry_point: 'inline_composer',
+          composer_source_surface: 'group',
+          composer_type: 'group',
+          logging: {
+            composer_session_id: composerSessionId,
+          },
+          source: 'WWW',
+          message: {
+            ranges: [],
+            text: postMessage,
+          },
+          with_tags_ids: null,
+          inline_activities: [],
+          text_format_preset_id: '0',
+          group_flair: {
+            flair_id: null,
+          },
+          composed_text: {
+            block_data: ['{}'],
+            block_depths: [0],
+            block_types: [0],
+            blocks: [postMessage],
+            entities: ['[]'],
+            entity_map: '{}',
+            inline_styles: ['[]'],
+          },
+          navigation_data: {
+            attribution_id_v2: `CometGroupDiscussionRoot.react,comet.group,tap_bookmark,${Date.now()},352021,${groupID},,`,
+          },
+          tracking: [null],
+          event_share_metadata: {
+            surface: 'newsfeed',
+          },
+          audience: {
+            to_id: groupID,
+          },
+          actor_id: ctx.userID,
+          client_mutation_id: Math.floor(Math.random() * 10 + 1).toString(),
+        },
+        feedLocation: 'GROUP',
+        feedbackSource: 0,
+        focusCommentID: null,
+        gridMediaWidth: null,
+        groupID: null,
+        scale: 1,
+        privacySelectorRenderLocation: 'COMET_STREAM',
+        checkPhotosToReelsUpsellEligibility: false,
+        referringStoryRenderLocation: null,
+        renderLocation: 'group',
+        useDefaultActor: false,
+        inviteShortLinkKey: null,
+        isFeed: false,
+        isFundraiser: false,
+        isFunFactPost: false,
+        isGroup: true,
+        isEvent: false,
+        isTimeline: false,
+        isSocialLearning: false,
+        isPageNewsFeed: false,
+        isProfileReviews: false,
+        isWorkSharedDraft: false,
+        canUserManageOffers: false,
+        __relay_internal__pv__CometUFIShareActionMigrationrelayprovider: true,
+        __relay_internal__pv__GHLShouldChangeSponsoredDataFieldNamerelayprovider: true,
+        __relay_internal__pv__GHLShouldChangeAdIdFieldNamerelayprovider: true,
+        __relay_internal__pv__CometUFI_dedicated_comment_routable_dialog_gkrelayprovider: true,
+        __relay_internal__pv__CometUFICommentAutoTranslationTyperelayprovider: 'ORIGINAL',
+        __relay_internal__pv__CometUFICommentAvatarStickerAnimatedImagerelayprovider: false,
+        __relay_internal__pv__CometUFICommentActionLinksRewriteEnabledrelayprovider: false,
+        __relay_internal__pv__IsWorkUserrelayprovider: false,
+        __relay_internal__pv__CometUFIReactionsEnableShortNamerelayprovider: false,
+        __relay_internal__pv__CometUFISingleLineUFIrelayprovider: false,
+        __relay_internal__pv__CometFeedStory_enable_post_permalink_white_space_clickrelayprovider: false,
+        __relay_internal__pv__TestPilotShouldIncludeDemoAdUseCaserelayprovider: false,
+        __relay_internal__pv__FBReels_deprecate_short_form_video_context_gkrelayprovider: true,
+        __relay_internal__pv__FBReels_enable_view_dubbed_audio_type_gkrelayprovider: true,
+        __relay_internal__pv__CometImmersivePhotoCanUserDisable3DMotionrelayprovider: false,
+        __relay_internal__pv__WorkCometIsEmployeeGKProviderrelayprovider: false,
+        __relay_internal__pv__IsMergQAPollsrelayprovider: false,
+        __relay_internal__pv__FBReelsMediaFooter_comet_enable_reels_ads_gkrelayprovider: true,
+        __relay_internal__pv__FBReelsIFUTileContent_reelsIFUPlayOnHoverrelayprovider: true,
+        __relay_internal__pv__GroupsCometGYSJFeedItemHeightrelayprovider: 150,
+        __relay_internal__pv__ShouldEnableBakedInTextStoriesrelayprovider: false,
+        __relay_internal__pv__StoriesShouldIncludeFbNotesrelayprovider: false,
+        __relay_internal__pv__groups_comet_use_glvrelayprovider: false,
+        __relay_internal__pv__GHLShouldChangeSponsoredAuctionDistanceFieldNamerelayprovider: false,
+        __relay_internal__pv__GHLShouldUseSponsoredAuctionLabelFieldNameV1relayprovider: false,
+        __relay_internal__pv__GHLShouldUseSponsoredAuctionLabelFieldNameV2relayprovider: false,
+      };
+
+      // Attach post title if provided
+      if (postTitle) {
+        variables.input.post_message_title = { text: postTitle };
+      }
+
+      // Attach photos if provided
+      if (photos.length > 0) {
+        variables.input.attachments = photos
+          .filter(Boolean)
+          .map((photoID) => ({
+            photo: { id: String(photoID) },
+          }));
+      }
+
+      const form = {
+        av: ctx.userID,
+        __aaid: '0',
+        __user: ctx.userID,
+        __a: '1',
+        __req: '1z',
+        __hs: '20558.HCSV2:comet_pkg.2.1...0',
+        dpr: '1',
+        __ccg: 'EXCELLENT',
+        __comet_req: '15',
+        locale: 'vi_VN',
+        fb_dtsg: ctx.fb_dtsg,
+        jazoest: ctx.jazoest,
+        lsd: ctx.lsd || ctx.fb_dtsg,
+        __spin_r: '1037381017',
+        __spin_b: 'trunk',
+        __spin_t: Math.floor(Date.now() / 1000).toString(),
+        __crn: 'comet.fbweb.CometGroupDiscussionRoute',
+        fb_api_caller_class: 'RelayModern',
+        fb_api_req_friendly_name: 'ComposerStoryCreateMutation',
+        variables: JSON.stringify(variables),
+        server_timestamps: 'true',
+        doc_id: '34999618373018994',
+      };
+
+      const customHeader = {
+        'x-fb-friendly-name': 'ComposerStoryCreateMutation',
+        'x-fb-lsd': ctx.lsd || '',
+        'x-asbd-id': '359341',
+        origin: 'https://www.facebook.com',
+        referer: `https://www.facebook.com/groups/${groupID}?locale=vi_VN`,
+      };
+
+      const res = await utils.post(
+        'https://www.facebook.com/api/graphql/',
+        ctx.jar,
+        form,
+        ctx.globalOptions,
+        ctx,
+        customHeader,
+      );
+
+      const data = parseResponseBody(res.body);
+
+      if (data?.errors) {
+        throw new Error(JSON.stringify(data.errors));
+      }
+
+      return {
+        success: true,
+        postID: data?.data?.story_create?.story?.id || null,
+        url: data?.data?.story_create?.story?.url || null,
+        data,
+      };
+    },
   };
 
   return groupModule;