nodebb-plugin-facebook-post 1.0.0

package/README.md

@@ -0,0 +1,32 @@
+# nodebb-plugin-facebook-post (worker) + Instagram
+
+Cette version publie :
+- **Facebook Page** : toujours (si checkbox cochée dans le composer)
+- **Instagram** : option ACP “Publier aussi sur Instagram” ET seulement si une image est présente.
+
+## Instagram: carrousel (jusqu’à 10 médias)
+Si le message contient plusieurs images, le worker publie un **carrousel Instagram** :
+1. crée un container enfant par image (`is_carousel_item=true`)
+2. crée un container parent (`media_type=CAROUSEL`, `children=<ids>`)
+3. publie via `/{ig-user-id}/media_publish`
+Le worker attend que les containers passent à `FINISHED` via `status_code`. citeturn0search1turn0search0
+
+## Variables d’environnement
+
+### Communes (NodeBB + worker)
+- `NODEBB_FB_PAGE_ID`
+- `NODEBB_FB_PAGE_ACCESS_TOKEN`
+- `NODEBB_FB_GRAPH_VERSION` (optionnel, défaut `v25.0`)
+- `NODEBB_FB_QUEUE_REDIS_URL`
+- `NODEBB_FB_WORKER_SECRET`
+
+### Instagram
+- `NODEBB_IG_USER_ID` (obligatoire si Instagram activé)
+
+### Tuning (optionnel)
+- `NODEBB_IG_POLL_INTERVAL_MS` (défaut 2000)
+- `NODEBB_IG_POLL_MAX_MS` (défaut 120000)
+
+## Note sur la géolocalisation
+Le plugin réutilise ton `placeId` comme `place` (Facebook) et `location_id` (Instagram) lors de la création du container. citeturn0search0turn0search1
+

package/library.js

