fca-phantom 1.0.0

package/phantom/dispatch/theme.js

@@ -0,0 +1,296 @@
+"use strict";
+
+/**
+ * theme — Advanced Theme Manager for Phantom SDK
+ *
+ * Made by Choru Official (original) — massively extended for phantom-fca
+ *
+ * Features:
+ *  - List available themes with full metadata
+ *  - Set theme by name (exact, partial, fuzzy), by ID, or by index
+ *  - AI theme generation and application via createAITheme
+ *  - MQTT primary path with GraphQL HTTP fallback
+ *  - Retry and error recovery for MQTT publish failures
+ *  - Thread-level theme change event object (type, threadID, themeID, senderID, timestamp)
+ *  - Undo last theme change (restore previous)
+ *  - Full callback + Promise dual API
+ */
+
+const utils = require('../datastore/models/matrix/tools');
+
+// Per-thread undo stack
+const _undoStack = new Map(); // threadID → [{ themeID, themeName }]
+
+function pushUndo(threadID, themeID, themeName) {
+  if (!_undoStack.has(threadID)) _undoStack.set(threadID, []);
+  const stack = _undoStack.get(threadID);
+  stack.push({ themeID, themeName, ts: Date.now() });
+  if (stack.length > 5) stack.shift(); // keep last 5
+}
+
+// ── Fuzzy score: higher = better match ────────────────────────────────────────
+function fuzzyScore(name, query) {
+  const n = name.toLowerCase(), q = query.toLowerCase();
+  if (n === q)          return 100;
+  if (n.startsWith(q))  return 80;
+  if (n.includes(q))    return 60;
+  // partial char match
+  let qi = 0;
+  for (let ni = 0; ni < n.length && qi < q.length; ni++) {
+    if (n[ni] === q[qi]) qi++;
+  }
+  return qi === q.length ? 30 : 0;
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+
+  // ── Fetch the full theme catalogue ─────────────────────────────────────────
+  async function fetchThemes(threadID) {
+    const form = {
+      av:                       ctx.userID,
+      __user:                   ctx.userID,
+      fb_dtsg:                  ctx.fb_dtsg,
+      lsd:                      ctx.lsd || ctx.fb_dtsg,
+      fb_api_caller_class:      'RelayModern',
+      fb_api_req_friendly_name: 'MWPThreadThemeQuery_AllThemesQuery',
+      variables:                JSON.stringify({ version: "default" }),
+      server_timestamps:        true,
+      doc_id:                   '24474714052117636',
+    };
+
+    const resData = await defaultFuncs
+      .post("https://www.facebook.com/api/graphql/", ctx.jar, form, null, {
+        "x-fb-friendly-name": "MWPThreadThemeQuery_AllThemesQuery",
+        "x-fb-lsd":           ctx.lsd,
+        "referer":            `https://www.facebook.com/messages/t/${threadID}`,
+      })
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+    if (resData.errors) throw new Error(JSON.stringify(resData.errors));
+    if (!resData.data?.messenger_thread_themes) throw new Error("Could not retrieve theme list");
+
+    return resData.data.messenger_thread_themes.map(t => {
+      if (!t?.id) return null;
+      return {
+        id:                            t.id,
+        name:                          t.accessibility_label || t.name || '',
+        description:                   t.description || null,
+        appColorMode:                  t.app_color_mode,
+        composerBackgroundColor:       t.composer_background_color,
+        backgroundGradientColors:      t.background_gradient_colors,
+        titleBarButtonTintColor:       t.title_bar_button_tint_color,
+        inboundMessageGradientColors:  t.inbound_message_gradient_colors,
+        titleBarTextColor:             t.title_bar_text_color,
+        composerTintColor:             t.composer_tint_color,
+        titleBarAttributionColor:      t.title_bar_attribution_color,
+        composerInputBackgroundColor:  t.composer_input_background_color,
+        hotLikeColor:                  t.hot_like_color,
+        backgroundImage:               t.background_asset?.image?.uri || null,
+        messageTextColor:              t.message_text_color,
+        inboundMessageTextColor:       t.inbound_message_text_color,
+        primaryButtonBackgroundColor:  t.primary_button_background_color,
+        titleBarBackgroundColor:       t.title_bar_background_color,
+        tertiaryTextColor:             t.tertiary_text_color,
+        reactionPillBackgroundColor:   t.reaction_pill_background_color,
+        secondaryTextColor:            t.secondary_text_color,
+        fallbackColor:                 t.fallback_color,
+        gradientColors:                t.gradient_colors,
+        normalThemeId:                 t.normal_theme_id,
+        iconAsset:                     t.icon_asset?.image?.uri || null,
+      };
+    }).filter(Boolean);
+  }
+
+  // ── MQTT theme publisher ────────────────────────────────────────────────────
+  async function publishThemeViaMqtt(threadID, themeID, themeName, initiatorID) {
+    if (!ctx.mqttClient) throw new Error("Not connected to MQTT");
+
+    const publish = (label, queueName, extra = {}) => {
+      ctx.wsReqNumber  = (ctx.wsReqNumber  || 0) + 1;
+      ctx.wsTaskNumber = (ctx.wsTaskNumber || 0) + 1;
+      const reqId  = ctx.wsReqNumber;
+      const taskId = ctx.wsTaskNumber;
+
+      const content = {
+        app_id:  ctx.appID || '2220391788200892',
+        payload: JSON.stringify({
+          epoch_id:   parseInt(utils.generateOfflineThreadingID ? utils.generateOfflineThreadingID() : Date.now()),
+          tasks:      [{
+            failure_count: null,
+            label,
+            payload: JSON.stringify({ thread_key: threadID.toString(), theme_fbid: themeID.toString(), sync_group: 1, ...extra }),
+            queue_name: queueName,
+            task_id:    taskId,
+          }],
+          version_id: '24631415369801570',
+        }),
+        request_id: reqId,
+        type:       3,
+      };
+
+      return new Promise((res, rej) => {
+        ctx.mqttClient.publish('/ls_req', JSON.stringify(content), { qos: 1, retain: false }, err => {
+          if (err) rej(new Error(`MQTT publish failed (label ${label}): ${err.message}`));
+          else res();
+        });
+      });
+    };
+
+    // Publish all four MQTT messages in parallel for speed
+    await Promise.all([
+      publish('1013', 'ai_generated_theme'),
+      publish('1037', 'msgr_custom_thread_theme'),
+      publish('1028', 'thread_theme_writer'),
+      publish('43',   'thread_theme', { source: null, payload: null }),
+    ]);
+
+    return {
+      type:      "thread_theme_update",
+      threadID,
+      themeID,
+      themeName,
+      senderID:  initiatorID,
+      BotID:     ctx.userID,
+      timestamp: Date.now(),
+    };
+  }
+
+  // ── Argument normaliser ─────────────────────────────────────────────────────
+  function normaliseArgs(themeName, threadID, callback, initiatorID) {
+    let _cb, _tid = threadID, _init = initiatorID;
+
+    if (typeof callback === 'function' || typeof callback === 'object' && callback?.constructor?.name === 'AsyncFunction') {
+      _cb   = callback;
+      _init = initiatorID;
+    } else if (typeof threadID === 'function') {
+      _cb   = threadID;
+      _tid  = null;
+      _init = callback;
+    } else if (typeof callback === 'string') {
+      _init = callback;
+    }
+
+    return { _cb, _tid: _tid || ctx.threadID, _init: _init || ctx.userID };
+  }
+
+  // ── Main exported function ─────────────────────────────────────────────────
+  /**
+   * Manage or set the theme for a Messenger thread.
+   *
+   * @param {string}   themeName   Theme name / partial name / ID / "list" / "ai:<prompt>" / "undo"
+   * @param {string}   [threadID]  Target thread (required unless ctx.threadID is set)
+   * @param {Function} [callback]  Node-style (err, result) callback
+   * @param {string}   [initiatorID] User initiating the change (defaults to bot userID)
+   * @returns {Promise}
+   *
+   * Special values for themeName:
+   *   "list"           → return array of all available themes
+   *   "undo"           → revert to previous theme for this thread
+   *   "ai:<prompt>"    → generate AI theme matching prompt and apply it
+   *   "#<themeID>"     → set by exact ID  (e.g. "#196241301102133")
+   *   "<number>"       → match by theme index in the list
+   */
+  return async function theme(themeName, threadID, callback, initiatorID) {
+    const { _cb: rawCb, _tid, _init } = normaliseArgs(themeName, threadID, callback, initiatorID);
+
+    let _resolveFunc, _rejectFunc;
+    const finalPromise = new Promise((res, rej) => { _resolveFunc = res; _rejectFunc = rej; });
+
+    const _callback = rawCb || ((err, data) => { if (err) _rejectFunc(err); else _resolveFunc(data); });
+
+    if (!_tid)      return _callback(new Error("theme: threadID is required"));
+    if (!themeName) return _callback(new Error("theme: themeName is required"));
+
+    try {
+      const normalised = themeName.trim().toLowerCase();
+
+      // ── LIST ──────────────────────────────────────────────────────────────
+      if (normalised === 'list') {
+        const themes = await fetchThemes(_tid);
+        return _callback(null, themes);
+      }
+
+      // ── UNDO ──────────────────────────────────────────────────────────────
+      if (normalised === 'undo') {
+        const stack = _undoStack.get(_tid);
+        if (!stack || stack.length < 2) return _callback(new Error("No previous theme to undo to for this thread"));
+        stack.pop(); // remove current
+        const prev = stack[stack.length - 1];
+        const event = await publishThemeViaMqtt(_tid, prev.themeID, prev.themeName, _init);
+        return _callback(null, event);
+      }
+
+      // ── AI THEME ──────────────────────────────────────────────────────────
+      if (normalised.startsWith('ai:')) {
+        const prompt = themeName.slice(3).trim();
+        if (!prompt) return _callback(new Error("theme: AI prompt is required after 'ai:'"));
+        if (!api.createAITheme) return _callback(new Error("createAITheme is not available"));
+
+        const aiThemes = await api.createAITheme(prompt, 1, { enrichPrompt: true });
+        if (!aiThemes?.length) return _callback(new Error("AI theme generation returned no results"));
+
+        const best = aiThemes[0];
+        if (!best.id) return _callback(new Error("AI theme has no usable ID"));
+
+        pushUndo(_tid, best.id, best.name || prompt);
+        const event = await publishThemeViaMqtt(_tid, best.id, best.name || prompt, _init);
+        return _callback(null, { ...event, aiTheme: best });
+      }
+
+      // ── SET BY EXPLICIT ID ────────────────────────────────────────────────
+      if (themeName.startsWith('#')) {
+        const explicitId = themeName.slice(1).trim();
+        pushUndo(_tid, explicitId, explicitId);
+        const event = await publishThemeViaMqtt(_tid, explicitId, explicitId, _init);
+        return _callback(null, event);
+      }
+
+      // ── SEARCH IN CATALOGUE ───────────────────────────────────────────────
+      const themes = await fetchThemes(_tid);
+
+      let matched = null;
+
+      // 1. Exact ID match
+      matched = themes.find(t => t.id === normalised);
+
+      // 2. Numeric index
+      if (!matched && /^\d+$/.test(normalised)) {
+        const idx = parseInt(normalised, 10);
+        matched = themes[idx] || themes.find(t => t.id === normalised);
+      }
+
+      // 3. Exact name match
+      if (!matched) matched = themes.find(t => t.name.toLowerCase() === normalised);
+
+      // 4. Starts-with match
+      if (!matched) matched = themes.find(t => t.name.toLowerCase().startsWith(normalised));
+
+      // 5. Contains match
+      if (!matched) matched = themes.find(t => t.name.toLowerCase().includes(normalised));
+
+      // 6. Fuzzy scoring — pick highest
+      if (!matched) {
+        const scored = themes
+          .map(t => ({ t, score: fuzzyScore(t.name, normalised) }))
+          .filter(x => x.score > 0)
+          .sort((a, b) => b.score - a.score);
+        matched = scored[0]?.t || null;
+      }
+
+      if (!matched) {
+        const names = themes.slice(0, 8).map(t => t.name).join(', ');
+        return _callback(new Error(`Theme "${themeName}" not found. Available themes include: ${names}`));
+      }
+
+      pushUndo(_tid, matched.id, matched.name);
+      const event = await publishThemeViaMqtt(_tid, matched.id, matched.name, _init);
+      _callback(null, event);
+
+    } catch (err) {
+      const finalError = err instanceof Error ? err : new Error(err?.message || err?.error || 'Unknown theme error');
+      _callback(finalError);
+    }
+
+    return finalPromise;
+  };
+};

