fca-phantom 1.0.0

package/phantom/dispatch/stickers.js

@@ -0,0 +1,395 @@
+"use strict";
+
+/**
+ * Sticker API Module — Advanced for Phantom SDK
+ *
+ * Provides access to Facebook's GraphQL-based sticker endpoints.
+ * Made by @ChoruOfficial — massively extended for phantom-fca
+ *
+ * Features:
+ *  - Sticker search with pagination support
+ *  - Pack listing, store browsing, and full auto-pagination
+ *  - AI-generated & trending sticker fetching
+ *  - Individual sticker metadata resolution
+ *  - Pack add/remove management
+ *  - In-memory caching (5 minutes)
+ *  - Exponential-backoff retry on transient GraphQL errors
+ *  - Parallel batch sticker resolution
+ *  - Recent sticker tray management
+ */
+
+const utils = require('../datastore/models/matrix/tools');
+
+const _cache    = new Map();
+const CACHE_TTL = 5 * 60 * 1000;
+
+// ── Shared helpers ────────────────────────────────────────────────────────────
+function cached(key, fn) {
+  const hit = _cache.get(key);
+  if (hit && Date.now() - hit.ts < CACHE_TTL) return Promise.resolve(hit.data);
+  return fn().then(data => { _cache.set(key, { data, ts: Date.now() }); return data; });
+}
+
+function normalizeSticker(node) {
+  if (!node) return null;
+  return {
+    type:        'sticker',
+    ID:          node.id,
+    stickerID:   node.id,
+    url:         node.image?.uri         || node.url         || null,
+    animatedUrl: node.animated_image?.uri || node.animatedUrl || null,
+    spriteUrl:   node.sprite_image?.uri  || null,
+    packID:      node.pack?.id           || node.packID      || null,
+    packName:    node.pack?.name         || null,
+    label:       node.label || node.accessibility_label || null,
+    width:       node.image?.width       || null,
+    height:      node.image?.height      || null,
+    isAnimated:  !!(node.animated_image?.uri),
+  };
+}
+
+function normalizePack(node) {
+  if (!node) return null;
+  return {
+    id:        node.id,
+    name:      node.name,
+    thumbnail: node.thumbnail_image?.uri || null,
+    stickerCount: node.sticker_count || null,
+    isOwned:   node.is_owned !== undefined ? node.is_owned : null,
+    isNew:     node.is_new   || false,
+  };
+}
+
+// ── Formatters ────────────────────────────────────────────────────────────────
+function formatPackList(data) {
+  const trayPacks  = data?.data?.picker_plugins?.sticker_picker?.sticker_store?.tray_packs;
+  const storePacks = data?.data?.viewer?.sticker_store?.available_packs;
+  const packData   = storePacks || trayPacks;
+
+  if (!packData) return { packs: [], page_info: { has_next_page: false }, store_id: null };
+
+  const edges = Array.isArray(packData) ? packData : packData.edges || [];
+  return {
+    packs:      edges.map(e => normalizePack(e.node || e)).filter(Boolean),
+    page_info:  packData.page_info || { has_next_page: false },
+    store_id:   data?.data?.viewer?.sticker_store?.id || null,
+  };
+}
+
+function formatStickerSearchResults(data) {
+  const edges = data?.data?.sticker_search?.sticker_results?.edges || [];
+  return edges.map(e => normalizeSticker(e.node)).filter(Boolean);
+}
+
+function formatStickerPackResults(data) {
+  const edges = data?.data?.sticker_pack?.stickers?.edges || [];
+  return edges.map(e => normalizeSticker(e.node)).filter(Boolean);
+}
+
+function formatAiStickers(data) {
+  const nodes = data?.data?.xfb_trending_generated_ai_stickers?.nodes || [];
+  return nodes.map(n => normalizeSticker(n)).filter(Boolean);
+}
+
+function formatRecentStickers(data) {
+  const edges = data?.data?.viewer?.recent_stickers?.edges || [];
+  return edges.map(e => normalizeSticker(e.node)).filter(Boolean);
+}
+
+function formatTrayStickers(data) {
+  const plugins = data?.data?.picker_plugins?.sticker_picker?.recent_stickers;
+  if (!plugins) return [];
+  const stickers = Array.isArray(plugins) ? plugins : plugins.edges?.map(e => e.node) || [];
+  return stickers.map(normalizeSticker).filter(Boolean);
+}
+
+// ── Module export ─────────────────────────────────────────────────────────────
+module.exports = function (defaultFuncs, api, ctx) {
+
+  // ── Request helper with retry ─────────────────────────────────────────────
+  async function makeRequest(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) throw new Error("GraphQL returned no data");
+        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("StickerAPI", `Retry ${attempt}/${retries} in ${Math.round(wait)}ms`);
+        await new Promise(r => setTimeout(r, wait));
+      }
+    }
+    throw lastErr;
+  }
+
+  return {
+
+    /**
+     * Search for stickers by keyword.
+     * @param {string}  query
+     * @param {object} [options]  { limit, width, height }
+     * @returns {Promise<Array>}
+     */
+    search: async function (query, options = {}) {
+      if (!query) throw new Error("stickers.search: query is required");
+      const w = options.width  || 128;
+      const h = options.height || 128;
+      const form = {
+        fb_api_caller_class:      'RelayModern',
+        fb_api_req_friendly_name: 'CometStickerPickerSearchResultsRootQuery',
+        variables: JSON.stringify({
+          scale:            3,
+          search_query:     query.trim(),
+          sticker_height:   h,
+          sticker_width:    w,
+          stickerInterface: "MESSAGES",
+        }),
+        doc_id: '24004987559125954',
+      };
+      const res = await makeRequest(form);
+      let stickers = formatStickerSearchResults(res);
+      if (options.limit) stickers = stickers.slice(0, options.limit);
+      return stickers;
+    },
+
+    /**
+     * List the user's installed sticker packs (tray).
+     * @returns {Promise<Array>}
+     */
+    listPacks: async function () {
+      return cached('listPacks', async () => {
+        const form = {
+          fb_api_caller_class:      'RelayModern',
+          fb_api_req_friendly_name: 'CometStickerPickerCardQuery',
+          variables: JSON.stringify({ scale: 3, stickerInterface: "MESSAGES" }),
+          doc_id:   '10095807770482952',
+        };
+        const res = await makeRequest(form);
+        return formatPackList(res).packs;
+      });
+    },
+
+    /**
+     * Get all available sticker packs from the store (fully auto-paginated).
+     * @param {object} [options]  { maxPages }
+     * @returns {Promise<Array>}
+     */
+    getStorePacks: async function (options = {}) {
+      const maxPages = options.maxPages || 50;
+      utils.log("StickerAPI", "Fetching all store packs (auto-paginated)...");
+      let allPacks = [], page = 0;
+
+      const firstForm = {
+        fb_api_caller_class:      'RelayModern',
+        fb_api_req_friendly_name: 'CometStickersStoreDialogQuery',
+        variables: JSON.stringify({}),
+        doc_id:   '29237828849196584',
+      };
+      let res = await makeRequest(firstForm);
+      let { packs, page_info, store_id } = formatPackList(res);
+      allPacks.push(...packs);
+      page++;
+
+      while (page_info?.has_next_page && page < maxPages) {
+        const nextForm = {
+          fb_api_caller_class:      'RelayModern',
+          fb_api_req_friendly_name: 'CometStickersStorePackListPaginationQuery',
+          variables: JSON.stringify({ count: 20, cursor: page_info.end_cursor, id: store_id }),
+          doc_id:   '9898634630218439',
+        };
+        res = await makeRequest(nextForm);
+        const next = formatPackList(res);
+        allPacks.push(...next.packs);
+        page_info = next.page_info;
+        page++;
+      }
+
+      utils.log("StickerAPI", `Fetched ${allPacks.length} store packs in ${page} pages`);
+      return allPacks;
+    },
+
+    /**
+     * Merge user's tray packs with store packs into a deduplicated list.
+     * @returns {Promise<Array>}
+     */
+    listAllPacks: async function () {
+      const [myPacks, storePacks] = await Promise.all([this.listPacks(), this.getStorePacks()]);
+      const map = new Map();
+      [...myPacks, ...storePacks].forEach(p => map.set(p.id, p));
+      return Array.from(map.values());
+    },
+
+    /**
+     * Add a sticker pack by ID.
+     * @param {string} packID
+     * @returns {Promise<Object>}
+     */
+    addPack: async function (packID) {
+      if (!packID) throw new Error("stickers.addPack: packID is required");
+      const form = {
+        fb_api_caller_class:      'RelayModern',
+        fb_api_req_friendly_name: 'CometStickersStorePackMutationAddMutation',
+        variables: JSON.stringify({
+          input: {
+            pack_id:             packID,
+            actor_id:            ctx.userID,
+            client_mutation_id:  String(Date.now() % 1e9),
+          }
+        }),
+        doc_id: '9877489362345320',
+      };
+      const res = await makeRequest(form);
+      return normalizePack(res.data?.sticker_pack_add?.sticker_pack) || res.data;
+    },
+
+    /**
+     * Remove a sticker pack by ID.
+     * @param {string} packID
+     * @returns {Promise<Object>}
+     */
+    removePack: async function (packID) {
+      if (!packID) throw new Error("stickers.removePack: packID is required");
+      const form = {
+        fb_api_caller_class:      'RelayModern',
+        fb_api_req_friendly_name: 'CometStickersStorePackMutationRemoveMutation',
+        variables: JSON.stringify({
+          input: {
+            pack_id:             packID,
+            actor_id:            ctx.userID,
+            client_mutation_id:  String(Date.now() % 1e9),
+          }
+        }),
+        doc_id: '25244534060527988',
+      };
+      const res = await makeRequest(form);
+      return res.data;
+    },
+
+    /**
+     * Get all stickers inside a specific pack.
+     * @param {string} packID
+     * @param {object} [options]  { width, height }
+     * @returns {Promise<Array>}
+     */
+    getStickersInPack: async function (packID, options = {}) {
+      if (!packID) throw new Error("stickers.getStickersInPack: packID is required");
+      return cached(`pack::${packID}`, async () => {
+        const form = {
+          fb_api_caller_class:      'RelayModern',
+          fb_api_req_friendly_name: 'CometStickerPickerPackContentRootQuery',
+          variables: JSON.stringify({
+            packID,
+            stickerWidth:  options.width  || 128,
+            stickerHeight: options.height || 128,
+            scale:         3,
+          }),
+          doc_id: '23982341384707469',
+        };
+        const res = await makeRequest(form);
+        return formatStickerPackResults(res);
+      });
+    },
+
+    /**
+     * Get trending AI-generated stickers.
+     * @param {object} [options]  { limit }
+     * @returns {Promise<Array>}
+     */
+    getAiStickers: async function ({ limit = 20 } = {}) {
+      return cached(`ai_stickers::${limit}`, async () => {
+        const form = {
+          fb_api_caller_class:      'RelayModern',
+          fb_api_req_friendly_name: 'CometStickerPickerStickerGeneratedCardQuery',
+          variables: JSON.stringify({ limit }),
+          doc_id:   '24151467751156443',
+        };
+        const res = await makeRequest(form);
+        return formatAiStickers(res);
+      });
+    },
+
+    /**
+     * Get the user's recent stickers.
+     * @param {object} [options]  { limit }
+     * @returns {Promise<Array>}
+     */
+    getRecentStickers: async function ({ limit = 30 } = {}) {
+      const form = {
+        fb_api_caller_class:      'RelayModern',
+        fb_api_req_friendly_name: 'CometStickerPickerRecentStickersQuery',
+        variables: JSON.stringify({ scale: 3, stickerInterface: "MESSAGES" }),
+        doc_id:   '10095807770482952',
+      };
+      const res = await makeRequest(form);
+      const tray = formatTrayStickers(res);
+      return tray.slice(0, limit);
+    },
+
+    /**
+     * Resolve full metadata for one or many sticker IDs in parallel.
+     * @param {string|string[]} stickerIDs
+     * @returns {Promise<object|object[]>}
+     */
+    resolveSticker: async function (stickerIDs) {
+      const ids  = Array.isArray(stickerIDs) ? stickerIDs : [stickerIDs];
+      const form = {
+        fb_api_caller_class:      'RelayModern',
+        fb_api_req_friendly_name: 'CometStickerPickerStickerQuery',
+        variables: JSON.stringify({ stickerIDs: ids, scale: 3 }),
+        doc_id:   '9580756598638278',
+      };
+      try {
+        const res = await makeRequest(form);
+        const nodes = (res?.data?.stickers || ids.map(() => null));
+        const resolved = (Array.isArray(nodes) ? nodes : Object.values(nodes))
+          .map(n => normalizeSticker(n)).filter(Boolean);
+        return ids.length === 1 ? (resolved[0] || null) : resolved;
+      } catch {
+        // Fallback: return minimal objects
+        const fallback = ids.map(id => ({ type: 'sticker', ID: id, stickerID: id }));
+        return ids.length === 1 ? fallback[0] : fallback;
+      }
+    },
+
+    /**
+     * Generate an AI sticker from a text prompt.
+     * @param {string}  prompt
+     * @param {object} [options]  { numResults }
+     * @returns {Promise<Array>}
+     */
+    generateAiSticker: async function (prompt, { numResults = 4 } = {}) {
+      if (!prompt) throw new Error("stickers.generateAiSticker: prompt is required");
+      const form = {
+        av:                       ctx.userID,
+        __user:                   ctx.userID,
+        fb_dtsg:                  ctx.fb_dtsg,
+        fb_api_caller_class:      'RelayModern',
+        fb_api_req_friendly_name: 'useGenerateAIStickerMutation',
+        variables: JSON.stringify({
+          input: {
+            client_mutation_id: String(Date.now() % 1e9),
+            actor_id:           ctx.userID,
+            num_results:        Math.min(numResults, 8),
+            prompt:             prompt.trim(),
+          }
+        }),
+        server_timestamps: true,
+        doc_id:            '6774614342659830',
+      };
+      const res     = await makeRequest(form);
+      const stickers = res?.data?.xfb_generate_ai_sticker?.stickers || [];
+      return stickers.map(normalizeSticker).filter(Boolean);
+    },
+
+  };
+};

