fca-phantom 1.0.0

package/phantom/dispatch/nickname.js

@@ -0,0 +1,132 @@
+"use strict";
+
+const utils = require('../datastore/models/matrix/tools');
+
+module.exports = function (defaultFuncs, api, ctx) { 
+  /**
+   * Made by Choru Official 
+   * Mqtt
+   * Sets a nickname for a participant in a Facebook thread via MQTT.
+   *
+   * @param {string} nickname The new nickname to set.
+   * @param {string} threadID The ID of the thread.
+   * @param {string} participantID The ID of the participant whose nickname will be changed. Defaults to the current user's ID if not provided or a function.
+   * @param {Function} [callback] Optional callback function to be invoked upon completion.
+   * @param {string} [initiatorID] The ID of the user who initiated the nickname change (e.g., from event.senderID).
+   * @returns {Promise<object>} A promise that resolves with a structured event object on success or rejects on error.
+   */
+  return function setNickname(nickname, threadID, participantID, callback, initiatorID) {
+    let _callback;
+    let _initiatorID;
+
+    let _resolvePromise;
+    let _rejectPromise;
+    const returnPromise = new Promise((resolve, reject) => {
+        _resolvePromise = resolve;
+        _rejectPromise = reject;
+    });
+
+    if (utils.getType(callback) === "Function" || utils.getType(callback) === "AsyncFunction") {
+        _callback = callback;
+        _initiatorID = initiatorID;
+    } else if (utils.getType(threadID) === "Function" || utils.getType(threadID) === "AsyncFunction") {
+        _callback = threadID;
+        threadID = null;
+        _initiatorID = callback;
+    } else if (utils.getType(participantID) === "Function" || utils.getType(participantID) === "AsyncFunction") {
+        _callback = participantID;
+        participantID = ctx.userID;
+        _initiatorID = callback;
+    }
+    else if (utils.getType(callback) === "string") {
+        _initiatorID = callback;
+        _callback = undefined;
+    } else {
+        _callback = undefined;
+        _initiatorID = undefined;
+    }
+
+    if (!_callback) {
+      _callback = function (__err, __data) {
+        if (__err) _rejectPromise(__err);
+        else _resolvePromise(__data);
+      };
+    } else {
+      const originalCallback = _callback;
+      _callback = function(__err, __data) {
+        if (__err) {
+          originalCallback(__err);
+          _rejectPromise(__err);
+        } else {
+          originalCallback(null, __data);
+          _resolvePromise(__data);
+        }
+      };
+    }
+
+    _initiatorID = _initiatorID || ctx.userID;
+
+    threadID = threadID || ctx.threadID;
+    participantID = participantID || ctx.userID;
+
+    if (!threadID) {
+      return _callback(new Error("threadID is required to set a nickname."));
+    }
+    if (typeof nickname !== 'string') {
+      return _callback(new Error("nickname must be a string."));
+    }
+
+    if (!ctx.mqttClient) {
+      return _callback(new Error("Not connected to MQTT"));
+    }
+
+    ctx.wsReqNumber += 1;
+    ctx.wsTaskNumber += 1;
+
+    const queryPayload = {
+      thread_key: threadID.toString(),
+      contact_id: participantID.toString(),
+      nickname: nickname,
+      sync_group: 1,
+    };
+
+    const query = {
+      failure_count: null,
+      label: '44',
+      payload: JSON.stringify(queryPayload),
+      queue_name: 'thread_participant_nickname',
+      task_id: ctx.wsTaskNumber,
+    };
+
+    const context = {
+      app_id: ctx.appID,
+      payload: {
+        epoch_id: parseInt(utils.generateOfflineThreadingID()),
+        tasks: [query],
+        version_id: '24631415369801570',
+      },
+      request_id: ctx.wsReqNumber,
+      type: 3,
+    };
+    context.payload = JSON.stringify(context.payload);
+    
+    ctx.mqttClient.publish('/ls_req', JSON.stringify(context), { qos: 1, retain: false }, (err) => {
+      if (err) {
+        return _callback(new Error(`MQTT publish failed for setNickname: ${err.message || err}`));
+      }
+      
+      const nicknameChangeEvent = {
+        type: "thread_nickname_update", 
+        threadID: threadID,
+        participantID: participantID,
+        newNickname: nickname,
+        senderID: _initiatorID,
+        BotID: ctx.userID,
+        timestamp: Date.now(),
+      };
+      _callback(null, nicknameChangeEvent);
+    });
+
+    return returnPromise;
+  };
+};