package/phantom/dispatch/unfriend.js

@@ -0,0 +1,199 @@
+"use strict";
+
+const utils = require('../datastore/models/matrix/tools');
+const { globalShield } = require('../datastore/models/matrix/ghost');
+
+const UNFRIEND_HISTORY = [];
+const MAX_HISTORY = 200;
+const UNDO_STACK = [];
+const MAX_UNDO = 50;
+const CONFIRMATION_CACHE = new Map();
+const CONFIRMATION_TTL = 5000;
+
+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));
+    }
+  }
+}
+
+async function httpUnfriend(defaultFuncs, ctx, userID) {
+  const form = {
+    uid: String(userID),
+    unref: 'bd_friends_tab',
+    floc: 'friends_tab',
+    'nctr[_mod]': `pagelet_timeline_app_collection_${ctx.userID}:2356318349:2`
+  };
+
+  const res = await defaultFuncs.post(
+    'https://www.facebook.com/ajax/profile/removefriendconfirm.php',
+    ctx.jar,
+    form
+  ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+  if (res && res.error) throw res;
+  return { success: true, userID: String(userID), method: 'http', timestamp: Date.now() };
+}
+
+async function graphqlUnfriend(defaultFuncs, ctx, userID) {
+  const form = {
+    fb_api_caller_class: 'RelayModern',
+    fb_api_req_friendly_name: 'FriendingCometUnfriendMutation',
+    variables: JSON.stringify({
+      input: {
+        source: 'bd_friends_tab',
+        unfriend_id: String(userID),
+        actor_id: ctx.userID,
+        client_mutation_id: String(Math.round(Math.random() * 10000))
+      }
+    }),
+    doc_id: '3662088047145115'
+  };
+
+  const res = await defaultFuncs.post('https://www.facebook.com/api/graphql/', ctx.jar, form)
+    .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+  if (res?.errors?.length) throw new Error(JSON.stringify(res.errors));
+  return { success: true, userID: String(userID), method: 'graphql', timestamp: Date.now() };
+}
+
+function recordHistory(op) {
+  UNFRIEND_HISTORY.unshift({ ...op, ts: Date.now() });
+  if (UNFRIEND_HISTORY.length > MAX_HISTORY) UNFRIEND_HISTORY.length = MAX_HISTORY;
+}
+
+function recordUndo(op) {
+  UNDO_STACK.unshift({ ...op, ts: Date.now() });
+  if (UNDO_STACK.length > MAX_UNDO) UNDO_STACK.length = MAX_UNDO;
+}
+
+module.exports = (defaultFuncs, api, ctx) => {
+
+  const unfriend = async function unfriend(userOrUsers, options, callback) {
+    if (typeof options === 'function') { callback = options; options = {}; }
+    if (!options || typeof options !== 'object') options = {};
+    const {
+      preferGraphQL = true,
+      batchDelay = 500,
+      requireConfirmation = false,
+      skipAlreadyUnfriended = false,
+      dryRun = false
+    } = options;
+
+    let resolveFunc, rejectFunc;
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (typeof callback !== 'function') {
+      callback = (err, data) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    }
+
+    try {
+      const userIDs = Array.isArray(userOrUsers)
+        ? userOrUsers.map(String)
+        : [String(userOrUsers)];
+
+      if (userIDs.length === 0) throw new Error('unfriend: at least one userID is required');
+
+      for (const uid of userIDs) {
+        if (!uid || uid === 'undefined' || uid === 'null') {
+          throw new Error(`unfriend: invalid userID "${uid}"`);
+        }
+        if (uid === String(ctx.userID)) {
+          throw new Error('unfriend: cannot unfriend yourself');
+        }
+      }
+
+      if (requireConfirmation) {
+        for (const uid of userIDs) {
+          const cacheKey = `confirm_${uid}`;
+          const cached = CONFIRMATION_CACHE.get(cacheKey);
+          if (!cached || Date.now() - cached.ts > CONFIRMATION_TTL) {
+            throw new Error(`unfriend: confirmation required for user ${uid} — call unfriend.confirm("${uid}") first`);
+          }
+        }
+      }
+
+      if (dryRun) {
+        return callback(null, { dryRun: true, wouldUnfriend: userIDs, timestamp: Date.now() });
+      }
+
+      await globalShield.addSmartDelay();
+
+      const results = [];
+      const errors = [];
+
+      for (let i = 0; i < userIDs.length; i++) {
+        const uid = userIDs[i];
+        if (i > 0) await new Promise(r => setTimeout(r, batchDelay + Math.random() * 200));
+
+        try {
+          let result;
+
+          if (preferGraphQL) {
+            try {
+              result = await retryOp(() => graphqlUnfriend(defaultFuncs, ctx, uid));
+            } catch (gqlErr) {
+              utils.warn('unfriend', `GraphQL failed for ${uid}, using HTTP:`, gqlErr.message);
+              result = await retryOp(() => httpUnfriend(defaultFuncs, ctx, uid));
+            }
+          } else {
+            try {
+              result = await retryOp(() => httpUnfriend(defaultFuncs, ctx, uid));
+            } catch (httpErr) {
+              utils.warn('unfriend', `HTTP failed for ${uid}, using GraphQL:`, httpErr.message);
+              result = await retryOp(() => graphqlUnfriend(defaultFuncs, ctx, uid));
+            }
+          }
+
+          results.push(result);
+          recordHistory({ userID: uid, method: result.method });
+          recordUndo({ userID: uid, action: 'unfriended', method: result.method });
+          utils.log('unfriend', `Unfriended user ${uid} via ${result.method}`);
+        } catch (err) {
+          const isAlreadyUnfriended = /already|not friend|not a friend/i.test(String(err?.message || err));
+          if (isAlreadyUnfriended && skipAlreadyUnfriended) {
+            results.push({ userID: uid, skipped: true, reason: 'already_unfriended' });
+          } else {
+            errors.push({ userID: uid, error: err.message || String(err) });
+          }
+        }
+      }
+
+      const isSingle = userIDs.length === 1;
+      const finalResult = isSingle && results.length === 1
+        ? results[0]
+        : { success: errors.length === 0, results, errors: errors.length ? errors : undefined, timestamp: Date.now() };
+
+      if (errors.length === userIDs.length) {
+        return callback(new Error(`unfriend: all ${userIDs.length} unfriend(s) failed — ${errors[0]?.error}`));
+      }
+
+      callback(null, finalResult);
+    } catch (err) {
+      utils.error('unfriend', err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+
+  unfriend.confirm = (userID) => {
+    CONFIRMATION_CACHE.set(`confirm_${userID}`, { ts: Date.now() });
+    return { confirmed: true, userID: String(userID), expiresIn: CONFIRMATION_TTL };
+  };
+
+  unfriend.getHistory = (limit = 30) => UNFRIEND_HISTORY.slice(0, limit);
+  unfriend.getUndoStack = () => [...UNDO_STACK];
+
+  return unfriend;
+};

package/phantom/dispatch/unsendMessage.js

@@ -0,0 +1,124 @@
+"use strict";
+
+/**
+ * unsendMessage — Advanced Message Unsend for Phantom SDK
+ *
+ * Features:
+ *  - Primary: GraphQL mutation (modern, works for sent messages)
+ *  - Fallback: Legacy messaging/unsend_message endpoint
+ *  - Batch unsend: pass array of messageIDs
+ *  - Exponential-backoff retry on transient errors
+ *  - Full callback + Promise dual API
+ */
+
+const utils = require('../datastore/models/matrix/tools');
+
+async function unsendGraphQL(defaultFuncs, ctx, messageID) {
+  const form = {
+    av:                       ctx.userID,
+    __user:                   ctx.userID,
+    __a:                      1,
+    fb_dtsg:                  ctx.fb_dtsg,
+    lsd:                      ctx.lsd || ctx.fb_dtsg,
+    fb_api_caller_class:      "RelayModern",
+    fb_api_req_friendly_name: "useUnsendMessageMutation",
+    variables: JSON.stringify({
+      input: {
+        client_mutation_id: String(Date.now() % 1e9),
+        actor_id:           ctx.userID,
+        message_id:         messageID,
+      }
+    }),
+    server_timestamps: true,
+    doc_id:            "4719873428063543",
+  };
+
+  const res     = await defaultFuncs.post("https://www.facebook.com/api/graphql/", ctx.jar, form);
+  const checked = await utils.parseAndCheckLogin(ctx, defaultFuncs)(res);
+  if (checked?.errors) throw new Error(checked.errors[0]?.message || JSON.stringify(checked.errors));
+  return { success: true, messageID, method: 'graphql' };
+}
+
+async function unsendLegacy(defaultFuncs, ctx, messageID) {
+  const defData = await defaultFuncs.post(
+    "https://www.facebook.com/messaging/unsend_message/",
+    ctx.jar,
+    { message_id: messageID }
+  );
+  const resData = await utils.parseAndCheckLogin(ctx, defaultFuncs)(defData);
+  if (resData?.error) throw new Error(JSON.stringify(resData.error));
+  return { success: true, messageID, method: 'legacy' };
+}
+
+async function unsendOne(defaultFuncs, ctx, messageID, retries, baseMs) {
+  let lastErr;
+  for (let attempt = 1; attempt <= retries; attempt++) {
+    try {
+      return await unsendGraphQL(defaultFuncs, ctx, messageID);
+    } catch (primaryErr) {
+      try {
+        return await unsendLegacy(defaultFuncs, ctx, messageID);
+      } catch (fallbackErr) {
+        lastErr = primaryErr;
+        if (attempt >= retries || /checkpoint|auth|disabled/i.test(primaryErr.message)) throw primaryErr;
+        const wait = baseMs * Math.pow(2, attempt - 1) + Math.random() * 200;
+        utils.warn("unsendMessage", `Retry ${attempt}/${retries} for ${messageID} in ${Math.round(wait)}ms`);
+        await new Promise(r => setTimeout(r, wait));
+      }
+    }
+  }
+  throw lastErr;
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+
+  /**
+   * Unsend (recall) a sent message.
+   *
+   * @param {string|string[]} messageID  Message ID or array of IDs for batch unsend
+   * @param {object}          [options]  { retries: number, concurrency: number }
+   * @param {Function}        [callback] Node-style (err, result) callback
+   * @returns {Promise<object|object[]>}
+   */
+  return async function unsendMessage(messageID, options, callback) {
+    if (typeof options === 'function') { callback = options; options = {}; }
+    options = options || {};
+
+    const retries     = options.retries     || 3;
+    const baseMs      = 600;
+    const concurrency = options.concurrency || 3;
+
+    let resolveFunc, rejectFunc;
+    const promise = new Promise((res, rej) => { resolveFunc = res; rejectFunc = rej; });
+
+    function done(err, data) {
+      if (callback) return err ? callback(err) : callback(null, data);
+      if (err) rejectFunc(err); else resolveFunc(data);
+    }
+
+    const ids = Array.isArray(messageID) ? messageID : [messageID];
+
+    if (!ids.length || ids.some(id => !id)) {
+      done(new Error("unsendMessage: messageID is required"));
+      return promise;
+    }
+
+    try {
+      const results = [];
+      // Process in batches respecting concurrency
+      for (let i = 0; i < ids.length; i += concurrency) {
+        const batch = ids.slice(i, i + concurrency);
+        const batchResults = await Promise.all(batch.map(id => unsendOne(defaultFuncs, ctx, id, retries, baseMs)));
+        results.push(...batchResults);
+      }
+
+      const out = ids.length === 1 ? results[0] : { success: true, results };
+      done(null, out);
+    } catch (err) {
+      utils.error("unsendMessage", err.message || err);
+      done(err);
+    }
+
+    return promise;
+  };
+};