bb-fca 2.0.7 → 2.0.9

package/dist/deltas/apis/posting/post.js

@@ -59,6 +59,7 @@ function default_1(defaultFuncs, api, ctx) {
             let privacy = 'SELF';
             let photos = [];
             let videoId = null;
+            let groupID = null;
             if (typeof options === 'string') {
                 postMessage = options;
             }
@@ -67,6 +68,7 @@ function default_1(defaultFuncs, api, ctx) {
                 privacy = options.privacy || 'SELF';
                 photos = options.photos || [];
                 videoId = options.video || null;
+                groupID = options.groupID || null;
             }
             else {
                 throw new Error('Invalid input: expected string or object.');
@@ -90,10 +92,11 @@ function default_1(defaultFuncs, api, ctx) {
                 .toString(36)
                 .substring(2)}`;
             const idempotenceToken = `${composerSessionId}_FEED`;
+            const isGroup = !!groupID;
             const variables = {
                 input: {
                     composer_entry_point: 'inline_composer',
-                    composer_source_surface: 'newsfeed',
+                    composer_source_surface: isGroup ? 'group' : 'newsfeed',
                     composer_type: 'feed',
                     idempotence_token: idempotenceToken,
                     source: 'WWW',
@@ -128,11 +131,11 @@ function default_1(defaultFuncs, api, ctx) {
                     actor_id: ctx.userID,
                     client_mutation_id: '1',
                 },
-                feedLocation: 'NEWSFEED',
+                feedLocation: isGroup ? 'GROUP' : 'NEWSFEED',
                 feedbackSource: 1,
                 focusCommentID: null,
                 gridMediaWidth: null,
-                groupID: null,
+                groupID: groupID,
                 scale: 2,
                 privacySelectorRenderLocation: 'COMET_STREAM',
                 checkPhotosToReelsUpsellEligibility: true,
@@ -143,7 +146,7 @@ function default_1(defaultFuncs, api, ctx) {
                 isFeed: true,
                 isFundraiser: false,
                 isFunFactPost: false,
-                isGroup: false,
+                isGroup: isGroup,
                 isEvent: false,
                 isTimeline: false,
                 isSocialLearning: false,
@@ -300,14 +303,26 @@ function default_1(defaultFuncs, api, ctx) {
         }
     }
     /**
-     * Gets comments from a Facebook post.
-     * @param {string|object} postID - The post ID (string) or options object.
-     * @param {string} postID.story_fbid - The story FBID from the permalink URL.
-     * @param {string} postID.id - The account ID from the permalink URL.
+     * Gets comments from a Facebook post, with pagination support.
+     * @param {string|object} postID - The post URL (string) or options object.
+     * @param {string} [postID.url] - Direct Facebook post URL.
+     * @param {string} [postID.story_fbid] - The story FBID.
+     * @param {string} [postID.id] - The account ID.
+     * @param {string} [postID.after] - Cursor string to fetch the next page.
+     * @param {string} [postID.feedback_id] - Feedback ID required for pagination (returned in page_info).
      * @param {Function} [callback] - Optional callback function.
-     * @returns {Promise<Array>} Array of comments with author info, text, timestamps, etc.
+     * @returns {Promise<{comments: Array, page_info: object}>} Object with comments array and pagination info.
      */
-    async function getPostComments(postID, callback) {
+    async function getPostComments(postID, optionsOrCallback, callback) {
+        // Support: getComments(url), getComments(url, cb), getComments(url, opts), getComments(url, opts, cb)
+        let paginationOpts = null;
+        if (typeof optionsOrCallback === 'function') {
+            callback = optionsOrCallback;
+        }
+        else if (typeof optionsOrCallback === 'object' &&
+            optionsOrCallback !== null) {
+            paginationOpts = optionsOrCallback;
+        }
         let resolveFunc = function () { };
         let rejectFunc = function () { };
         const returnPromise = new Promise(function (resolve, reject) {
@@ -322,31 +337,153 @@ function default_1(defaultFuncs, api, ctx) {
                     resolveFunc(data);
                 };
         try {
-            let story_fbid, accountID;
-            // Handle both string and object input
+            // ── Pagination mode: fetch next page via GraphQL ──────────────────
+            // Merge pagination from either postID (object) or second-arg options
+            const afterCursor = paginationOpts?.after ||
+                (typeof postID === 'object' && postID !== null
+                    ? postID.after
+                    : undefined);
+            const feedbackId = paginationOpts?.feedback_id ||
+                (typeof postID === 'object' && postID !== null
+                    ? postID.feedback_id
+                    : undefined);
+            if (afterCursor && feedbackId) {
+                // Use GraphQL to fetch next page of comments using the cursor
+                // feedbackId is the GraphQL ID (base64 of "feedback:<numeric_id>")
+                const variables = {
+                    commentsAfterCount: -1,
+                    commentsAfterCursor: afterCursor,
+                    commentsBeforeCount: null,
+                    commentsBeforeCursor: null,
+                    commentsIntentToken: null,
+                    feedLocation: 'POST_PERMALINK_DIALOG',
+                    focusCommentID: null,
+                    scale: 1,
+                    useDefaultActor: false,
+                    id: feedbackId,
+                    __relay_internal__pv__CometUFICommentAutoTranslationTyperelayprovider: 'ORIGINAL',
+                    __relay_internal__pv__CometUFICommentAvatarStickerAnimatedImagerelayprovider: false,
+                    __relay_internal__pv__CometUFICommentActionLinksRewriteEnabledrelayprovider: false,
+                    __relay_internal__pv__IsWorkUserrelayprovider: false,
+                };
+                const form = {
+                    av: ctx.userID,
+                    fb_api_caller_class: 'RelayModern',
+                    fb_api_req_friendly_name: 'CommentsListComponentsPaginationQuery',
+                    variables: JSON.stringify(variables),
+                    doc_id: '35385759421023325',
+                    server_timestamps: 'true',
+                };
+                const gqlRes = await defaultFuncs.post('https://www.facebook.com/api/graphql/', ctx.jar, form, ctx.globalOptions, ctx);
+                let gqlData;
+                if (typeof gqlRes.body === 'object' &&
+                    gqlRes.body !== null &&
+                    !Buffer.isBuffer(gqlRes.body)) {
+                    gqlData = gqlRes.body;
+                }
+                else {
+                    const body = gqlRes.body.toString();
+                    try {
+                        gqlData = JSON.parse(body);
+                    }
+                    catch (e) {
+                        // Multi-line JSON stream — take first line
+                        gqlData = JSON.parse(body.split('\n')[0]);
+                    }
+                }
+                // Navigate to comments in GraphQL response
+                const commentsConnection = gqlData?.data?.node?.comment_rendering_instance_for_feed_location
+                    ?.comments ??
+                    gqlData?.data?.feedback?.comment_rendering_instance_for_feed_location
+                        ?.comments ??
+                    null;
+                const result = [];
+                let page_info = null;
+                if (commentsConnection) {
+                    page_info = commentsConnection.page_info || null;
+                    (commentsConnection.edges || []).forEach((edge) => {
+                        if (!edge?.node)
+                            return;
+                        const c = {
+                            id: edge.node.legacy_fbid,
+                            graphql_id: edge.node.id,
+                            text: edge.node.body?.text || edge.node.preferred_body?.text || '',
+                            created_time: edge.node.created_time,
+                            author: {
+                                id: edge.node.author?.id,
+                                name: edge.node.author?.name,
+                                avatar: edge.node.author?.profile_picture_depth_0?.uri,
+                            },
+                            reply_count: edge.node.feedback?.replies_fields?.count || 0,
+                            total_reply_count: edge.node.feedback?.replies_fields?.total_count || 0,
+                            depth: edge.node.depth || 0,
+                            attachments: edge.node.attachments || [],
+                        };
+                        if (edge.node.feedback?.replies_connection?.edges) {
+                            c.replies = edge.node.feedback.replies_connection.edges
+                                .map((re) => {
+                                if (!re?.node)
+                                    return null;
+                                return {
+                                    id: re.node.legacy_fbid,
+                                    text: re.node.body?.text || re.node.preferred_body?.text || '',
+                                    created_time: re.node.created_time,
+                                    author: {
+                                        id: re.node.author?.id,
+                                        name: re.node.author?.name,
+                                        avatar: re.node.author?.profile_picture_depth_0?.uri,
+                                    },
+                                };
+                            })
+                                .filter((r) => r !== null);
+                        }
+                        result.push(c);
+                    });
+                }
+                callback(null, { comments: result, page_info });
+                return returnPromise;
+            }
+            // ── Initial load mode: fetch HTML and parse ───────────────────────
+            let url;
             if (typeof postID === 'string') {
-                // If it's a simple post ID, construct URL with user's ID
-                story_fbid = postID;
-                accountID = ctx.userID;
+                if (postID.startsWith('https://') || postID.startsWith('http://')) {
+                    url = postID;
+                }
+                else if (postID.startsWith('/')) {
+                    url = `https://www.facebook.com${postID}`;
+                }
+                else if (/^\d+$/.test(postID)) {
+                    url = `https://www.facebook.com/permalink.php?story_fbid=${postID}&id=${ctx.userID}`;
+                }
+                else {
+                    url = `https://www.facebook.com/permalink.php?story_fbid=${postID}&id=${ctx.userID}`;
+                }
             }
