bb-fca 2.0.17 → 2.0.19

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

@@ -0,0 +1,261 @@
+import utils = require('../../../utils');
+
+/**
+ * Extracts the numeric post ID from a Facebook post URL by fetching the page HTML.
+ * Supports formats: full URL, /posts/pfbid..., /posts/numericID, permalink.php, etc.
+ * @param {object} defaultFuncs - The default functions for making API requests.
+ * @param {object} ctx - The context object.
+ * @param {string} postUrl - The Facebook post URL.
+ * @returns {Promise<string>} The numeric post ID.
+ */
+async function resolvePostID(
+  defaultFuncs,
+  ctx,
+  postUrl: string,
+): Promise<string> {
+  // Build fetch URL
+  let fetchUrl: string;
+  if (postUrl.startsWith('http://') || postUrl.startsWith('https://')) {
+    fetchUrl = postUrl;
+  } else if (postUrl.startsWith('/')) {
+    fetchUrl = `https://www.facebook.com${postUrl}`;
+  } else {
+    fetchUrl = `https://www.facebook.com/${postUrl}`;
+  }
+
+  const resData = await utils.get(
+    fetchUrl,
+    ctx.jar,
+    {},
+    ctx.globalOptions,
+    ctx,
+  );
+  const html = resData.body.toString();
+
+  // Try to find post_id from the HTML JSON data
+  const scriptMatches = html.match(
+    /<script type="application\/json"\s+data-content-len="\d+"\s+data-sjs>(.*?)<\/script>/gs,
+  );
+
+  if (!scriptMatches) {
+    throw new Error('Could not parse post HTML to find post ID.');
+  }
+
+  let postID: string | null = null;
+
+  // Deep search helper
+  function deepFind(obj: any, key: string): string | null {
+    if (!obj || typeof obj !== 'object') return null;
+    for (const k of Object.keys(obj)) {
+      if (k === key && typeof obj[k] === 'string' && obj[k].length > 0) {
+        return obj[k];
+      }
+      const found = deepFind(obj[k], key);
+      if (found) return found;
+    }
+    return null;
+  }
+
+  for (const scriptMatch of scriptMatches) {
+    try {
+      const jsonMatch = scriptMatch.match(/<script[^>]*>(.*?)<\/script>/s);
+      if (!jsonMatch) continue;
+      const jsonData = JSON.parse(jsonMatch[1]);
+      const found = deepFind(jsonData, 'post_id');
+      if (found) {
+        postID = found;
+        break;
+      }
+    } catch (e) {
+      continue;
+    }
+  }
+
+  if (!postID) {
+    // Fallback: try to extract from URL patterns
+    // e.g. /posts/3228319350779313:415318807385347
+    const urlMatch = postUrl.match(/posts\/(\d+)/);
+    if (urlMatch) {
+      postID = urlMatch[1];
+    }
+  }
+
+  if (!postID) {
+    // Fallback: try story_fbid from permalink.php
+    const storyMatch = postUrl.match(/story_fbid=(\d+)/);
+    if (storyMatch) {
+      postID = storyMatch[1];
+    }
+  }
+
+  if (!postID) {
+    throw new Error('Could not resolve post ID from the provided URL.');
+  }
+
+  return postID;
+}
+
+/**
+ * Submits the reply comment to the GraphQL endpoint.
+ * @param {object} defaultFuncs - The default functions.
+ * @param {object} ctx - The context object.
+ * @param {object} variables - The fully constructed variables object.
+ * @returns {Promise<object>} A promise that resolves with the comment info.
+ */
+async function submitReply(defaultFuncs, ctx, variables) {
+  const res = await defaultFuncs
+    .post('https://www.facebook.com/api/graphql/', ctx.jar, {
+      fb_api_caller_class: 'RelayModern',
+      fb_api_req_friendly_name: 'useCometUFICreateCommentMutation',
+      variables: JSON.stringify(variables),
+      server_timestamps: true,
+      doc_id: '26613344231661138',
+    })
+    .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+  if (res.errors) {
+    throw res;
+  }
+
+  const commentEdge = res.data?.comment_create?.feedback_comment_edge;
+  if (!commentEdge) {
+    throw new Error(
+      'Unexpected response structure: missing comment_create.feedback_comment_edge',
+    );
+  }
+
+  return {
+    id: commentEdge.node.id,
+    url: commentEdge.node.feedback?.url || null,
+    count: res.data.comment_create.feedback?.total_comment_count || 0,
+  };
+}
+
+/**
+ * Creates a reply to a comment on a Facebook post.
+ *
+ * @param {string} postUrl - The URL of the Facebook post (e.g. https://www.facebook.com/user/posts/123456789).
+ * @param {string} commentID - The numeric ID of the comment to reply to.
+ * @param {string} text - The reply text content.
+ * @param {function} [callback] - Optional callback function (err, result).
+ * @returns {Promise<object>} A promise that resolves with the new reply's information:
+ *   - id: The GraphQL ID of the new reply.
+ *   - url: The URL of the reply (if available).
+ *   - count: The total comment count on the post.
+ *
+ * @example
+ * // Using async/await
+ * const result = await api.replyComment(
+ *   'https://www.facebook.com/user/posts/3228319350779313',
+ *   '3873188569648912',
+ *   'Cảm ơn bạn!'
+ * );
+ * console.log(result.id);
+ *
+ * // Using callback
+ * api.replyComment(url, commentId, 'Hello!', (err, result) => {
+ *   if (err) console.error(err);
+ *   else console.log(result);
+ * });
+ */
+export default function(defaultFuncs: any, api: any, ctx: any) {
+  return async function replyComment(
+    postUrl: string,
+    commentID: string,
+    text: string,
+    callback?: Function,
+  ) {
+    let cb: (error: any, info?: any) => void;
+    const returnPromise = new Promise<any>((resolve, reject) => {
+      cb = (error, info) => (info ? resolve(info) : reject(error));
+    });
+
+    if (typeof callback === 'function') {
+      cb = callback as any;
+    }
+
+    // ── Validate inputs ──────────────────────────────────────────────
+    if (!postUrl || typeof postUrl !== 'string') {
+      const error = 'postUrl must be a non-empty string (Facebook post URL).';
+      utils.error('replyComment', error);
+      return cb(error);
+    }
+    if (!commentID || typeof commentID !== 'string') {
+      const error =
+        'commentID must be a non-empty string (numeric comment ID).';
+      utils.error('replyComment', error);
+      return cb(error);
+    }
+    if (!text || typeof text !== 'string') {
+      const error = 'text must be a non-empty string (reply content).';
+      utils.error('replyComment', error);
+      return cb(error);
+    }
+
+    try {
+      // ── Step 1: Resolve the numeric post ID from the URL ─────────
+      const postID = await resolvePostID(defaultFuncs, ctx, postUrl);
+      utils.log('replyComment', `Resolved postID: ${postID}`);
+
+      // ── Step 2: Build the correct base64 IDs ─────────────────────
+      // feedback_id = base64("feedback:{postID}_{commentID}")
+      const feedbackIdRaw = `feedback:${postID}_${commentID}`;
+      const feedbackIdBase64 = Buffer.from(feedbackIdRaw).toString('base64');
+
+      // reply_comment_parent_fbid = base64("comment:{postID}_{commentID}")
+      const replyParentRaw = `comment:${postID}_${commentID}`;
+      const replyParentBase64 = Buffer.from(replyParentRaw).toString('base64');
+
+      // ── Step 3: Build the variables payload ──────────────────────
+      const variables = {
+        feedLocation: 'POST_PERMALINK_DIALOG',
+        feedbackSource: 2,
+        groupID: null,
+        input: {
+          actor_id: ctx.userID,
+          client_mutation_id: Math.round(Math.random() * 19).toString(),
+          attachments: null,
+          feedback_id: feedbackIdBase64,
+          formatting_style: null,
+          message: {
+            ranges: [],
+            text: text,
+          },
+          reply_comment_parent_fbid: replyParentBase64,
+          reply_target_clicked: true,
+          attribution_id_v2: `CometSinglePostDialogRoot.react,comet.post.single_dialog,via_cold_start,${Date.now()},846664,,,`,
+          vod_video_timestamp: null,
+          is_tracking_encrypted: true,
+          tracking: [],
+          feedback_source: 'OBJECT',
+          idempotence_token: 'client:' + utils.getGUID(),
+          session_id: utils.getGUID(),
+          downstream_share_session_id: utils.getGUID(),
+          downstream_share_session_origin_uri: postUrl,
+          downstream_share_session_start_time: Date.now().toString(),
+        },
+        inviteShortLinkKey: null,
+        renderLocation: null,
+        scale: 1,
+        useDefaultActor: false,
+        focusCommentID: null,
+        __relay_internal__pv__groups_comet_use_glvrelayprovider: false,
+        __relay_internal__pv__CometUFICommentActionLinksRewriteEnabledrelayprovider: false,
+        __relay_internal__pv__CometUFICommentAvatarStickerAnimatedImagerelayprovider: false,
+        __relay_internal__pv__IsWorkUserrelayprovider: false,
+        __relay_internal__pv__CometUFICommentAutoTranslationTyperelayprovider:
+          'ORIGINAL',
+      };
+
+      // ── Step 4: Submit the reply ──────────────────────────────────
+      const info = await submitReply(defaultFuncs, ctx, variables);
+      utils.log('replyComment', `Reply created successfully: ${info.id}`);
+      cb(null, info);
+    } catch (err) {
+      utils.error('replyComment', err);
+      cb(err);
+    }
+
+    return returnPromise;
+  };
+}