package/phantom/dispatch/notes.js

@@ -0,0 +1,263 @@
+"use strict";
+
+/**
+ * Notes Module — Advanced Messenger Notes for Phantom SDK
+ *
+ * @ChoruOfficial (original) — massively extended for phantom-fca
+ *
+ * Features:
+ *  - Full Promise + callback dual API for all methods
+ *  - Privacy levels: EVERYONE | FRIENDS | CLOSE_FRIENDS | CUSTOM
+ *  - Customisable note duration (default 24h)
+ *  - Optional emoji reaction attachment
+ *  - Exponential-backoff retry on transient GraphQL errors
+ *  - Batch delete support
+ *  - Structured output with noteID, text, expiresAt, privacyLevel
+ */
+
+const utils = require('../datastore/models/matrix/tools');
+
+const PRIVACY_VALUES = new Set(['EVERYONE', 'FRIENDS', 'CLOSE_FRIENDS', 'CUSTOM', 'ONLY_ME']);
+const DEFAULT_DURATION = 86400; // 24 hours in seconds
+
+function wrapPromise(fn) {
+  let resolve, reject;
+  const promise = new Promise((res, rej) => { resolve = res; reject = rej; });
+  const cb = (err, data) => { if (err) reject(err); else resolve(data); };
+  fn(cb);
+  return promise;
+}
+
+async function gqlPost(defaultFuncs, ctx, form, retries = 3, baseMs = 500) {
+  let lastErr;
+  for (let attempt = 1; attempt <= retries; attempt++) {
+    try {
+      const resData = await defaultFuncs
+        .post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+      if (resData?.errors) {
+        const msg = resData.errors[0]?.message || JSON.stringify(resData.errors);
+        throw Object.assign(new Error(msg), { isFatal: /auth|permission|checkpoint/i.test(msg) });
+      }
+      return resData;
+    } catch (err) {
+      lastErr = err;
+      if (err.isFatal || attempt >= retries) throw err;
+      const wait = baseMs * Math.pow(2, attempt - 1) + Math.random() * 200;
+      utils.warn("notes", `Retry ${attempt}/${retries} in ${Math.round(wait)}ms`);
+      await new Promise(r => setTimeout(r, wait));
+    }
+  }
+  throw lastErr;
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+
+  /**
+   * Check the currently active Messenger note for this account.
+   * @param {Function} [callback]
+   * @returns {Promise<object|null>}
+   */
+  function checkNote(callback) {
+    const form = {
+      fb_api_caller_class:      "RelayModern",
+      fb_api_req_friendly_name: "MWInboxTrayNoteCreationDialogQuery",
+      variables:                JSON.stringify({ scale: 2 }),
+      doc_id:                   "30899655739648624",
+    };
+
+    const exec = async cb => {
+      try {
+        const res = await gqlPost(defaultFuncs, ctx, form);
+        const note = res?.data?.viewer?.actor?.msgr_user_rich_status || null;
+        const out = note ? {
+          noteID:       note.id,
+          text:         note.text || note.description || null,
+          emoji:        note.emoji || null,
+          privacyLevel: note.privacy || null,
+          createdAt:    note.creation_time || null,
+          expiresAt:    note.expiration_time || null,
+          isActive:     true,
+        } : null;
+        cb(null, out);
+      } catch (err) {
+        utils.error("notes.checkNote", err.message || err);
+        cb(err);
+      }
+    };
+
+    if (callback) { exec(callback); return; }
+    return wrapPromise(exec);
+  }
+
+  /**
+   * Create a new Messenger note.
+   * @param {string}   text
+   * @param {object}  [options]  { privacy, duration, emoji }
+   * @param {Function} [callback]
+   * @returns {Promise<object>}
+   */
+  function createNote(text, options, callback) {
+    if (typeof options === 'function') { callback = options; options = {}; }
+    options = options || {};
+
+    const privacy  = PRIVACY_VALUES.has(options.privacy) ? options.privacy : 'EVERYONE';
+    const duration = options.duration || DEFAULT_DURATION;
+
+    const input = {
+      client_mutation_id: String(Date.now() % 1e9),
+      actor_id:           ctx.userID,
+      description:        typeof text === 'string' ? text : String(text),
+      duration,
+      note_type:          "TEXT_NOTE",
+      privacy,
+      session_id:         utils.getGUID ? utils.getGUID() : String(Math.random()),
+    };
+    if (options.emoji) input.emoji = options.emoji;
+
+    const form = {
+      fb_api_caller_class:      "RelayModern",
+      fb_api_req_friendly_name: "MWInboxTrayNoteCreationDialogCreationStepContentMutation",
+      variables:                JSON.stringify({ input }),
+      doc_id:                   "24060573783603122",
+    };
+
+    const exec = async cb => {
+      try {
+        const res = await gqlPost(defaultFuncs, ctx, form);
+        const status = res?.data?.xfb_rich_status_create?.status;
+        if (!status) throw new Error("No note status in response — creation may have failed");
+        cb(null, {
+          noteID:       status.id,
+          text:         status.text || text,
+          emoji:        status.emoji || options.emoji || null,
+          privacyLevel: privacy,
+          duration,
+          expiresAt:    status.expiration_time || (Date.now() + duration * 1000),
+          createdAt:    Date.now(),
+        });
+      } catch (err) {
+        utils.error("notes.createNote", err.message || err);
+        cb(err);
+      }
+    };
+
+    if (callback) { exec(callback); return; }
+    return wrapPromise(exec);
+  }
+
+  /**
+   * Delete a Messenger note by ID.
+   * @param {string|string[]} noteID   One ID or array for batch delete
+   * @param {Function}        [callback]
+   * @returns {Promise<object>}
+   */
+  function deleteNote(noteID, callback) {
+    const ids = Array.isArray(noteID) ? noteID : [noteID];
+
+    const deleteOne = async id => {
+      const form = {
+        fb_api_caller_class:      "RelayModern",
+        fb_api_req_friendly_name: "useMWInboxTrayDeleteNoteMutation",
+        variables:                JSON.stringify({
+          input: {
+            client_mutation_id: String(Date.now() % 1e9),
+            actor_id:           ctx.userID,
+            rich_status_id:     id,
+          }
+        }),
+        doc_id: "9532619970198958",
+      };
+      const res = await gqlPost(defaultFuncs, ctx, form);
+      if (!res?.data?.xfb_rich_status_delete) throw new Error(`Delete note ${id}: no confirmation in response`);
+      return { success: true, noteID: id };
+    };
+
+    const exec = async cb => {
+      try {
+        const results = await Promise.all(ids.map(deleteOne));
+        cb(null, ids.length === 1 ? results[0] : results);
+      } catch (err) {
+        utils.error("notes.deleteNote", err.message || err);
+        cb(err);
+      }
+    };
+
+    if (callback) { exec(callback); return; }
+    return wrapPromise(exec);
+  }
+
+  /**
+   * Delete the old note and create a new one atomically (sequential).
+   * @param {string}   oldNoteID
+   * @param {string}   newText
+   * @param {object}  [options]  createNote options { privacy, duration, emoji }
+   * @param {Function} [callback]
+   * @returns {Promise<{ deleted, created }>}
+   */
+  function recreateNote(oldNoteID, newText, options, callback) {
+    if (typeof options === 'function') { callback = options; options = {}; }
+    options = options || {};
+
+    const exec = async cb => {
+      try {
+        const deleted = await new Promise((res, rej) => deleteNote(oldNoteID, (err, d) => err ? rej(err) : res(d)));
+        const created = await new Promise((res, rej) => createNote(newText, options, (err, c) => err ? rej(err) : res(c)));
+        cb(null, { deleted, created });
+      } catch (err) {
+        utils.error("notes.recreateNote", err.message || err);
+        cb(err);
+      }
+    };
+
+    if (callback) { exec(callback); return; }
+    return wrapPromise(exec);
+  }
+
+  /**
+   * Update an existing note: delete old + create new. Alias for recreateNote.
+   */
+  function updateNote(oldNoteID, newText, options, callback) {
+    return recreateNote(oldNoteID, newText, options, callback);
+  }
+
+  /**
+   * Delete the current active note (if any) and optionally create a new one.
+   * @param {string}   [newText]   If provided, create a replacement note
+   * @param {object}  [options]
+   * @param {Function} [callback]
+   * @returns {Promise<object>}
+   */
+  async function replaceActiveNote(newText, options, callback) {
+    if (typeof options === 'function') { callback = options; options = {}; }
+    options = options || {};
+
+    const exec = async cb => {
+      try {
+        const current = await new Promise((res, rej) => checkNote((err, n) => err ? rej(err) : res(n)));
+        let deleted = null;
+        if (current?.noteID) {
+          deleted = await new Promise((res, rej) => deleteNote(current.noteID, (err, d) => err ? rej(err) : res(d)));
+        }
+        if (!newText) return cb(null, { deleted, created: null });
+        const created = await new Promise((res, rej) => createNote(newText, options, (err, c) => err ? rej(err) : res(c)));
+        cb(null, { deleted, created });
+      } catch (err) {
+        utils.error("notes.replaceActiveNote", err.message || err);
+        cb(err);
+      }
+    };
+
+    if (callback) { exec(callback); return; }
+    return wrapPromise(exec);
+  }
+
+  return {
+    create:             createNote,
+    delete:             deleteNote,
+    recreate:           recreateNote,
+    update:             updateNote,
+    check:              checkNote,
+    replaceActive:      replaceActiveNote,
+  };
+};