package/phantom/dispatch/story.js

@@ -0,0 +1,240 @@
+"use strict";
+
+const utils = require('../datastore/models/matrix/tools');
+const { URL } = require('url');
+const { globalShield } = require('../datastore/models/matrix/ghost');
+
+const STORY_CACHE = new Map();
+const STORY_CACHE_TTL = 5 * 60 * 1000;
+const STORY_HISTORY = [];
+const MAX_HISTORY = 300;
+
+const ALLOWED_REACTIONS = new Set(['❤️', '👍', '🤗', '😆', '😡', '😢', '😮']);
+
+const FONT_MAP = {
+  headline: '1919119914775364',
+  classic: '516266749248495',
+  casual: '516266749248495',
+  fancy: '1790435664339626',
+  bold: '1919119914775364'
+};
+
+const BG_MAP = {
+  orange: '2163607613910521',
+  blue: '401372137331149',
+  green: '367314917184744',
+  modern: '554617635055752',
+  dark: '2163607613910521',
+  light: '401372137331149'
+};
+
+async function retryOp(fn, retries = 4, base = 600) {
+  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 extractStoryIDFromURL(url) {
+  try {
+    const u = new URL(url);
+    const parts = u.pathname.split('/');
+    const idx = parts.indexOf('stories');
+    if (idx !== -1 && parts.length > idx + 2) return parts[idx + 2];
+    const storyParam = u.searchParams.get('story_fbid');
+    if (storyParam) return storyParam;
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+function resolveStoryID(storyIdOrUrl) {
+  if (!storyIdOrUrl) throw new Error('story: storyID or URL is required');
+  const extracted = extractStoryIDFromURL(storyIdOrUrl);
+  return extracted || storyIdOrUrl;
+}
+
+function recordHistory(op) {
+  STORY_HISTORY.unshift({ ...op, ts: Date.now() });
+  if (STORY_HISTORY.length > MAX_HISTORY) STORY_HISTORY.length = MAX_HISTORY;
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+
+  async function sendStoryReply(storyIdOrUrl, message, isReaction, options = {}) {
+    const storyID = resolveStoryID(storyIdOrUrl);
+    const { retry = true, timeout = 15000 } = options;
+
+    if (!message) throw new Error('story: message or reaction is required');
+
+    if (isReaction && !ALLOWED_REACTIONS.has(message)) {
+      throw new Error(`story: invalid reaction "${message}". Allowed: ${Array.from(ALLOWED_REACTIONS).join(' ')}`);
+    }
+
+    const variables = {
+      input: {
+        attribution_id_v2: 'StoriesCometSuspenseRoot.react,comet.stories.viewer,via_cold_start',
+        message,
+        story_id: storyID,
+        story_reply_type: isReaction ? 'LIGHT_WEIGHT' : 'TEXT',
+        actor_id: ctx.userID,
+        client_mutation_id: String(Math.floor(Math.random() * 10 + 1))
+      }
+    };
+
+    if (isReaction) {
+      variables.input.lightweight_reaction_actions = { offsets: [0], reaction: message };
+    }
+
+    const form = {
+      av: ctx.userID,
+      __user: ctx.userID,
+      __a: '1',
+      fb_dtsg: ctx.fb_dtsg,
+      jazoest: ctx.jazoest,
+      fb_api_caller_class: 'RelayModern',
+      fb_api_req_friendly_name: 'useStoriesSendReplyMutation',
+      variables: JSON.stringify(variables),
+      doc_id: '9697491553691692'
+    };
+
+    await globalShield.addSmartDelay();
+
+    const exec = () => defaultFuncs.post('https://www.facebook.com/api/graphql/', ctx.jar, form, {});
+    const res = retry ? await retryOp(exec) : await exec();
+
+    if (res.data?.errors) throw new Error(JSON.stringify(res.data.errors));
+
+    const storyReplyData = res.data?.data?.direct_message_reply;
+    if (!storyReplyData) throw new Error('story: "direct_message_reply" not found in response');
+
+    recordHistory({ action: isReaction ? 'react' : 'reply', storyID, message });
+    return { success: true, storyID, [isReaction ? 'reaction' : 'message']: message, result: storyReplyData, timestamp: Date.now() };
+  }
+
+  async function create(message, fontName = 'classic', backgroundName = 'blue', options = {}) {
+    const { retry = true } = options;
+    if (!message || typeof message !== 'string') throw new Error('story.create: message must be a non-empty string');
+
+    const fontId = FONT_MAP[fontName.toLowerCase()] || FONT_MAP.classic;
+    const bgId = BG_MAP[backgroundName.toLowerCase()] || BG_MAP.blue;
+
+    const variables = {
+      input: {
+        audiences: [{ stories: { self: { target_id: ctx.userID } } }],
+        audiences_is_complete: true,
+        logging: { composer_session_id: `createStoriesText-${Date.now()}` },
+        navigation_data: { attribution_id_v2: 'StoriesCreateRoot.react,comet.stories.create' },
+        source: 'WWW',
+        message: { ranges: [], text: message },
+        text_format_metadata: { inspirations_custom_font_id: fontId },
+        text_format_preset_id: bgId,
+        tracking: [null],
+        actor_id: ctx.userID,
+        client_mutation_id: String(Math.floor(Math.random() * 9999))
+      }
+    };
+
+    const form = {
+      __a: '1',
+      fb_dtsg: ctx.fb_dtsg,
+      jazoest: ctx.jazoest,
+      fb_api_caller_class: 'RelayModern',
+      fb_api_req_friendly_name: 'StoriesCreateMutation',
+      variables: JSON.stringify(variables),
+      doc_id: '24226878183562473'
+    };
+
+    await globalShield.addSmartDelay();
+
+    const exec = () => defaultFuncs.post('https://www.facebook.com/api/graphql/', ctx.jar, form, {});
+    const res = retry ? await retryOp(exec) : await exec();
+
+    if (res.data?.errors) throw new Error(JSON.stringify(res.data.errors));
+
+    const storyNode = res.data?.data?.story_create?.viewer?.actor?.story_bucket?.nodes?.[0]?.first_story_to_show;
+    if (!storyNode?.id) throw new Error('story.create: storyID not found in response');
+
+    recordHistory({ action: 'create', message: message.slice(0, 80), font: fontName, bg: backgroundName, storyID: storyNode.id });
+    utils.log('story.create', `Story created: ${storyNode.id}`);
+
+    return { success: true, storyID: storyNode.id, font: fontName, background: backgroundName, timestamp: Date.now() };
+  }
+
+  async function getStory(storyIdOrUrl, options = {}) {
+    const storyID = resolveStoryID(storyIdOrUrl);
+    const { skipCache = false } = options;
+    const cacheKey = `story_${storyID}`;
+
+    if (!skipCache) {
+      const cached = STORY_CACHE.get(cacheKey);
+      if (cached && Date.now() - cached.ts < STORY_CACHE_TTL) return { ...cached.result, fromCache: true };
+    }
+
+    const form = {
+      av: ctx.userID,
+      fb_api_caller_class: 'RelayModern',
+      fb_api_req_friendly_name: 'StoriesRootQuery',
+      variables: JSON.stringify({ story_bucket_id: storyID }),
+      doc_id: '9781019695323982'
+    };
+
+    const res = await retryOp(() => defaultFuncs.post('https://www.facebook.com/api/graphql/', ctx.jar, form, {}));
+    if (res.data?.errors) throw new Error(JSON.stringify(res.data.errors));
+
+    const result = { success: true, storyID, data: res.data, timestamp: Date.now() };
+    STORY_CACHE.set(cacheKey, { result, ts: Date.now() });
+    return result;
+  }
+
+  async function deleteStory(storyID, options = {}) {
+    if (!storyID) throw new Error('story.delete: storyID is required');
+    const { retry = true } = options;
+
+    const form = {
+      av: ctx.userID,
+      __user: ctx.userID,
+      fb_dtsg: ctx.fb_dtsg,
+      fb_api_caller_class: 'RelayModern',
+      fb_api_req_friendly_name: 'StoriesDeleteMutation',
+      variables: JSON.stringify({
+        input: {
+          story_id: String(storyID),
+          actor_id: ctx.userID,
+          client_mutation_id: String(Math.floor(Math.random() * 9999))
+        }
+      }),
+      doc_id: '5697804170303568'
+    };
+
+    await globalShield.addSmartDelay();
+
+    const exec = () => defaultFuncs.post('https://www.facebook.com/api/graphql/', ctx.jar, form, {});
+    const res = retry ? await retryOp(exec) : await exec();
+    if (res.data?.errors) throw new Error(JSON.stringify(res.data.errors));
+
+    STORY_CACHE.delete(`story_${storyID}`);
+    recordHistory({ action: 'delete', storyID });
+    return { success: true, storyID, timestamp: Date.now() };
+  }
+
+  return {
+    create,
+    react: (storyIdOrUrl, reaction, options) => sendStoryReply(storyIdOrUrl, reaction, true, options),
+    msg: (storyIdOrUrl, message, options) => sendStoryReply(storyIdOrUrl, message, false, options),
+    reply: (storyIdOrUrl, message, options) => sendStoryReply(storyIdOrUrl, message, false, options),
+    get: getStory,
+    delete: deleteStory,
+    extractID: extractStoryIDFromURL,
+    getHistory: (limit = 50) => STORY_HISTORY.slice(0, limit),
+    clearCache: () => { STORY_CACHE.clear(); return { success: true }; },
+    allowedReactions: Array.from(ALLOWED_REACTIONS),
+    fonts: Object.keys(FONT_MAP),
+    backgrounds: Object.keys(BG_MAP)
+  };
+};