@@ -0,0 +1,414 @@
+'use strict';
+
+const Redis = require('ioredis');
+const { v4: uuidv4 } = require('uuid');
+
+let meta = {};
+let settings = {};
+let appRef;
+
+const SETTINGS_KEY = 'facebook-post';
+const QUEUE_KEY = 'fbpost:queue';
+
+const DEFAULT_SETTINGS = {
+  enabled: false,
+
+  includeExcerpt: true,
+  excerptMaxLen: 220,
+
+  categoriesWhitelist: '',
+  minimumReputation: 0,
+
+  maxImages: 4,
+
+  enablePlaceTagging: true,
+
+  allowedGroups: '',
+
+  // Also publish to Instagram (worker only does it if at least 1 image)
+  publishInstagram: false,
+};
+
+let redisClient = null;
+
+function bool(v) { return v === true || v === 'true' || v === 1 || v === '1' || v === 'on'; }
+function int(v, def) { const n = parseInt(v, 10); return Number.isFinite(n) ? n : def; }
+function trimStr(v) { return (v || '').toString().trim(); }
+function parseCsvInts(csv) {
+  const s = trimStr(csv);
+  if (!s) return [];
+  return s.split(',').map(x => parseInt(x.trim(), 10)).filter(n => Number.isFinite(n));
+}
+
+function readEnv() {
+  const env = process.env || {};
+  return {
+    fbGraphVersion: trimStr(env.NODEBB_FB_GRAPH_VERSION) || 'v25.0',
+    fbPageId: trimStr(env.NODEBB_FB_PAGE_ID),
+    fbPageAccessToken: trimStr(env.NODEBB_FB_PAGE_ACCESS_TOKEN),
+
+    igUserId: trimStr(env.NODEBB_IG_USER_ID) || '',
+
+    redisUrl: trimStr(env.NODEBB_FB_QUEUE_REDIS_URL) || 'redis://127.0.0.1:6379',
+    workerSecret: trimStr(env.NODEBB_FB_WORKER_SECRET) || '',
+  };
+}
+
+async function loadSettings() {
+  const raw = await meta.settings.get(SETTINGS_KEY);
+  settings = Object.assign({}, DEFAULT_SETTINGS, raw || {});
+
+  settings.enabled = bool(settings.enabled);
+  settings.includeExcerpt = bool(settings.includeExcerpt);
+  settings.excerptMaxLen = int(settings.excerptMaxLen, DEFAULT_SETTINGS.excerptMaxLen);
+
+  settings.minimumReputation = int(settings.minimumReputation, 0);
+  settings.maxImages = int(settings.maxImages, DEFAULT_SETTINGS.maxImages);
+  settings.enablePlaceTagging = bool(settings.enablePlaceTagging);
+
+  settings.categoriesWhitelist = trimStr(settings.categoriesWhitelist);
+  settings.allowedGroups = trimStr(settings.allowedGroups);
+
+  settings.publishInstagram = bool(settings.publishInstagram);
+
+  const env = readEnv();
+  settings.fbGraphVersion = env.fbGraphVersion;
+  settings.fbPageId = env.fbPageId;
+  settings.fbPageAccessToken = env.fbPageAccessToken;
+  settings.igUserId = env.igUserId;
+
+  settings.redisUrl = env.redisUrl;
+  settings.workerSecret = env.workerSecret;
+}
+
+function getForumBaseUrl() {
+  const nconf = require.main.require('nconf');
+  return trimStr(nconf.get('url')) || '';
+}
+function absolutizeUrl(url) {
+  const base = getForumBaseUrl();
+  if (!url) return '';
+  if (url.startsWith('http://') || url.startsWith('https://')) return url;
+  if (url.startsWith('//')) return `https:${url}`;
+  if (!base) return url;
+  if (url.startsWith('/')) return base + url;
+  return base + '/' + url;
+}
+function isForumHosted(urlAbs) {
+  const base = getForumBaseUrl();
+  if (!base) return false;
+  try { return new URL(urlAbs).host === new URL(base).host; } catch { return false; }
+}
+
+function extractImageUrlsFromContent(rawContent) {
+  const urls = new Set();
+  if (!rawContent) return [];
+
+  const mdImg = /!\[[^\]]*]\(([^)\s]+)(?:\s+"[^"]*")?\)/g;
+  let m;
+  while ((m = mdImg.exec(rawContent)) !== null) urls.add(m[1]);
+
+  const htmlImg = /<img[^>]+src=["']([^"']+)["'][^>]*>/gi;
+  while ((m = htmlImg.exec(rawContent)) !== null) urls.add(m[1]);
+
+  const bare = /(https?:\/\/[^\s<>"']+\.(?:png|jpe?g|gif|webp))(?:\?[^\s<>"']*)?/gi;
+  while ((m = bare.exec(rawContent)) !== null) urls.add(m[1]);
+
+  return Array.from(urls).map(u => trimStr(u)).filter(Boolean).map(absolutizeUrl);
+}
+
+function sanitizeExcerpt(text, maxLen) {
+  const s = trimStr(text).replace(/\s+/g, ' ').replace(/<[^>]*>/g, '');
+  if (!s) return '';
+  if (s.length <= maxLen) return s;
+  return s.slice(0, Math.max(0, maxLen - 1)).trimEnd() + '…';
+}
+
+function parseAllowedGroupsList() {
+  const s = trimStr(settings.allowedGroups);
+  if (!s) return [];
+  return s.split(',').map(x => x.trim()).filter(Boolean);
+}
+async function userIsAllowed(uid) {
+  const allowed = parseAllowedGroupsList();
+  if (!allowed.length) return false;
+
+  const Groups = require.main.require('./src/groups');
+  for (const groupName of allowed) {
+    try {
+      // eslint-disable-next-line no-await-in-loop
+      const ok = await Groups.isMember(uid, groupName);
+      if (ok) return true;
+    } catch {}
+  }
+  return false;
+}
+
+async function getPostContext(postData) {
+  const Posts = require.main.require('./src/posts');
+  const Topics = require.main.require('./src/topics');
+  const User = require.main.require('./src/user');
+
+  const pid = postData && (postData.pid || (postData.post && postData.post.pid));
+  if (!pid) return null;
+
+  const post = await Posts.getPostData(pid);
+  if (!post) return null;
+
+  const topic = await Topics.getTopicData(post.tid);
+  if (!topic) return null;
+
+  const user = await User.getUserFields(post.uid, ['uid', 'username', 'userslug', 'reputation']);
+  const url = await Topics.getTopicUrl(post.tid);
+  const topicUrlAbs = absolutizeUrl(url);
+
+  return { post, topic, user, topicUrlAbs };
+}
+
+function shouldEnqueue(ctx) {
+  if (!ctx || !ctx.post || !ctx.topic || !ctx.user) return false;
+  if (!settings.enabled) return false;
+  if (!settings.fbPageId || !settings.fbPageAccessToken) return false;
+
+  const isFirstPost = (ctx.post.isMainPost === true) || (ctx.post.index === 0);
+  if (!isFirstPost) return false;
+
+  if (!bool(ctx.post.fbPostEnabled)) return false;
+
+  if ((ctx.user.reputation || 0) < settings.minimumReputation) return false;
+
+  const whitelist = parseCsvInts(settings.categoriesWhitelist);
+  if (whitelist.length > 0) {
+    const cid = parseInt(ctx.topic.cid, 10);
+    if (!whitelist.includes(cid)) return false;
+  }
+
+  return true;
+}
+
+async function getRedis() {
+  if (redisClient) return redisClient;
+  const winston = require.main.require('winston');
+  redisClient = new Redis(settings.redisUrl, {
+    maxRetriesPerRequest: 2,
+    enableReadyCheck: true,
+    lazyConnect: true,
+  });
+  redisClient.on('error', (err) => {
+    winston.error(`[facebook-post] Redis error: ${err && err.message ? err.message : err}`);
+  });
+  await redisClient.connect();
+  return redisClient;
+}
+
+function buildJob(ctx) {
+  const rawContent = ctx.post.content || '';
+  const topicTitle = ctx.topic.title || 'Nouveau sujet';
+  const author = ctx.user.username || 'Quelqu’un';
+  const link = ctx.topicUrlAbs;
+
+  const excerpt = settings.includeExcerpt ? sanitizeExcerpt(rawContent, settings.excerptMaxLen) : '';
+
+  let imageUrls = extractImageUrlsFromContent(rawContent)
+    .map(absolutizeUrl)
+    .filter(isForumHosted);
+
+  imageUrls = imageUrls.slice(0, Math.max(0, settings.maxImages));
+
+  let placeId = null;
+  if (settings.enablePlaceTagging) {
+    const pid = trimStr(ctx.post.fbPlaceId);
+    if (pid) placeId = pid;
+  }
+
+  const lines = [];
+  lines.push(`📝 ${topicTitle}`);
+  if (excerpt) lines.push(`\n${excerpt}`);
+  lines.push(`\n🔗 ${link}`);
+  lines.push(`\n— ${author}`);
+  const message = lines.join('\n');
+
+  return {
+    id: uuidv4(),
+    createdAt: Date.now(),
+    attempts: 0,
+
+    pid: ctx.post.pid,
+    tid: ctx.post.tid,
+    uid: ctx.post.uid,
+
+    message,
+    link,
+    imageUrls,
+    placeId,
+
+    publishInstagram: !!settings.publishInstagram,
+
+    nodebbBaseUrl: getForumBaseUrl(),
+  };
+}
+
+async function enqueueJob(job) {
+  const redis = await getRedis();
+  await redis.lpush(QUEUE_KEY, JSON.stringify(job));
+}
+
+async function ensureAdmin(req) {
+  const User = require.main.require('./src/user');
+  const uid = req.uid;
+  if (!uid) return false;
+
+  try { if (await User.isAdministrator(uid)) return true; } catch {}
+  try { if (await User.isAdminOrGlobalMod(uid)) return true; } catch {}
+  if (req.user && req.user.isAdmin) return true;
+  return false;
+}
+
+async function listAllGroups() {
+  const Groups = require.main.require('./src/groups');
+  try {
+    const groups = await Groups.getGroupsFromSet('groups:createtime', 0, -1);
+    if (Array.isArray(groups)) return groups;
+  } catch {}
+  try {
+    const groups2 = await Groups.getGroups('groups:createtime', 0, 9999);
+    if (Array.isArray(groups2)) return groups2;
+  } catch {}
+  return [];
+}
+
+const Plugin = {};
+
+Plugin.init = async function (params) {
+  appRef = params.app;
+  meta = (params && params.meta) ? params.meta : require.main.require('./src/meta');
+
+  await loadSettings();
+
+  const routeHelpers = require.main.require('./src/routes/helpers');
+  routeHelpers.setupAdminPageRoute(appRef, '/admin/plugins/facebook-post', params.middleware, [], (req, res) => {
+    res.render('admin/facebook-post', {});
+  });
+
+  appRef.get('/api/admin/plugins/facebook-post/groups', params.middleware.authenticate, async (req, res) => {
+    try {
+      await loadSettings();
+      const ok = await ensureAdmin(req);
+      if (!ok) return res.status(403).json({ error: 'forbidden' });
+
+      const groups = await listAllGroups();
+      const names = (groups || [])
+        .map(g => g && (g.name || g.displayName || g.slug))
+        .filter(Boolean)
+        .filter(n => n.toLowerCase() !== 'guests');
+
+      const uniq = Array.from(new Set(names)).sort((a, b) => a.localeCompare(b));
+      return res.json({ groups: uniq });
+    } catch {
+      return res.status(500).json({ error: 'failed' });
+    }
+  });
+
+  appRef.get('/api/facebook-post/can-post', params.middleware.authenticate, async (req, res) => {
+    try {
+      await loadSettings();
+      if (!settings.enabled) return res.json({ allowed: false, reason: 'disabled' });
+
+      const ok = await userIsAllowed(req.uid);
+      return res.json({ allowed: ok });
+    } catch {
+      return res.json({ allowed: false });
+    }
+  });
+
+  appRef.post('/api/admin/plugins/facebook-post/mark-posted', params.middleware.authenticate, async (req, res) => {
+    try {
+      await loadSettings();
+      const secret = trimStr(req.body && req.body.secret);
+      if (!secret || secret !== settings.workerSecret) {
+        return res.status(403).json({ error: 'bad_secret' });
+      }
+      const ok = await ensureAdmin(req);
+      if (!ok) return res.status(403).json({ error: 'forbidden' });
+
+      const pid = parseInt(req.body && req.body.pid, 10);
+      const fbPostedId = trimStr(req.body && req.body.fbPostedId);
+      const fbPostedAt = parseInt(req.body && req.body.fbPostedAt, 10) || Date.now();
+      if (!Number.isFinite(pid) || !fbPostedId) return res.status(400).json({ error: 'bad_payload' });
+
+      const Posts = require.main.require('./src/posts');
+      await Posts.setPostField(pid, 'fbPostedId', fbPostedId);
+      await Posts.setPostField(pid, 'fbPostedAt', fbPostedAt);
+      await Posts.deletePostField(pid, 'fbQueueJobId');
+      await Posts.deletePostField(pid, 'fbQueuedAt');
+      return res.json({ ok: true });
+    } catch {
+      return res.status(500).json({ error: 'failed' });
+    }
+  });
+
+  appRef.on('nodebb:settings:reload', async (payload) => {
+    if (payload && payload.plugin === SETTINGS_KEY) {
+      await loadSettings();
+    }
+  });
+};
+
+Plugin.addAdminNavigation = async function (header) {
+  header.plugins = header.plugins || [];
+  header.plugins.push({ route: '/plugins/facebook-post', icon: 'fa-facebook', name: 'Facebook/Instagram Post' });
+  return header;
+};
+
+Plugin.addClientScripts = async function (scripts) {
+  scripts.push('plugins/nodebb-plugin-facebook-post/lib/composer.js');
+  return scripts;
+};
+
+Plugin.addAdminScripts = async function (scripts) {
+  scripts.push('plugins/nodebb-plugin-facebook-post/lib/admin.js');
+  return scripts;
+};
+
+Plugin.onPostCreate = async function (hookData) {
+  try {
+    if (!hookData?.post || !hookData?.data) return hookData;
+    hookData.post.fbPostEnabled = bool(hookData.data.fbPostEnabled);
+    const fbPlaceId = trimStr(hookData.data.fbPlaceId);
+    if (fbPlaceId) hookData.post.fbPlaceId = fbPlaceId;
+  } catch {}
+  return hookData;
+};
+
+Plugin.onPostSave = async function (hookData) {
+  const winston = require.main.require('winston');
+  try {
+    await loadSettings();
+    if (!settings.enabled) return;
+
+    const ctx = await getPostContext(hookData && hookData.post ? hookData.post : hookData);
+    if (!ctx) return;
+
+    const allowed = await userIsAllowed(ctx.post.uid);
+    if (!allowed) return;
+
+    if (!shouldEnqueue(ctx)) return;
+
+    const Posts = require.main.require('./src/posts');
+    const alreadyPosted = await Posts.getPostField(ctx.post.pid, 'fbPostedId');
+    const alreadyQueued = await Posts.getPostField(ctx.post.pid, 'fbQueueJobId');
+    if (alreadyPosted || alreadyQueued) return;
+
+    const job = buildJob(ctx);
+    await enqueueJob(job);
+
+    await Posts.setPostField(ctx.post.pid, 'fbQueueJobId', job.id);
+    await Posts.setPostField(ctx.post.pid, 'fbQueuedAt', Date.now());
+  } catch (e) {
+    const detail = e && (e.response && JSON.stringify(e.response.data) || e.message || e);
+    winston.error(`[facebook-post] Enqueue failed: ${detail}`);
+  }
+};
+
+module.exports = Plugin;
+

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "nodebb-plugin-facebook-post",
+  "version": "1.0.0",
+  "description": "Queue-based worker to auto-post new NodeBB topics to a fixed Facebook Page and optionally Instagram (images only).",
+  "main": "library.js",
+  "dependencies": {
+    "axios": "^1.6.0",
+    "ioredis": "^5.4.1",
+    "uuid": "^9.0.1"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "MIT"
+}

package/plugin.json

@@ -0,0 +1,37 @@
+{
+  "id": "nodebb-plugin-facebook-post",
+  "name": "Facebook/Instagram Post (Worker)",
+  "description": "Enqueue new NodeBB topics to a worker that posts to a fixed Facebook Page (+ optional Instagram).",
+  "url": "https://example.invalid/nodebb-plugin-facebook-post",
+  "library": "./library.js",
+  "hooks": [
+    {
+      "hook": "static:app.load",
+      "method": "init"
+    },
+    {
+      "hook": "filter:admin.header.build",
+      "method": "addAdminNavigation"
+    },
+    {
+      "hook": "filter:scripts.get",
+      "method": "addClientScripts"
+    },
+    {
+      "hook": "filter:admin.scripts.get",
+      "method": "addAdminScripts"
+    },
+    {
+      "hook": "filter:post.create",
+      "method": "onPostCreate"
+    },
+    {
+      "hook": "action:post.save",
+      "method": "onPostSave"
+    }
+  ],
+  "staticDirs": {
+    "static": "static"
+  },
+  "templates": "static/templates"
+}

package/static/lib/admin.js

@@ -0,0 +1,74 @@
+/* global $, app, socket */
+'use strict';
+
+function parseCsv(s) { return (s || '').split(',').map(x => x.trim()).filter(Boolean); }
+function toCsv(arr) { return (arr || []).map(x => String(x).trim()).filter(Boolean).join(','); }
+
+async function fetchGroupsList() {
+  const res = await fetch('/api/admin/plugins/facebook-post/groups', { credentials: 'same-origin' });
+  if (!res.ok) throw new Error('groups api not ok');
+  const data = await res.json();
+  return (data && data.groups) ? data.groups : [];
+}
+
+$(document).ready(function () {
+  socket.emit('admin.settings.get', { hash: 'facebook-post' }, async function (err, data) {
+    if (err) return app.alertError(err.message || err);
+
+    data = data || {};
+    const savedAllowed = parseCsv(data.allowedGroups);
+
+    for (const [k, v] of Object.entries(data)) {
+      if (k === 'allowedGroups') continue;
+      const $el = $('[name="' + k + '"]');
+      if (!$el.length) continue;
+
+      if ($el.attr('type') === 'checkbox') {
+        $el.prop('checked', v === true || v === 'true' || v === 1 || v === '1' || v === 'on');
+      } else {
+        $el.val(v);
+      }
+    }
+
+    const $select = $('#allowedGroupsSelect');
+    const $hidden = $('input[type="hidden"][name="allowedGroups"]');
+
+    function syncHidden() {
+      const selected = $select.val() || [];
+      $hidden.val(toCsv(selected));
+    }
+
+    try {
+      const groups = await fetchGroupsList();
+      $select.empty();
+      groups.forEach(name => {
+        const opt = document.createElement('option');
+        opt.value = name;
+        opt.textContent = name;
+        if (savedAllowed.includes(name)) opt.selected = true;
+        $select.append(opt);
+      });
+      $select.on('change', syncHidden);
+      syncHidden();
+    } catch (e) {
+      app.alertError('Impossible de charger la liste des groupes. Vérifie les droits admin et les logs serveur.');
+    }
+  });
+
+  $('#save').on('click', function () {
+    const payload = {};
+    $('.facebook-post-settings [name]').each(function () {
+      const $el = $(this);
+      const name = $el.attr('name');
+      if ($el.attr('type') === 'checkbox') payload[name] = $el.is(':checked');
+      else payload[name] = $el.val();
+    });
+
+    socket.emit('admin.settings.set', { hash: 'facebook-post', values: payload }, function (err) {
+      if (err) return app.alertError(err.message || err);
+      app.alertSuccess('Enregistré.');
+      socket.emit('admin.settings.sync', { hash: 'facebook-post' });
+    });
+  });
+});
+

package/static/lib/composer.js

@@ -0,0 +1,76 @@
+/* global $, app */
+'use strict';
+
+(function () {
+  async function canPost() {
+    try {
+      const res = await fetch('/api/facebook-post/can-post', { credentials: 'same-origin' });
+      if (!res.ok) return { allowed: false };
+      return await res.json();
+    } catch {
+      return { allowed: false };
+    }
+  }
+
+  function injectUI($composer) {
+    if ($composer.find('[data-fbpost-wrap]').length) return;
+
+    const html = `
+      <div class="mb-2" data-fbpost-wrap>
+        <div class="form-check mb-2">
+          <input type="checkbox" class="form-check-input" id="fbPostEnabled" data-fbpost-enabled>
+          <label class="form-check-label" for="fbPostEnabled">Publier ce nouveau topic sur Facebook (et Insta si activé)</label>
+        </div>
+
+        <div class="mb-2" data-fbpost-place-wrap style="display:none;">
+          <label class="form-label" style="font-size: 12px; opacity: .8;">
+            Lieu (Facebook Place ID) – optionnel
+          </label>
+          <input type="text" class="form-control" data-fbpost-place-id placeholder="ex: 123456789012345">
+          <div class="form-text" style="font-size: 11px;">
+            Utilisé comme <code>place</code> sur Facebook et <code>location_id</code> sur Instagram.
+          </div>
+        </div>
+      </div>
+    `;
+
+    const $target = $composer.find('.write, .composer-body, .composer-content').first();
+    if ($target.length) $target.prepend(html);
+    else $composer.prepend(html);
+
+    const $enabled = $composer.find('[data-fbpost-enabled]');
+    const $placeWrap = $composer.find('[data-fbpost-place-wrap]');
+
+    $enabled.on('change', function () {
+      $placeWrap.toggle($enabled.is(':checked'));
+    });
+
+    $(window).off('filter:composer.submit.fbpost')
+      .on('filter:composer.submit.fbpost', function (ev2, submitData) {
+        const enabled = $enabled.is(':checked');
+        submitData.data = submitData.data || {};
+        submitData.data.fbPostEnabled = enabled;
+
+        if (enabled) {
+          const placeId = $composer.find('[data-fbpost-place-id]').val();
+          if (placeId) submitData.data.fbPlaceId = placeId;
+        }
+        return submitData;
+      });
+  }
+
+  $(window).on('action:composer.loaded', async function (ev, data) {
+    try {
+      const $composer = data && data.composer ? data.composer : $('.composer');
+      if (!$composer || !$composer.length) return;
+
+      const perm = await canPost();
+      if (!perm.allowed) return;
+
+      injectUI($composer);
+    } catch {
+      // ignore
+    }
+  });
+})();
+

package/static/templates/admin/facebook-post.tpl

@@ -0,0 +1,93 @@
+<div class="acp-page-container">
+  <h2>Facebook/Instagram Post (Worker)</h2>
+  <p class="text-muted">
+    Enfile les publications dans une <strong>queue Redis</strong>. Un worker séparé consomme la queue et poste sur Facebook,
+    et sur Instagram (si activé et si une image est présente).
+  </p>
+
+  <div class="alert alert-info">
+    Variables d’environnement :
+    <ul class="mb-0">
+      <li><code>NODEBB_FB_PAGE_ID</code></li>
+      <li><code>NODEBB_FB_PAGE_ACCESS_TOKEN</code></li>
+      <li><code>NODEBB_FB_GRAPH_VERSION</code> (optionnel)</li>
+      <li><code>NODEBB_FB_QUEUE_REDIS_URL</code></li>
+      <li><code>NODEBB_FB_WORKER_SECRET</code></li>
+      <li><code>NODEBB_IG_USER_ID</code> (si Instagram activé)</li>
+    </ul>
+  </div>
+
+  <form role="form" class="facebook-post-settings">
+    <div class="form-check mb-3">
+      <input type="checkbox" class="form-check-input" id="enabled" name="enabled">
+      <label class="form-check-label" for="enabled">Activer</label>
+    </div>
+
+    <div class="form-check mb-3">
+      <input type="checkbox" class="form-check-input" id="publishInstagram" name="publishInstagram">
+      <label class="form-check-label" for="publishInstagram">Publier aussi sur Instagram (uniquement si une image est présente)</label>
+    </div>
+
+    <hr/>
+
+    <h4>Accès</h4>
+    <p class="text-muted">Groupes NodeBB autorisés à voir la case “Publier sur Facebook” dans le composer (et donc déclencher Facebook + Insta).</p>
+
+    <div class="mb-3">
+      <label class="form-label" for="allowedGroupsSelect">Groupes autorisés</label>
+      <select class="form-select" id="allowedGroupsSelect" multiple size="10"></select>
+    </div>
+
+    <input type="hidden" id="allowedGroups" name="allowedGroups" value="">
+
+    <hr/>
+
+    <h4>Message</h4>
+
+    <div class="form-check mb-2">
+      <input type="checkbox" class="form-check-input" id="includeExcerpt" name="includeExcerpt">
+      <label class="form-check-label" for="includeExcerpt">Inclure un extrait du message</label>
+    </div>
+
+    <div class="mb-3">
+      <label class="form-label" for="excerptMaxLen">Longueur max de l’extrait</label>
+      <input type="number" class="form-control" id="excerptMaxLen" name="excerptMaxLen" min="50" max="5000">
+    </div>
+
+    <hr/>
+
+    <h4>Filtres</h4>
+
+    <div class="mb-3">
+      <label class="form-label" for="categoriesWhitelist">Whitelist catégories (cids séparés par virgules)</label>
+      <input type="text" class="form-control" id="categoriesWhitelist" name="categoriesWhitelist" placeholder="1,2,5">
+      <div class="form-text">Vide = toutes les catégories.</div>
+    </div>
+
+    <div class="mb-3">
+      <label class="form-label" for="minimumReputation">Réputation minimale</label>
+      <input type="number" class="form-control" id="minimumReputation" name="minimumReputation" min="0">
+    </div>
+
+    <hr/>
+
+    <h4>Images</h4>
+
+    <div class="mb-3">
+      <label class="form-label" for="maxImages">Nombre max d’images (uploads du forum)</label>
+      <input type="number" class="form-control" id="maxImages" name="maxImages" min="0" max="20">
+    </div>
+
+    <hr/>
+
+    <h4>Lieu / Géolocalisation</h4>
+
+    <div class="form-check mb-3">
+      <input type="checkbox" class="form-check-input" id="enablePlaceTagging" name="enablePlaceTagging">
+      <label class="form-check-label" for="enablePlaceTagging">Activer le tag de lieu (Place ID / location_id)</label>
+    </div>
+
+    <button type="button" class="btn btn-primary" id="save">Enregistrer</button>
+  </form>
+</div>
+

package/worker.js

@@ -0,0 +1,260 @@
+#!/usr/bin/env node
+'use strict';
+
+const Redis = require('ioredis');
+const axios = require('axios');
+
+const QUEUE_KEY = 'fbpost:queue';
+
+function trimStr(v) { return (v || '').toString().trim(); }
+function int(v, def) { const n = parseInt(v, 10); return Number.isFinite(n) ? n : def; }
+function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+
+const env = process.env || {};
+const redisUrl = trimStr(env.NODEBB_FB_QUEUE_REDIS_URL) || 'redis://127.0.0.1:6379';
+
+const graphVersion = trimStr(env.NODEBB_FB_GRAPH_VERSION) || 'v25.0';
+const pageId = trimStr(env.NODEBB_FB_PAGE_ID);
+const pageToken = trimStr(env.NODEBB_FB_PAGE_ACCESS_TOKEN);
+
+const igUserId = trimStr(env.NODEBB_IG_USER_ID);
+
+const workerSecret = trimStr(env.NODEBB_FB_WORKER_SECRET);
+
+const maxAttempts = int(env.NODEBB_FB_WORKER_MAX_ATTEMPTS, 5);
+const retryDelayMs = int(env.NODEBB_FB_WORKER_RETRY_DELAY_MS, 30000);
+
+// Instagram polling (containers processing)
+const igPollIntervalMs = int(env.NODEBB_IG_POLL_INTERVAL_MS, 2000);
+const igPollMaxMs = int(env.NODEBB_IG_POLL_MAX_MS, 120000); // 2 minutes
+
+if (!pageId || !pageToken) {
+  console.error('[fb-worker] Missing NODEBB_FB_PAGE_ID or NODEBB_FB_PAGE_ACCESS_TOKEN');
+  process.exit(2);
+}
+if (!workerSecret) {
+  console.error('[fb-worker] Missing NODEBB_FB_WORKER_SECRET (required to mark posts as posted)');
+  process.exit(2);
+}
+
+const redis = new Redis(redisUrl, { enableReadyCheck: true });
+
+/* ---------- Facebook ---------- */
+async function fbUploadPhoto(urlAbs) {
+  const endpoint = `https://graph.facebook.com/${graphVersion}/${pageId}/photos`;
+  const resp = await axios.post(endpoint, null, {
+    params: { url: urlAbs, published: false, access_token: pageToken },
+    timeout: 20000,
+  });
+  return resp.data && resp.data.id;
+}
+
+async function fbPublishFeed({ message, link, photoIds, placeId }) {
+  const endpoint = `https://graph.facebook.com/${graphVersion}/${pageId}/feed`;
+  const form = new URLSearchParams();
+  form.append('message', String(message || ''));
+  form.append('access_token', String(pageToken));
+  if (link) form.append('link', String(link));
+  if (placeId) form.append('place', String(placeId));
+  if (Array.isArray(photoIds) && photoIds.length) {
+    photoIds.forEach((id, idx) => {
+      form.append(`attached_media[${idx}]`, JSON.stringify({ media_fbid: id }));
+    });
+  }
+  const resp = await axios.post(endpoint, form, {
+    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+    timeout: 20000,
+  });
+  return resp.data && resp.data.id;
+}
+
+/* ---------- Instagram ---------- */
+/**
+ * Instagram posting uses containers:
+ * - Single image: POST /{ig-user-id}/media (image_url + caption) -> creation_id; then POST /media_publish
+ * - Carousel: create N child containers with is_carousel_item=true, then create parent container media_type=CAROUSEL with children,
+ *   then publish parent. Poll child/parent status_code until FINISHED.
+ */
+async function igCreateImageContainer({ imageUrl, caption, locationId, isCarouselItem }) {
+  const endpoint = `https://graph.facebook.com/${graphVersion}/${igUserId}/media`;
+  const form = new URLSearchParams();
+  form.append('image_url', String(imageUrl));
+  if (caption) form.append('caption', String(caption));
+  form.append('access_token', String(pageToken));
+  if (locationId) form.append('location_id', String(locationId));
+  if (isCarouselItem) form.append('is_carousel_item', 'true');
+
+  const resp = await axios.post(endpoint, form, {
+    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+    timeout: 20000,
+  });
+  return resp.data && resp.data.id; // creation_id
+}
+
+async function igCreateCarouselContainer({ childrenIds, caption, locationId }) {
+  const endpoint = `https://graph.facebook.com/${graphVersion}/${igUserId}/media`;
+  const form = new URLSearchParams();
+  form.append('media_type', 'CAROUSEL');
+  // children is a comma-separated string of container IDs
+  form.append('children', childrenIds.join(','));
+  if (caption) form.append('caption', String(caption));
+  form.append('access_token', String(pageToken));
+  if (locationId) form.append('location_id', String(locationId));
+
+  const resp = await axios.post(endpoint, form, {
+    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+    timeout: 20000,
+  });
+  return resp.data && resp.data.id; // creation_id
+}
+
+async function igGetContainerStatus(containerId) {
+  const endpoint = `https://graph.facebook.com/${graphVersion}/${containerId}`;
+  const resp = await axios.get(endpoint, {
+    params: { fields: 'status_code', access_token: pageToken },
+    timeout: 20000,
+  });
+  return resp.data && resp.data.status_code;
+}
+
+async function igWaitFinished(containerId) {
+  const deadline = Date.now() + igPollMaxMs;
+  while (Date.now() < deadline) {
+    // eslint-disable-next-line no-await-in-loop
+    const status = await igGetContainerStatus(containerId);
+    if (status === 'FINISHED') return;
+    if (status === 'ERROR') throw new Error(`Instagram container ${containerId} status ERROR`);
+    // IN_PROGRESS or unknown
+    // eslint-disable-next-line no-await-in-loop
+    await sleep(igPollIntervalMs);
+  }
+  throw new Error(`Instagram container ${containerId} timeout after ${igPollMaxMs}ms`);
+}
+
+async function igPublishContainer(creationId) {
+  const endpoint = `https://graph.facebook.com/${graphVersion}/${igUserId}/media_publish`;
+  const form = new URLSearchParams();
+  form.append('creation_id', String(creationId));
+  form.append('access_token', String(pageToken));
+  const resp = await axios.post(endpoint, form, {
+    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+    timeout: 20000,
+  });
+  return resp.data && resp.data.id;
+}
+
+/* ---------- NodeBB callback (optional) ---------- */
+async function markPosted(job, fbPostedId) {
+  const bearer = trimStr(env.NODEBB_FB_NODEBB_BEARER_TOKEN);
+  if (!bearer) return;
+
+  const url = `${trimStr(job.nodebbBaseUrl).replace(/\/$/, '')}/api/admin/plugins/facebook-post/mark-posted`;
+  const payload = { pid: job.pid, fbPostedId, fbPostedAt: Date.now(), secret: workerSecret };
+
+  await axios.post(url, payload, {
+    headers: { Authorization: `Bearer ${bearer}` },
+    timeout: 15000,
+  });
+}
+
+async function handleJob(job) {
+  const imgs = Array.isArray(job.imageUrls) ? job.imageUrls : [];
+  const placeId = job.placeId ? String(job.placeId) : null;
+
+  // Facebook
+  let fbId;
+  if (!imgs.length) {
+    fbId = await fbPublishFeed({ message: job.message, link: job.link, photoIds: [], placeId });
+  } else {
+    const photoIds = [];
+    for (const urlAbs of imgs) {
+      // eslint-disable-next-line no-await-in-loop
+      const id = await fbUploadPhoto(urlAbs);
+      if (id) photoIds.push(id);
+    }
+    fbId = await fbPublishFeed({ message: job.message, link: job.link, photoIds, placeId });
+  }
+
+  // Instagram (only if enabled AND at least one image)
+  if (job.publishInstagram && imgs.length) {
+    if (!igUserId) {
+      console.warn('[fb-worker] publishInstagram enabled but NODEBB_IG_USER_ID missing; skipping Instagram.');
+    } else {
+      const caption = job.message;
+
+      // Instagram carousel limit: up to 10 items.
+      const igImgs = imgs.slice(0, 10);
+
+      if (igImgs.length === 1) {
+        const creationId = await igCreateImageContainer({ imageUrl: igImgs[0], caption, locationId: placeId, isCarouselItem: false });
+        await igWaitFinished(creationId);
+        const igPostId = await igPublishContainer(creationId);
+        console.log(`[fb-worker] Instagram published (single): ${igPostId}`);
+      } else {
+        const childIds = [];
+        for (const imageUrl of igImgs) {
+          // eslint-disable-next-line no-await-in-loop
+          const childId = await igCreateImageContainer({ imageUrl, caption: null, locationId: null, isCarouselItem: true });
+          // eslint-disable-next-line no-await-in-loop
+          await igWaitFinished(childId);
+          childIds.push(childId);
+        }
+
+        const parentId = await igCreateCarouselContainer({ childrenIds: childIds, caption, locationId: placeId });
+        await igWaitFinished(parentId);
+        const igPostId = await igPublishContainer(parentId);
+        console.log(`[fb-worker] Instagram published (carousel ${igImgs.length}): ${igPostId}`);
+      }
+    }
+  }
+
+  return fbId;
+}
+
+async function requeue(job) {
+  job.attempts = int(job.attempts, 0) + 1;
+  if (job.attempts >= maxAttempts) {
+    console.error(`[fb-worker] Job ${job.id} reached max attempts (${maxAttempts}). Dropping.`);
+    return;
+  }
+  console.warn(`[fb-worker] Requeue job ${job.id} in ${retryDelayMs}ms (attempt ${job.attempts}/${maxAttempts})`);
+  setTimeout(async () => {
+    try { await redis.lpush(QUEUE_KEY, JSON.stringify(job)); }
+    catch (e) { console.error('[fb-worker] Failed to requeue:', e && e.message ? e.message : e); }
+  }, retryDelayMs);
+}
+
+async function loop() {
+  console.log('[fb-worker] Started. Waiting for jobs…');
+  while (true) {
+    try {
+      const res = await redis.brpop(QUEUE_KEY, 0);
+      const payload = res && res[1];
+      if (!payload) continue;
+
+      let job;
+      try { job = JSON.parse(payload); }
+      catch { console.error('[fb-worker] Bad job payload, skipping.'); continue; }
+
+      console.log(`[fb-worker] Processing job ${job.id} pid=${job.pid} tid=${job.tid}`);
+      try {
+        const fbId = await handleJob(job);
+        console.log(`[fb-worker] Facebook posted: ${fbId}`);
+        try { await markPosted(job, fbId); } catch (e) {
+          console.warn('[fb-worker] mark-posted failed:', e && e.message ? e.message : e);
+        }
+      } catch (e) {
+        console.error('[fb-worker] Job failed:', e && (e.response && JSON.stringify(e.response.data) || e.message || e));
+        await requeue(job);
+      }
+    } catch (e) {
+      console.error('[fb-worker] Loop error:', e && e.message ? e.message : e);
+      await sleep(2000);
+    }
+  }
+}
+
+loop().catch((e) => {
+  console.error('[fb-worker] Fatal:', e && e.message ? e.message : e);
+  process.exit(1);
+});