package/src/types/index.d.ts

@@ -705,6 +705,63 @@ export interface API {
     callback?: Callback<CommentResult>,
   ): Promise<CommentResult>;
 
+  /**
+   * Reply to a comment on a Facebook post.
+   * @param postUrl - The URL of the Facebook post.
+   * @param commentID - The numeric ID of the comment to reply to.
+   * @param text - The reply text content.
+   * @param callback - Optional callback function.
+   * @returns A promise that resolves with the new reply's information.
+   */
+  replyComment(
+    postUrl: string,
+    commentID: string,
+    text: string,
+    callback?: Callback<CommentResult>,
+  ): Promise<CommentResult>;
+
+  /**
+   * Upload and publish a video as a Facebook Reel.
+   * Full flow: upload video → copyright check → publish.
+   *
+   * @param options - The reel options.
+   * @param options.videoPath - File path to the video file.
+   * @param options.message - Caption text for the reel.
+   * @param options.privacy - Privacy: "EVERYONE", "FRIENDS", or "SELF". Default: "EVERYONE".
+   * @param options.skipCopyrightCheck - Skip copyright check polling. Default: false.
+   * @param options.copyrightCheckTimeout - Max time for copyright check (ms). Default: 60000.
+   * @param options.copyrightCheckInterval - Polling interval for copyright check (ms). Default: 2000.
+   * @param callback - Optional callback function.
+   * @returns A promise that resolves with the reel's information.
+   */
+  createReel(
+    options: {
+      videoPath: string;
+      message?: string;
+      privacy?: 'EVERYONE' | 'FRIENDS' | 'SELF';
+      skipCopyrightCheck?: boolean;
+      copyrightCheckTimeout?: number;
+      copyrightCheckInterval?: number;
+    },
+    callback?: Callback<{
+      success: boolean;
+      postID: string | null;
+      storyID: string | null;
+      videoID: string;
+      publishingFlow: string | null;
+      composerSessionId: string;
+      data: any;
+    }>,
+  ): Promise<{
+    success: boolean;
+    postID: string | null;
+    storyID: string | null;
+    videoID: string;
+    publishingFlow: string | null;
+    composerSessionId: string;
+    data: any;
+  }>;
+
   /** Share a Facebook post. */
   share(
     text: string,

package/src/utils/axios.ts

@@ -19,8 +19,19 @@ let proxyAgent: any = null;
 // Request interceptor: attach cookies from jar + proxy agent
 (client.interceptors as any).request.use((config: any) => {
   const url = config.url || '';
+  const currentJar = config.jar || jar;
   try {
-    const cookieString = jar.getCookieStringSync(url);
+    let cookieString = currentJar.getCookieStringSync(url);
+    
+    // Cross-domain fallback: if URL is a facebook.com subdomain, ensure we send facebook.com cookies
+    if (url.includes('facebook.com') || url.includes('messenger.com')) {
+      const baseCookies = currentJar.getCookieStringSync('https://www.facebook.com');
+      if (baseCookies) {
+        // Merge cookies if necessary, but usually baseCookies is sufficient for subdomains
+        cookieString = cookieString ? `${cookieString}; ${baseCookies}` : baseCookies;
+      }
+    }
+
     if (cookieString) {
       config.headers = config.headers || {};
       config.headers['Cookie'] = cookieString;
@@ -41,11 +52,15 @@ let proxyAgent: any = null;
 // Response interceptor: save set-cookie headers back to jar
 (client.interceptors as any).response.use((response: any) => {
   const url = response.config.url || '';
+  const currentJar = response.config.jar || jar;
   const setCookieHeaders = response.headers['set-cookie'];
   if (setCookieHeaders && Array.isArray(setCookieHeaders)) {
     for (const cookie of setCookieHeaders) {
       try {
-        jar.setCookieSync(cookie, url);
+        currentJar.setCookieSync(cookie, url);
+        if (url.includes('facebook.com')) {
+          currentJar.setCookieSync(cookie, 'https://www.facebook.com');
+        }
       } catch (e) {
         // Ignore invalid cookies
       }
@@ -56,11 +71,15 @@ let proxyAgent: any = null;
   // Also save cookies from error responses
   if (error.response) {
     const url = error.response.config?.url || '';
+    const currentJar = error.response.config?.jar || jar;
     const setCookieHeaders = error.response.headers?.['set-cookie'];
     if (setCookieHeaders && Array.isArray(setCookieHeaders)) {
       for (const cookie of setCookieHeaders) {
         try {
-          jar.setCookieSync(cookie, url);
+          currentJar.setCookieSync(cookie, url);
+          if (url.includes('facebook.com')) {
+            currentJar.setCookieSync(cookie, 'https://www.facebook.com');
+          }
         } catch (e) {
           // Ignore
         }
@@ -148,6 +167,7 @@ export async function get(
     timeout: 60000,
     params: qs,
     validateStatus: (status: number) => status >= 200 && status < 600,
+    jar: reqJar,
   };
   return requestWithRetry(async () => await client.get(url, config));
 }
@@ -186,6 +206,7 @@ export async function post(
     headers,
     timeout: 60000,
     validateStatus: (status: number) => status >= 200 && status < 600,
+    jar: reqJar,
   };
   return requestWithRetry(async () => await client.post(url, data, config));
 }
@@ -214,6 +235,7 @@ export async function postFormData(
     timeout: 60000,
     params: qs,
     validateStatus: (status: number) => status >= 200 && status < 600,
+    jar: reqJar,
   };
   return requestWithRetry(async () => await client.post(url, formData, config));
 }
@@ -232,6 +254,7 @@ export async function postRaw(
     maxContentLength: Infinity,
     maxBodyLength: Infinity,
     validateStatus: (status: number) => status >= 200 && status < 600,
+    jar: reqJar,
   };
   return requestWithRetry(async () => await client.post(url, body, config));
 }