-            else if (typeof postID === 'object') {
-                story_fbid = postID.story_fbid;
-                accountID = postID.id || ctx.userID;
+            else if (typeof postID === 'object' && postID !== null) {
+                const story_fbid = postID.story_fbid;
+                const accountID = postID.id || ctx.userID;
+                const postUrl = postID.url;
+                if (postUrl) {
+                    url = postUrl.startsWith('http')
+                        ? postUrl
+                        : `https://www.facebook.com${postUrl}`;
+                }
+                else if (story_fbid) {
+                    url = `https://www.facebook.com/permalink.php?story_fbid=${story_fbid}&id=${accountID}`;
+                }
+                else {
+                    throw new Error('Object input must have story_fbid or url field.');
+                }
             }
             else {
-                throw new Error('Invalid input: expected string or object with story_fbid and id.');
-            }
-            if (!story_fbid) {
-                throw new Error('Post ID or story_fbid is required.');
+                throw new Error('Invalid input: expected string (URL or postID) or object with story_fbid/url.');
             }
-            // Construct the permalink URL
-            const url = `https://www.facebook.com/permalink.php?story_fbid=${story_fbid}&id=${accountID}`;
             // Make GET request to fetch the page HTML with cookies
             const resData = await utils.get(url, ctx.jar, {}, ctx.globalOptions, ctx);
             const html = resData.body.toString();
-            // Extract comments using new logic
-            const commentList = extractCommentsFromHTML(html);
-            callback(null, commentList);
+            // Extract comments and page_info from HTML
+            const { comments, page_info } = extractCommentsFromHTML(html);
+            callback(null, { comments, page_info });
         }
         catch (err) {
             utils.error('getPostComments', err);
@@ -372,14 +509,16 @@ function default_1(defaultFuncs, api, ctx) {
     /**
      * Extract comments from HTML using new parsing logic
      * @private
+     * @returns {{ comments: any[], page_info: any | null }}
      */
     function extractCommentsFromHTML(htmlContent) {
         const comments = [];
+        let page_info = null;
         try {
             // Find all script tags containing JSON data
             const scriptMatches = htmlContent.match(/<script type="application\/json"\s+data-content-len="\d+"\s+data-sjs>(.*?)<\/script>/gs);
             if (!scriptMatches) {
-                return comments;
+                return { comments, page_info };
             }
             // Loop through each script tag
             for (const scriptMatch of scriptMatches) {
@@ -427,6 +566,26 @@ function default_1(defaultFuncs, api, ctx) {
                                         if (commentData &&
                                             commentData.edges &&
                                             Array.isArray(commentData.edges)) {
+                                            // Extract page_info (cursor pagination info)
+                                            if (commentData.page_info && !page_info) {
+                                                page_info = {
+                                                    end_cursor: commentData.page_info.end_cursor || null,
+                                                    has_next_page: commentData.page_info.has_next_page || false,
+                                                    has_previous_page: commentData.page_info.has_previous_page || false,
+                                                    start_cursor: commentData.page_info.start_cursor || null,
+                                                };
+                                                // Also try to capture feedback_id for GraphQL pagination
+                                                try {
+                                                    const feedback = result.data.node_v2?.comet_sections?.feedback?.story
+                                                        ?.story_ufi_container?.story?.feedback_context
+                                                        ?.feedback_target_with_context
+                                                        ?.comment_list_renderer?.feedback;
+                                                    if (feedback?.id && !page_info.feedback_id) {
+                                                        page_info.feedback_id = feedback.id;
+                                                    }
+                                                }
+                                                catch (_) { }
+                                            }
                                             // Extract comments
                                             commentData.edges.forEach((edge) => {
                                                 if (!edge.node)
@@ -489,7 +648,195 @@ function default_1(defaultFuncs, api, ctx) {
         catch (error) {
             utils.error('extractCommentsFromHTML', error);
         }
-        return comments;
+        return { comments, page_info };
+    }
+    /**
+     * Extract the numeric `post_id` (and related IDs) from a Facebook post HTML page.
+     *
+     * This follows the same pipeline as `getPostComments`:
+     * 1. Fetches the page HTML with session cookies (GET request).
+     * 2. Scans every `<script type="application/json" data-sjs>` block.
+     * 3. Searches each parsed JSON tree for `"post_id"` strings (and `"story_id"`,
+     *    `"feedback_id"`, etc.) that appear alongside the post data.
+     *
+     * Works with **all** URL formats:
+     * - `/posts/pfbid{token}`  ← pfbid (server resolves it during HTML render)
+     * - `/posts/{numericID}`
+     * - `permalink.php?story_fbid=...`
+     *
+     * @param {string} urlOrID - Full Facebook post URL, or a plain numeric post ID.
+     *   If a numeric ID is passed, it is fetched as
+     *   `facebook.com/permalink.php?story_fbid={id}&id={userID}`.
+     * @param {Function} [callback] - Optional node-style `(err, result)` callback.
+     * @returns {Promise<{
+     *   post_id:     string | null,   // numeric post ID found in HTML ("post_id":"…")
+     *   story_id:    string | null,   // numeric story/post ID (alias)
+     *   feedback_id: string | null,   // base64 GraphQL feedback ID
+     *   post_url:    string,          // URL that was actually fetched
+     * }>}
+     *
+     * @example
+     * const { post_id } = await api.post.getPostIDFromURL(
+     *   'https://www.facebook.com/tuyetcollection/posts/pfbid0Yo6XDaKKnFKpENu3g2c2to1zJe7jFoZNr2NqjiXRiHmwjsy8dwbE84y4n7syCSfMl'
+     * );
+     * console.log(post_id);  // '1510599910435387'
+     *
+     * // Then react using the real numeric ID
+     * await api.post.reactWithInfo(post_id, 'LOVE');
+     */
+    async function getPostIDFromURL(urlOrID, callback) {
+        let resolveFunc = function () { };
+        let rejectFunc = function () { };
+        const returnPromise = new Promise((resolve, reject) => {
+            resolveFunc = resolve;
+            rejectFunc = reject;
+        });
+        callback =
+            callback ||
+                function (err, data) {
+                    if (err)
+                        return rejectFunc(err);
+                    resolveFunc(data);
+                };
+        try {
+            if (!urlOrID)
+                throw new Error('urlOrID is required.');
+            // ── Build fetch URL ────────────────────────────────────────────────
+            let fetchUrl;
+            if (urlOrID.startsWith('http://') || urlOrID.startsWith('https://')) {
+                fetchUrl = urlOrID;
+            }
+            else if (urlOrID.startsWith('/')) {
+                fetchUrl = `https://www.facebook.com${urlOrID}`;
+            }
+            else if (/^\d+$/.test(urlOrID)) {
+                // plain numeric ID → use permalink.php format (same as getPostComments)
+                fetchUrl = `https://www.facebook.com/permalink.php?story_fbid=${urlOrID}&id=${ctx.userID}`;
+            }
+            else {
+                // pfbid token without full URL
+                fetchUrl = `https://www.facebook.com/permalink.php?story_fbid=${urlOrID}&id=${ctx.userID}`;
+            }
+            // ── Fetch HTML ─────────────────────────────────────────────────────
+            const resData = await utils.get(fetchUrl, ctx.jar, {}, ctx.globalOptions, ctx);
+            const html = resData.body.toString();
+            // ── Helpers ────────────────────────────────────────────────────────
+            /** Deep-search an object tree; call visitor(value, key) on every value. */
+            function deepSearch(obj, visitor) {
+                if (!obj || typeof obj !== 'object')
+                    return;
+                for (const key of Object.keys(obj)) {
+                    visitor(obj[key], key);
+                    deepSearch(obj[key], visitor);
+                }
+            }
+            /** Find the first string value of `fieldName` anywhere in `obj`. */
+            function findField(obj, fieldName) {
+                let found = null;
+                deepSearch(obj, (v, k) => {
+                    if (found)
+                        return;
+                    if (k === fieldName && typeof v === 'string' && v.length > 0) {
+                        found = v;
+                    }
+                });
+                return found;
+            }
+            // ── Parse <script data-sjs> blocks (same as getPostComments) ───────
+            const scriptMatches = html.match(/<script type="application\/json"\s+data-content-len="\d+"\s+data-sjs>(.*?)<\/script>/gs);
+            let post_id = null;
+            let story_id = null;
+            let feedback_id = null;
+            if (scriptMatches) {
+                outer: for (const scriptTag of scriptMatches) {
+                    try {
+                        const inner = scriptTag.match(/<script[^>]*>(.*?)<\/script>/s);
+                        if (!inner)
+                            continue;
+                        const jsonData = JSON.parse(inner[1]);
+                        if (!jsonData.require || !Array.isArray(jsonData.require))
+                            continue;
+                        for (const req of jsonData.require) {
+                            if (!Array.isArray(req))
+                                continue;
+                            if (req[0] === 'ScheduledServerJS' && req[1] === 'handle') {
+                                const payload = req[3];
+                                if (!payload || !Array.isArray(payload))
+                                    continue;
+                                for (const item of payload) {
+                                    if (!item.__bbox?.require)
+                                        continue;
+                                    for (const bboxReq of item.__bbox.require) {
+                                        if (!Array.isArray(bboxReq))
+                                            continue;
+                                        if (bboxReq[0] === 'RelayPrefetchedStreamCache' &&
+                                            bboxReq[1] === 'next') {
+                                            const streamData = bboxReq[3];
+                                            if (!Array.isArray(streamData) || streamData.length < 2)
+                                                continue;
+                                            const bboxData = streamData[1];
+                                            if (!bboxData?.__bbox?.result)
+                                                continue;
+                                            const result = bboxData.__bbox.result;
+                                            // ── Search for post_id / story_id ─────────────────
+                                            if (!post_id)
+                                                post_id = findField(result, 'post_id');
+                                            if (!story_id)
+                                                story_id = findField(result, 'story_id');
+                                            // ── Search for feedback_id (same path as getPostComments) ──
+                                            if (!feedback_id) {
+                                                try {
+                                                    const feedback = result.data?.node_v2?.comet_sections?.feedback
+                                                        ?.story?.story_ufi_container?.story
+                                                        ?.feedback_context?.feedback_target_with_context
+                                                        ?.comment_list_renderer?.feedback;
+                                                    if (feedback?.id)
+                                                        feedback_id = feedback.id;
+                                                }
+                                                catch (_) { }
+                                                // Fallback: deep-search for feedback_id string
+                                                if (!feedback_id)
+                                                    feedback_id = findField(result, 'feedback_id');
+                                            }
+                                            // Stop once we have the numeric post_id
+                                            if (post_id)
+                                                break outer;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    catch (_) {
+                        continue; // skip malformed JSON blocks
+                    }
+                }
+            }
+            // ── Fallback: regex scan on raw HTML ────────────────────────────────
+            // "post_id":"1510599910435387"  or  "post_id":1510599910435387
+            if (!post_id) {
+                const m = html.match(/"post_id"\s*:\s*"?(\d{10,20})"?/);
+                if (m)
+                    post_id = m[1];
+            }
+            if (!story_id) {
+                const m = html.match(/"story_id"\s*:\s*"?(\d{10,20})"?/);
+                if (m)
+                    story_id = m[1];
+            }
+            const resultObj = {
+                post_id,
+                story_id: story_id || post_id, // they're often the same
+                feedback_id,
+                post_url: fetchUrl,
+            };
+            callback(null, resultObj);
+        }
+        catch (err) {
+            utils.error('getPostIDFromURL', err);
+            callback(err);
+        }
+        return returnPromise;
     }
     /**
      * Upload a photo to Facebook
@@ -884,11 +1231,606 @@ function default_1(defaultFuncs, api, ctx) {
         }
         return returnPromise;
     }
+    /**
+     * React to a Facebook post (like, love, haha, wow, sad, angry).
+     *
+     * @param {string} feedbackId - The feedback ID. Can be:
+     *   - A raw numeric post ID (e.g. "1624250182241514")
+     *   - A base64-encoded feedback ID (e.g. "ZmVlZGJhY2s6MTYyN...")
+     *   - The literal string "feedback:<postID>"
+     * @param {string} [reaction="LIKE"] - Reaction type:
+     *   "LIKE" | "LOVE" | "HAHA" | "WOW" | "SAD" | "ANGRY" | "CARE"
+     *   or equivalent emojis: "👍" | "❤️" | "😂" | "😮" | "😢" | "😡" | "🤗"
+     * @param {Function} [callback] - Optional callback function.
+     * @returns {Promise<object>} The server response.
+     */
+    async function reactToPost(feedbackId, reaction = 'LIKE', callback) {
+        try {
+            if (!feedbackId) {
+                throw new Error('feedbackId is required.');
+            }
+            // ── Reaction ID map ────────────────────────────────────────────────
+            // IDs sourced from live Facebook reaction metadata.
+            // Only non-deprecated reactions are listed as primary keys.
+            // Deprecated reactions kept for backward-compat.
+            const REACTION_IDS = {
+                // ── Active reactions ─────────────────────────────────────────────
+                LIKE: '1635855486666999', // Thích       (type:1)  #0866FF
+                LOVE: '1678524932434102', // Yêu thích   (type:2)  #f33e58
+                WOW: '478547315650144', // Wow         (type:3)  #f7b125
+                HAHA: '115940658764963', // Haha        (type:4)  #f7b125
+                SAD: '908563459236466', // Buồn        (type:7)  #f7b125
+                ANGRY: '444813342392137', // Phẫn nộ     (type:8)  #e9710f
+                CARE: '613557422527858', // Thương thương (type:16) #f7b125
+                SUPPORT: '613557422527858', // alias CARE
+                DOROTHY: '1663186627268800', // Biết ơn     (type:11) #7e64c4
+                TOTO: '899779720071651', // Tự hào      (type:12) #ec7ebd
+                // ── Deprecated (kept for backward-compat) ────────────────────────
+                YAY: '1667835766830853', // Chúc mừng  (type:5  - deprecated)
+                CONFUSED: '1536130110011063', // Khó hiểu   (type:10 - deprecated)
+                SELFIE: '869508936487422', // Ảnh selfie  (type:13 - deprecated)
+                FLAME: '938644726258608', // Bày tỏ (flame, type:14 - deprecated)
+                PLANE: '1609920819308489', // Bày tỏ (plane, type:15 - deprecated)
+                // ── Emoji aliases ────────────────────────────────────────────────
+                '👍': '1635855486666999', // LIKE
+                '❤️': '1678524932434102', // LOVE
+                '😮': '478547315650144', // WOW
+                '😂': '115940658764963', // HAHA
+                '😢': '908563459236466', // SAD
+                '😡': '444813342392137', // ANGRY
+                '🤗': '613557422527858', // CARE/Support
+                // ── Vietnamese name aliases ──────────────────────────────────────
+                'THÍCH': '1635855486666999',
+                'YÊU THÍCH': '1678524932434102',
+                'BUỒN': '908563459236466',
+                'PHẪN NỘ': '444813342392137',
+                'THƯƠNG THƯƠNG': '613557422527858',
+                'BIẾT ƠN': '1663186627268800',
+                'TỰ HÀO': '899779720071651',
+            };
+            const reactionKey = reaction.toUpperCase
+                ? reaction.toUpperCase()
+                : reaction;
+            const reactionId = REACTION_IDS[reactionKey] || REACTION_IDS[reaction];
+            if (!reactionId) {
+                throw new Error(`Unknown reaction: "${reaction}". Valid values: LIKE, LOVE, WOW, HAHA, SAD, ANGRY, CARE, SUPPORT, DOROTHY, TOTO`);
+            }
+            // ── Normalise feedbackId → base64 "feedback:<postID>" format ───────
+            let encodedFeedbackId = feedbackId;
+            // Plain numeric post ID → encode
+            if (/^\d+$/.test(feedbackId)) {
+                encodedFeedbackId = Buffer.from(`feedback:${feedbackId}`).toString('base64');
+            }
+            else {
+                // Try to detect if it's already a valid base64 string by decoding
+                try {
+                    const decoded = Buffer.from(feedbackId, 'base64').toString('utf-8');
+                    if (!decoded.startsWith('feedback:')) {
+                        // Not yet a feedback base64 – wrap and encode
+                        const raw = feedbackId.startsWith('feedback:')
+                            ? feedbackId
+                            : `feedback:${feedbackId}`;
+                        encodedFeedbackId = Buffer.from(raw).toString('base64');
+                    }
+                    // else already properly encoded – keep as-is
+                }
+                catch (_) {
+                    // keep original value
+                }
+            }
+            // ── Build session IDs ──────────────────────────────────────────────
+            const crypto = require('node:crypto');
+            const sessionId = crypto.randomUUID
+                ? crypto.randomUUID()
+                : [
+                    crypto.randomBytes(4).toString('hex'),
+                    crypto.randomBytes(2).toString('hex'),
+                    crypto.randomBytes(2).toString('hex'),
+                    crypto.randomBytes(2).toString('hex'),
+                    crypto.randomBytes(6).toString('hex'),
+                ].join('-');
+            const downstreamSessionId = crypto.randomUUID
+                ? crypto.randomUUID()
+                : [
+                    crypto.randomBytes(4).toString('hex'),
+                    crypto.randomBytes(2).toString('hex'),
+                    crypto.randomBytes(2).toString('hex'),
+                    crypto.randomBytes(2).toString('hex'),
+                    crypto.randomBytes(6).toString('hex'),
+                ].join('-');
+            // ── Variables payload (mirrors CometUFIFeedbackReactMutation) ──────
+            const variables = {
+                input: {
+                    // attribution_id_v2 identifies the React component tree that triggered
+                    // the reaction (format: "<Component>,<surface>,<trigger>,<ts>,<seq>,<groupID>,,").
+                    // Pass ctx.attribution_id_v2 when you have it from a page scrape.
+                    attribution_id_v2: ctx.attribution_id_v2 || '',
+                    feedback_id: encodedFeedbackId,
+                    feedback_reaction_id: reactionId,
+                    feedback_source: 'OBJECT',
+                    is_tracking_encrypted: true,
+                    // tracking is an encrypted server-generated token array.
+                    // Carry it through ctx when available; fall back to [].
+                    tracking: Array.isArray(ctx.tracking) && ctx.tracking.length
+                        ? ctx.tracking
+                        : [],
+                    session_id: sessionId,
+                    downstream_share_session_id: downstreamSessionId,
+                    // The page URL where the reaction was performed
+                    downstream_share_session_origin_uri: ctx.currentUrl || 'https://www.facebook.com/',
+                    downstream_share_session_start_time: String(Date.now()),
+                    actor_id: ctx.userID,
+                    client_mutation_id: String(Math.floor(Math.random() * 10)),
+                },
+                useDefaultActor: false,
+                __relay_internal__pv__CometUFIReactionsEnableShortNamerelayprovider: false,
+            };
+            // ── POST to /api/graphql/ ──────────────────────────────────────────
+            // Includes every form field present in the original captured request.
+            const lsd = ctx.lsd || ctx.fb_dtsg;
+            const form = {
+                av: ctx.userID,
+                __aaid: '0',
+                __user: ctx.userID,
+                __a: '1',
+                __req: Math.floor(Math.random() * 99).toString(36),
+                // Opaque session-state tokens generated by the browser on every page
+                // load. Carry them through ctx when available so they match the live
+                // session; otherwise fall back to empty strings (FB tolerates it).
+                __hs: ctx.hs || '20536.HCSV2:comet_pkg.2.1...0',
+                dpr: '1',
+                __ccg: 'EXCELLENT',
+                __rev: ctx.revision || '',
+                __s: ctx.__s || '',
+                __hsi: ctx.__hsi || '',
+                __dyn: ctx.__dyn || '',
+                __csr: ctx.__csr || '',
+                __hsdp: ctx.__hsdp || '',
+                __hblp: ctx.__hblp || '',
+                __sjsp: ctx.__sjsp || '',
+                __comet_req: '15',
+                fb_dtsg: ctx.fb_dtsg,
+                jazoest: ctx.jazoest,
+                lsd,
+                __spin_r: ctx.revision || '',
+                __spin_b: 'trunk',
+                __spin_t: Math.floor(Date.now() / 1000).toString(),
+                // __crn is the Comet route name (page type). Use ctx value or a safe
+                // default that works for both feed and group pages.
+                __crn: ctx.__crn || 'comet.fbweb.CometHomeRoute',
+                fb_api_caller_class: 'RelayModern',
+                fb_api_req_friendly_name: 'CometUFIFeedbackReactMutation',
+                server_timestamps: 'true',
+                variables: JSON.stringify(variables),
+                doc_id: '34430477113234631',
+            };
+            const response = await defaultFuncs
+                .post('https://www.facebook.com/api/graphql/', ctx.jar, form, {})
+                .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+            if (response.errors) {
+                throw new Error(JSON.stringify(response.errors));
+            }
+            const result = {
+                success: true,
+                reaction: reactionKey,
+                reactionId,
+                feedbackId: encodedFeedbackId,
+                data: response?.data?.feedback_react ||
+                    response?.data?.story_act ||
+                    response?.data ||
+                    response,
+            };
+            if (callback) {
+                callback(null, result);
+            }
+            return result;
+        }
+        catch (err) {
+            utils.error('reactToPost', err);
+            if (callback) {
+                callback(err);
+            }
+            throw err;
+        }
+    }
+    // ── Helper: parse CometSinglePostDialogContentQuery response ───────────
+    function _extractTrackingFromNode(node) {
+        if (Array.isArray(node.tracking))
+            return node.tracking.filter(Boolean);
+        if (node.tracking && typeof node.tracking === 'string')
+            return [node.tracking];
+        return [];
+    }
+    function _extractFeedbackTarget(feedbackStory) {
+        const ufiCtx = feedbackStory.story_ufi_container?.story?.feedback_context ??
+            feedbackStory.feedback_context ??
+            null;
+        if (!ufiCtx)
+            return { feedback_id: null, post_url: null };
+        const feedbackTarget = ufiCtx.feedback_target_with_context ??
+            ufiCtx.ufi_renderer?.feedback ??
+            null;
+        return {
+            feedback_id: feedbackTarget?.id ?? null,
+            post_url: feedbackTarget?.url ?? null,
+        };
+    }
+    function _extractPostInfoFields(response, userID) {
+        try {
+            const node = response?.data?.node ?? response?.data?.node_v2 ?? null;
+            if (!node)
+                return {
+                    tracking: [],
+                    feedback_id: null,
+                    attribution_id_v2: '',
+                    post_url: null,
+                };
+            let tracking = _extractTrackingFromNode(node);
+            let feedback_id = null;
+            let post_url = null;
+            let attribution_id_v2 = '';
+            const feedbackStory = node.comet_sections?.feedback?.story ??
+                node.comet_sections?.content?.story ??
+                null;
+            if (feedbackStory) {
+                // Prefer tracking from UFI story (more specific)
+                const storyTracking = _extractTrackingFromNode(feedbackStory);
+                if (storyTracking.length > 0)
+                    tracking = storyTracking;
+                post_url = feedbackStory.permalink ?? feedbackStory.url ?? null;
+                // Build attribution_id_v2 matching live browser format
+                const ts = Date.now();
+                const seq = Math.floor(Math.random() * 999999);
+                attribution_id_v2 =
+                    `CometSinglePostDialogRoot.react,comet.post.single_dialog,unexpected,${ts},${seq},,,;` +
+                        `CometHomeRoot.react,comet.home,logo,${ts - 5000},${seq +
+                            1},${userID},229#230#301,`;
+                const target = _extractFeedbackTarget(feedbackStory);
+                feedback_id = target.feedback_id;
+                if (target.post_url)
+                    post_url = target.post_url;
+            }
+            // Fallback: deep path from node directly
+            if (!feedback_id) {
+                const fb = node.comet_sections?.feedback?.story?.story_ufi_container?.story
+                    ?.feedback_context?.feedback_target_with_context ?? null;
+                if (fb?.id)
+                    feedback_id = fb.id;
+            }
+            return { tracking, feedback_id, attribution_id_v2, post_url };
+        }
+        catch {
+            return {
+                tracking: [],
+                feedback_id: null,
+                attribution_id_v2: '',
+                post_url: null,
+            };
+        }
+    }
+    /**
+  
+     * Fetch post metadata using CometSinglePostDialogContentQuery.
+     * Returns the `tracking` token array, `feedback_id`, and `attribution_id_v2`
+     * required for accurate reactions via reactToPost().
+     *
+     * @param {string} storyID - The story node ID (base64-encoded, e.g. "UzpfS...").
+     *   Can also be a raw numeric post ID — will be auto-encoded.
+     * @param {Function} [callback] - Optional callback function.
+     * @returns {Promise<object>} Object with tracking, feedback_id, attribution_id_v2, and raw data.
+     *
+     * @example
+     * // Get tracking token then react
+     * const info = await api.create.getPostInfo('1510599910435387');
+     * await api.create.reactPost(info.feedback_id, 'LIKE');
+     */
+    async function getPostInfo(storyID, callback) {
+        let _resolve;
+        let _reject;
+        const returnPromise = new Promise((res, rej) => {
+            _resolve = res;
+            _reject = rej;
+        });
+        const done = callback ??
+            ((err, data) => {
+                if (err)
+                    return _reject(err);
+                _resolve(data);
+            });
+        try {
+            if (!storyID) {
+                throw new Error('storyID is required.');
+            }
+            // ── Encode storyID if it's a raw numeric post ID ──────────────────
+            // Facebook storyID format: base64("S:<ownerID>:<postID>:<postID>") or
+            // base64("UzpfS<ownerID>:<postID>:<postID>")
+            // If user passes a plain numeric ID, encode it as feedback ID format
+            // and let the server return the full story node.
+            // Usually users pass the post numeric ID (story_fbid), so we build
+            // the proper base64 story node ID: "S:f<userID>:<postID>:<postID>"
+            let encodedStoryID = storyID;
+            if (/^\d+$/.test(storyID)) {
+                // Raw numeric post ID → build story node ID: S:f<actorID>:<postID>:<postID>
+                const nodeString = `S:f${ctx.userID}:${storyID}:${storyID}`;
+                const b64 = Buffer.from(nodeString)
+                    .toString('base64')
+                    .replaceAll('+', '-')
+                    .replaceAll('/', '_')
+                    .replaceAll('=', '');
+                const pad = b64.length % 4;
+                encodedStoryID = pad ? b64 + '='.repeat(4 - pad) : b64;
+            }
+            // ── Variables matching CometSinglePostDialogContentQuery ──────────
+            const variables = {
+                feedbackSource: 2, // POST_PERMALINK_DIALOG
+                feedLocation: 'POST_PERMALINK_DIALOG',
+                focusCommentID: null,
+                privacySelectorRenderLocation: 'COMET_STREAM',
+                renderLocation: 'permalink',
+                scale: 1,
+                shouldChangeNodeFieldName: true,
+                storyID: encodedStoryID,
+                useDefaultActor: false,
+                // Relay provider flags (copy from live request)
+                __relay_internal__pv__GHLShouldChangeAdIdFieldNamerelayprovider: true,
+                __relay_internal__pv__GHLShouldChangeSponsoredDataFieldNamerelayprovider: true,
+                __relay_internal__pv__CometFeedStory_enable_post_permalink_white_space_clickrelayprovider: false,
+                __relay_internal__pv__CometUFICommentActionLinksRewriteEnabledrelayprovider: false,
+                __relay_internal__pv__CometUFICommentAvatarStickerAnimatedImagerelayprovider: false,
+                __relay_internal__pv__IsWorkUserrelayprovider: 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__CometUFIReactionsEnableShortNamerelayprovider: false,
+                __relay_internal__pv__CometUFICommentAutoTranslationTyperelayprovider: 'ORIGINAL',
+                __relay_internal__pv__CometUFIShareActionMigrationrelayprovider: true,
+                __relay_internal__pv__CometUFISingleLineUFIrelayprovider: false,
+                __relay_internal__pv__CometUFI_dedicated_comment_routable_dialog_gkrelayprovider: true,
+                __relay_internal__pv__FBReelsIFUTileContent_reelsIFUPlayOnHoverrelayprovider: true,
+                __relay_internal__pv__GroupsCometGYSJFeedItemHeightrelayprovider: 150,
+                __relay_internal__pv__ShouldEnableBakedInTextStoriesrelayprovider: false,
+                __relay_internal__pv__StoriesShouldIncludeFbNotesrelayprovider: false,
+            };
+            const lsd = ctx.lsd || ctx.fb_dtsg;
+            const form = {
+                av: ctx.userID,
+                __aaid: '0',
+                __user: ctx.userID,
+                __a: '1',
+                __req: Math.floor(Math.random() * 99).toString(36),
+                __hs: ctx.hs || '20536.HCSV2:comet_pkg.2.1...0',
+                dpr: '1',
+                __ccg: 'EXCELLENT',
+                __rev: ctx.revision || '',
+                __s: ctx.__s || '',
+                __hsi: ctx.__hsi || '',
+                __dyn: ctx.__dyn || '',
+                __csr: ctx.__csr || '',
+                __hsdp: ctx.__hsdp || '',
+                __hblp: ctx.__hblp || '',
+                __sjsp: ctx.__sjsp || '',
+                __comet_req: '15',
+                fb_dtsg: ctx.fb_dtsg,
+                jazoest: ctx.jazoest,
+                lsd,
+                __spin_r: ctx.revision || '',
+                __spin_b: 'trunk',
+                __spin_t: Math.floor(Date.now() / 1000).toString(),
+                __crn: ctx.__crn || 'comet.fbweb.CometHomeRoute',
+                fb_api_caller_class: 'RelayModern',
+                fb_api_req_friendly_name: 'CometSinglePostDialogContentQuery',
+                server_timestamps: 'true',
+                variables: JSON.stringify(variables),
+                doc_id: '26187019677574345',
+            };
+            const response = await defaultFuncs
+                .post('https://www.facebook.com/api/graphql/', ctx.jar, form, {})
+                .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+            if (response.errors) {
+                throw new Error(JSON.stringify(response.errors));
+            }
+            // ── Extract tracking, feedback_id, attribution_id_v2 from response ─
+            // The response structure for CometSinglePostDialogContentQuery:
+            // data.node → story node
+            //   .comet_sections.feedback.story → UFI (Unified Feedback Interface)
+            //     .story_ufi_container.story.feedback_context
+            //       .feedback_target_with_context
+            //         .id              → feedback_id (base64)
+            //         .url             → post URL
+            //   .tracking              → encrypted tracking token array
+            //   .id                    → story graphql node ID
+            const { tracking, feedback_id, attribution_id_v2, post_url, } = _extractPostInfoFields(response, ctx.userID);
+            const result = {
+                success: true,
+                storyID: encodedStoryID,
+                feedback_id,
+                tracking,
+                attribution_id_v2,
+                post_url,
+                data: response,
+            };
+            done(null, result);
+        }
+        catch (err) {
+            utils.error('getPostInfo', err);
+            done(err);
+        }
+        return returnPromise;
+    }
+    /**
+     * React to a post with full tracking accuracy.
+     *
+     * Combines `getPostInfo` + `reactToPost` in one call:
+     * 1. Fetches real `tracking` tokens and `feedback_id` from Facebook via
+     *    `CometSinglePostDialogContentQuery`.
+     * 2. Patches those values into `ctx` so `reactToPost` sends them correctly.
+     * 3. Falls back gracefully if `getPostInfo` fails (uses original IDs).
+     *
+     * @param {string} storyID  - Raw numeric post ID **or** base64 storyID.
+     *   Examples: `'1510599910435387'`  or  `'UzpfSTEwMDA0...'`
+     * @param {string} [reaction='LIKE'] - Reaction type.
+     *   Valid: `'LIKE'|'LOVE'|'HAHA'|'WOW'|'SAD'|'ANGRY'|'CARE'`
+     *   or emoji aliases: `'👍'|'❤️'|'😂'|'😮'|'😢'|'😡'|'🤗'`
+     * @param {Function} [callback] - Optional node-style callback `(err, result)`.
+     * @returns {Promise<object>} Same shape as `reactToPost()`.
+     *
+     * @example
+     * // Easiest usage — just pass the numeric post ID
+     * const result = await api.post.reactWithInfo('1510599910435387', 'LOVE');
+     *
+     * // With callback
+     * api.post.reactWithInfo('1510599910435387', 'HAHA', (err, res) => {
+     *   if (err) console.error(err);
+     *   else console.log('Reacted!', res);
+     * });
+     */
+    async function reactToPostWithTracking(storyID, reaction = 'LIKE', callback) {
+        try {
+            if (!storyID)
+                throw new Error('storyID is required.');
+            // ── Step 1: fetch tracking info from Facebook ──────────────────────
+            let feedbackId = storyID; // fallback: use storyID as-is
+            let infoErr = null;
+            try {
+                const info = await getPostInfo(storyID);
+                // Patch tracking + attribution_id_v2 into ctx so reactToPost uses them
+                if (info.tracking?.length)
+                    ctx.tracking = info.tracking;
+                if (info.attribution_id_v2)
+                    ctx.attribution_id_v2 = info.attribution_id_v2;
+                if (info.post_url)
+                    ctx.currentUrl = info.post_url;
+                // Prefer server-provided feedback_id; fall back to storyID
+                if (info.feedback_id)
+                    feedbackId = info.feedback_id;
+            }
+            catch (err) {
+                infoErr = err;
+                utils.warn('reactToPostWithTracking', `getPostInfo failed (falling back to storyID as feedbackId): ${err}`);
+            }
+            // ── Step 2: react using the enriched ctx ───────────────────────────
+            const result = await reactToPost(feedbackId, reaction);
+            // Attach info-fetch error to result so callers can inspect it
+            if (infoErr)
+                result.infoError = String(infoErr);
+            if (callback)
+                callback(null, result);
+            return result;
+        }
+        catch (err) {
+            utils.error('reactToPostWithTracking', err);
+            if (callback)
+                callback(err);
+            throw err;
+        }
+    }
+    // ── pfbid (Permalink-Friendly Base ID) ───────────────────────────────────
+    // pfbid is an opaque server-side token that Facebook generates.
+    // It CANNOT be decoded client-side (it's internally hashed/encrypted).
+    //
+    // The correct workflow:
+    //   parsePostUrl(url)  → extracts the pfbid token from the URL path
+    //   getPostInfo(token) → sends pfbid to Facebook's GraphQL; server resolves it
+    //                        and returns the real numeric story_fbid in the response
+    //
+    // The returned storyID from parsePostUrl is either:
+    //   - A numeric string  (e.g. "1510599910435387")   → for /posts/{numericID} URLs
+    //   - A pfbid string    (e.g. "pfbid0Yo6XDa...")    → for /posts/pfbid{token} URLs
+    //
+    // Both work as input to getPostInfo / reactWithInfo.
+    /**
+     * Parse any Facebook post URL into a storyID suitable for `getPostInfo`.
+     *
+     * Supports all common URL patterns:
+     * - `https://www.facebook.com/{page}/posts/pfbid{token}`   ← pfbid (new style)
+     * - `https://www.facebook.com/{page}/posts/{numericID}`    ← plain numeric
+     * - `https://www.facebook.com/permalink.php?story_fbid={id}&id={page}`
+     * - `https://www.facebook.com/photo?fbid={id}&...`
+     * - `https://m.facebook.com/story.php?story_fbid={id}&...`
+     *
+     * @param {string} url - Any Facebook post URL.
+     * @returns {{ storyID: string; pageSlug: string | null; format: 'pfbid'|'numeric'|'query' }}
+     *   `storyID` is either a numeric string or the full pfbid token (including "pfbid" prefix).
+     *   Pass it directly to `getPostInfo()` or `reactWithInfo()`.
+     * @throws If no recognisable post ID can be extracted.
+     *
+     * @example
+     * // pfbid URL → storyID is the pfbid token; pass it to getPostInfo which resolves it server-side
+     * const { storyID } = parsePostUrl('https://www.facebook.com/tuyetcollection/posts/pfbid0Yo6XDaKKnFKpENu3g2c2to1zJe7jFoZNr2NqjiXRiHmwjsy8dwbE84y4n7syCSfMl');
+     * // storyID = 'pfbid0Yo6XDaKKnFKpENu3g2c2to1zJe7jFoZNr2NqjiXRiHmwjsy8dwbE84y4n7syCSfMl'
+     * const info = await api.post.getPostInfo(storyID);  // Facebook resolves it → real ID in response
+     * await api.post.reactToPost(info.feedback_id, 'LOVE');
+     *
+     * // Easiest: reactWithInfo handles all of this automatically
+     * await api.post.reactWithInfo(storyID, 'LOVE');
+     *
+     * // Numeric URL → storyID is already the numeric ID
+     * const { storyID } = parsePostUrl('https://www.facebook.com/tuyetcollection/posts/1510599910435387');
+     * // storyID = '1510599910435387'
+     */
+    function parsePostUrl(url) {
+        let parsed;
+        try {
+            parsed = new URL(url);
+        }
+        catch {
+            throw new Error(`parsePostUrl: invalid URL "${url}"`);
+        }
+        const path = parsed.pathname; // e.g. /tuyetcollection/posts/pfbid0Yo6...
+        const segments = path.split('/').filter(Boolean);
+        // ── Pattern 1: /{slug}/posts/{id_or_pfbid} ───────────────────────────
+        const postIdx = segments.indexOf('posts');
+        if (postIdx !== -1 && segments[postIdx + 1]) {
+            const token = segments[postIdx + 1];
+            const pageSlug = postIdx > 0 ? segments[postIdx - 1] : null;
+            if (token.startsWith('pfbid')) {
+                // pfbid is an opaque server token — cannot be decoded client-side.
+                // Return the full pfbid as storyID; Facebook GraphQL resolves it server-side.
+                return { storyID: token, pageSlug, format: 'pfbid' };
+            }
+            if (/^\d+$/.test(token)) {
+                return { storyID: token, pageSlug, format: 'numeric' };
+            }
+        }
+        // ── Pattern 2: /photo/{numericID} or /video/{numericID} ──────────────
+        for (const seg of ['photo', 'video', 'reel']) {
+            const idx = segments.indexOf(seg);
+            if (idx !== -1 && segments[idx + 1] && /^\d+$/.test(segments[idx + 1])) {
+                return {
+                    storyID: segments[idx + 1],
+                    pageSlug: null,
+                    format: 'numeric',
+                };
+            }
+        }
+        // ── Pattern 3: query params ───────────────────────────────────────────
+        // permalink.php?story_fbid=&id=  |  photo?fbid=  |  story.php?story_fbid=
+        const storyFbid = parsed.searchParams.get('story_fbid');
+        if (storyFbid && /^\d+$/.test(storyFbid)) {
+            return { storyID: storyFbid, pageSlug: null, format: 'query' };
+        }
+        const fbid = parsed.searchParams.get('fbid');
+        if (fbid && /^\d+$/.test(fbid)) {
+            return { storyID: fbid, pageSlug: null, format: 'query' };
+        }
+        throw new Error(`parsePostUrl: could not extract post ID from "${url}"`);
+    }
     return {
         create: createPost,
         createPost: createPost,
         delete: deletePost,
         getComments: getPostComments,
+        getPostInfo: getPostInfo,
+        getPostIDFromURL: getPostIDFromURL,
+        parsePostUrl: parsePostUrl,
+        react: reactToPost,
+        reactToPost: reactToPost,
+        reactWithInfo: reactToPostWithTracking,
+        reactToPostWithTracking: reactToPostWithTracking,
         uploadPhoto: uploadPhoto,
         uploadVideo: uploadVideo,
     };