package/phantom/dispatch/pinMessage.js

@@ -0,0 +1,238 @@
+"use strict";
+
+const utils = require('../datastore/models/matrix/tools');
+const _ = require('lodash');
+const deepdash = require('deepdash');
+const { JSONPath } = require('jsonpath-plus');
+const { globalShield } = require('../datastore/models/matrix/ghost');
+
+deepdash(_);
+
+const PIN_CACHE = new Map();
+const PIN_CACHE_TTL = 2 * 60 * 1000;
+const PIN_HISTORY = [];
+const MAX_HISTORY = 200;
+const INFLIGHT_PINS = new Map();
+
+async function retryOp(fn, retries = 4, base = 400) {
+  for (let i = 0; i < retries; i++) {
+    try { return await fn(); } catch (err) {
+      if (i === retries - 1) throw err;
+      const transient = /network|timeout|ECONNRESET|ETIMEDOUT|5\d\d|429/i.test(String(err?.message || err));
+      if (!transient) throw err;
+      await new Promise(r => setTimeout(r, base * Math.pow(2, i) + Math.random() * 300));
+    }
+  }
+}
+
+function extractAndSearchLightspeedRequest(allJsonData) {
+  const lightReq = _.get(allJsonData, '__bbox.result.data.viewer.lightspeed_web_request');
+  if (!lightReq) return null;
+
+  try {
+    const matches = JSONPath({
+      path: `$..[?(@ === "setPinnedMessage" || @ === "deleteThenInsertMessage")]`,
+      json: lightReq
+    });
+    return { lightReq, pinnedCommands: matches, commandCount: matches.length };
+  } catch {
+    return { lightReq, pinnedCommands: [], commandCount: 0 };
+  }
+}
+
+function mqttPublishWithAck(ctx, content, timeoutMs = 15000) {
+  return new Promise((resolve, reject) => {
+    const reqID = content.request_id;
+    let handled = false;
+
+    const onResp = (topic, message) => {
+      if (topic !== '/ls_resp' || handled) return;
+      let j;
+      try { j = JSON.parse(message.toString()); j.payload = JSON.parse(j.payload); } catch { return; }
+      if (j.request_id !== reqID) return;
+      handled = true;
+      clearTimeout(timer);
+      ctx.mqttClient.removeListener('message', onResp);
+      resolve({ success: true, request_id: reqID, acked: true });
+    };
+
+    const timer = setTimeout(() => {
+      if (!handled) {
+        handled = true;
+        ctx.mqttClient.removeListener('message', onResp);
+        resolve({ success: true, request_id: reqID, acked: false, timeout: true });
+      }
+    }, timeoutMs);
+
+    ctx.mqttClient.on('message', onResp);
+    ctx.mqttClient.publish('/ls_req', JSON.stringify(content), { qos: 1, retain: false }, (err) => {
+      if (err && !handled) {
+        handled = true;
+        clearTimeout(timer);
+        ctx.mqttClient.removeListener('message', onResp);
+        reject(err);
+      }
+    });
+  });
+}
+
+function buildPinRequest(ctx, tasks, epochIncrement = 0) {
+  return {
+    app_id: '2220391788200892',
+    payload: JSON.stringify({
+      epoch_id: parseInt(utils.generateOfflineThreadingID()) + epochIncrement,
+      tasks,
+      version_id: '9523201934447612'
+    }),
+    request_id: (ctx.wsReqNumber = (ctx.wsReqNumber || 0) + 1),
+    type: 3
+  };
+}
+
+function recordHistory(op) {
+  PIN_HISTORY.unshift({ ...op, ts: Date.now() });
+  if (PIN_HISTORY.length > MAX_HISTORY) PIN_HISTORY.length = MAX_HISTORY;
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+
+  return async function pin(action, threadID, messageID, options, callback) {
+    if (typeof options === 'function') { callback = options; options = {}; }
+    if (!options || typeof options !== 'object') options = {};
+    const { useAck = true, skipCache = false } = options;
+
+    const VALID_ACTIONS = ['pin', 'unpin', 'list'];
+    if (!VALID_ACTIONS.includes(action)) {
+      throw new Error(`pinMessage: invalid action "${action}". Use: ${VALID_ACTIONS.join(', ')}`);
+    }
+
+    if (action === 'list') {
+      if (!threadID) throw new Error('pinMessage: "list" requires threadID');
+
+      const cacheKey = `pins_${threadID}`;
+      if (!skipCache) {
+        const cached = PIN_CACHE.get(cacheKey);
+        if (cached && Date.now() - cached.ts < PIN_CACHE_TTL) {
+          return { ...cached.result, fromCache: true };
+        }
+      }
+
+      if (INFLIGHT_PINS.has(cacheKey)) return INFLIGHT_PINS.get(cacheKey);
+
+      const inflightPromise = (async () => {
+        try {
+          const url = `https://www.facebook.com/messages/t/${threadID}/`;
+          const allJsonData = await retryOp(() => utils.json(url, ctx.jar, null, ctx.globalOptions, ctx));
+
+          const extracted = extractAndSearchLightspeedRequest(allJsonData);
+          if (!extracted || !extracted.lightReq) {
+            utils.warn('pinMessage', `No pinned messages found for thread ${threadID}`);
+            return { threadID: String(threadID), pins: [], count: 0, timestamp: Date.now() };
+          }
+
+          const result = {
+            threadID: String(threadID),
+            lightspeedData: extracted.lightReq,
+            pinnedCommands: extracted.pinnedCommands,
+            count: extracted.commandCount,
+            hasPins: extracted.commandCount > 0,
+            timestamp: Date.now()
+          };
+
+          PIN_CACHE.set(cacheKey, { result, ts: Date.now() });
+          recordHistory({ action: 'list', threadID: String(threadID), pinCount: extracted.commandCount });
+          return result;
+        } finally {
+          INFLIGHT_PINS.delete(cacheKey);
+        }
+      })();
+
+      INFLIGHT_PINS.set(cacheKey, inflightPromise);
+      return inflightPromise;
+    }
+
+    if (!ctx.mqttClient) throw new Error('pinMessage: MQTT not connected (start listening first)');
+    if (!threadID || !messageID) throw new Error(`pinMessage: "${action}" requires both threadID and messageID`);
+
+    await globalShield.addSmartDelay();
+
+    PIN_CACHE.delete(`pins_${threadID}`);
+
+    let results;
+
+    if (action === 'pin') {
+      const pinTask = {
+        label: '430',
+        payload: JSON.stringify({ thread_key: String(threadID), message_id: String(messageID), timestamp_ms: Date.now() }),
+        queue_name: `pin_msg_v2_${threadID}`,
+        task_id: (ctx.wsTaskNumber = (ctx.wsTaskNumber || 0) + 1)
+      };
+      const searchTask = {
+        label: '751',
+        payload: JSON.stringify({ thread_key: String(threadID), message_id: String(messageID), pinned_message_state: 1 }),
+        queue_name: 'set_pinned_message_search',
+        task_id: (ctx.wsTaskNumber = (ctx.wsTaskNumber || 0) + 1)
+      };
+
+      const publish = useAck ? mqttPublishWithAck : (c) => new Promise((res, rej) => {
+        ctx.mqttClient.publish('/ls_req', JSON.stringify(c), { qos: 1, retain: false }, e => e ? rej(e) : res({ success: true, request_id: c.request_id }));
+      });
+
+      results = await Promise.all([
+        retryOp(() => publish(ctx, buildPinRequest(ctx, [pinTask], 0))),
+        retryOp(() => publish(ctx, buildPinRequest(ctx, [searchTask], 1)))
+      ]);
+
+      recordHistory({ action: 'pin', threadID: String(threadID), messageID: String(messageID) });
+      utils.log('pinMessage', `Pinned message ${messageID} in thread ${threadID}`);
+    } else if (action === 'unpin') {
+      const searchTask1 = {
+        label: '751',
+        payload: JSON.stringify({ thread_key: String(threadID), message_id: String(messageID), pinned_message_state: 0 }),
+        queue_name: 'set_pinned_message_search',
+        task_id: (ctx.wsTaskNumber = (ctx.wsTaskNumber || 0) + 1)
+      };
+      const unpinTask = {
+        label: '431',
+        payload: JSON.stringify({ thread_key: String(threadID), message_id: String(messageID), timestamp_ms: Date.now() }),
+        queue_name: `unpin_msg_v2_${threadID}`,
+        task_id: (ctx.wsTaskNumber = (ctx.wsTaskNumber || 0) + 1)
+      };
+      const searchTask2 = {
+        label: '751',
+        payload: JSON.stringify({ thread_key: String(threadID), message_id: String(messageID), pinned_message_state: 0 }),
+        queue_name: 'set_pinned_message_search',
+        task_id: (ctx.wsTaskNumber = (ctx.wsTaskNumber || 0) + 1)
+      };
+
+      const publish = useAck ? (c) => mqttPublishWithAck(ctx, c) : (c) => new Promise((res, rej) => {
+        ctx.mqttClient.publish('/ls_req', JSON.stringify(c), { qos: 1, retain: false }, e => e ? rej(e) : res({ success: true, request_id: c.request_id }));
+      });
+
+      await retryOp(() => publish(buildPinRequest(ctx, [searchTask1], 0)));
+      await retryOp(() => publish(buildPinRequest(ctx, [unpinTask], 1)));
+      results = [await retryOp(() => publish(buildPinRequest(ctx, [searchTask2], 2)))];
+
+      recordHistory({ action: 'unpin', threadID: String(threadID), messageID: String(messageID) });
+      utils.log('pinMessage', `Unpinned message ${messageID} in thread ${threadID}`);
+    }
+
+    return {
+      success: true,
+      action,
+      threadID: String(threadID),
+      messageID: String(messageID),
+      publishResults: results,
+      timestamp: Date.now()
+    };
+  };
+
+  Object.assign(module.exports, {
+    getHistory: (limit = 50) => PIN_HISTORY.slice(0, limit),
+    clearCache: (threadID) => {
+      if (threadID) PIN_CACHE.delete(`pins_${threadID}`);
+      else PIN_CACHE.clear();
+      return { success: true };
+    }
+  });
+};