thumbgate 0.9.10 → 0.9.12

package/scripts/social-analytics/publishers/zernio.js

@@ -8,11 +8,69 @@
  *   ZERNIO_API_KEY — Bearer token for https://zernio.com/api/v1
  */
 
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
 const { tagUrlsInText } = require('../utm');
+const { loadLocalEnv } = require('../load-env');
 
 const ZERNIO_UTM = { source: 'zernio', medium: 'social', campaign: 'organic' };
 
 const ZERNIO_BASE = 'https://zernio.com/api/v1';
+const DEFAULT_DEDUP_LOG_PATH = path.join(__dirname, '..', '..', '..', '.thumbgate', 'zernio-dedup-log.json');
+
+loadLocalEnv();
+
+/**
+ * Content-hash dedup: prevents the same content from being posted to the same
+ * platform twice within a 24-hour window.
+ */
+function getDedupLogPath() {
+  return process.env.THUMBGATE_DEDUP_LOG_PATH || DEFAULT_DEDUP_LOG_PATH;
+}
+
+function buildDedupKey(content, platform) {
+  const hash = crypto.createHash('sha256').update(content.trim()).digest('hex').slice(0, 16);
+  return `${platform}::${hash}`;
+}
+
+function loadDedupLog() {
+  const logPath = getDedupLogPath();
+  try {
+    if (fs.existsSync(logPath)) {
+      return JSON.parse(fs.readFileSync(logPath, 'utf8'));
+    }
+  } catch { /* ignore corrupt log */ }
+  return {};
+}
+
+function saveDedupLog(log) {
+  const logPath = getDedupLogPath();
+  const dir = path.dirname(logPath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(logPath, JSON.stringify(log, null, 2));
+}
+
+function isDuplicate(content, platform) {
+  const log = loadDedupLog();
+  const key = buildDedupKey(content, platform);
+  const entry = log[key];
+  if (!entry) return false;
+  const ageMs = Date.now() - new Date(entry.postedAt).getTime();
+  return ageMs < 24 * 60 * 60 * 1000; // 24-hour dedup window
+}
+
+function recordPost(content, platform) {
+  const log = loadDedupLog();
+  const key = buildDedupKey(content, platform);
+  log[key] = { platform, postedAt: new Date().toISOString() };
+  // Prune entries older than 7 days
+  const cutoff = Date.now() - 7 * 24 * 60 * 60 * 1000;
+  for (const [k, v] of Object.entries(log)) {
+    if (new Date(v.postedAt).getTime() < cutoff) delete log[k];
+  }
+  saveDedupLog(log);
+}
 
 function requireApiKey() {
   const key = process.env.ZERNIO_API_KEY;
@@ -22,6 +80,82 @@ function requireApiKey() {
   return key;
 }
 
+function resolveAccountId(account) {
+  if (!account || typeof account !== 'object') {
+    return '';
+  }
+  return String(account.accountId || account._id || account.id || '').trim();
+}
+
+function normalizeAccount(account) {
+  if (!account || typeof account !== 'object') {
+    return null;
+  }
+  const platform = String(account.platform || '').trim();
+  const accountId = resolveAccountId(account);
+  return {
+    ...account,
+    platform,
+    accountId,
+  };
+}
+
+function normalizePlatforms(platforms) {
+  return platforms
+    .map(normalizeAccount)
+    .filter(Boolean)
+    .map((platform) => ({
+      platform: platform.platform,
+      accountId: platform.accountId,
+    }));
+}
+
+function groupAccountsByPlatform(accounts) {
+  const groups = new Map();
+  for (const account of accounts) {
+    if (!account || !account.platform || !account.accountId) {
+      continue;
+    }
+    const existing = groups.get(account.platform) || [];
+    existing.push({
+      platform: account.platform,
+      accountId: account.accountId,
+    });
+    groups.set(account.platform, existing);
+  }
+  return groups;
+}
+
+function inferContentType(filePath) {
+  const ext = path.extname(String(filePath || '')).toLowerCase();
+  if (ext === '.jpg' || ext === '.jpeg') return 'image/jpeg';
+  if (ext === '.png') return 'image/png';
+  if (ext === '.webp') return 'image/webp';
+  if (ext === '.gif') return 'image/gif';
+  if (ext === '.mp4') return 'video/mp4';
+  if (ext === '.mov') return 'video/quicktime';
+  if (ext === '.webm') return 'video/webm';
+  return 'application/octet-stream';
+}
+
+function inferMediaType(contentType) {
+  if (String(contentType || '').startsWith('video/')) {
+    return 'video';
+  }
+  return 'image';
+}
+
+function normalizePostResult(payload) {
+  const data = payload && typeof payload === 'object' ? (payload.data ?? payload) : {};
+  const post = data.post && typeof data.post === 'object' ? data.post : null;
+  const id = data.id || data._id || post?._id || post?.id || null;
+  return {
+    ...data,
+    id,
+    post: post || data.post,
+  };
+}
+
 async function zernioFetch(method, endpoint, body = null) {
   const apiKey = requireApiKey();
   const url = `${ZERNIO_BASE}${endpoint}`;
@@ -48,20 +182,92 @@ async function zernioFetch(method, endpoint, body = null) {
   return res.json();
 }
 
+async function listPosts(options = {}) {
+  const query = new URLSearchParams();
+  if (options.limit) query.set('limit', String(options.limit));
+  if (options.page) query.set('page', String(options.page));
+  if (options.status) query.set('status', String(options.status));
+
+  const suffix = query.toString() ? `?${query.toString()}` : '';
+  const json = await zernioFetch('GET', `/posts${suffix}`);
+  return Array.isArray(json.posts) ? json.posts : (json.data?.posts || json.data || []);
+}
+
+async function deletePost(postId) {
+  if (!postId) throw new Error('deletePost: postId is required');
+  const json = await zernioFetch('DELETE', `/posts/${encodeURIComponent(String(postId).trim())}`);
+  return json.data ?? json;
+}
+
+async function requestMediaPresign(filename, contentType, size) {
+  if (!filename) throw new Error('requestMediaPresign: filename is required');
+  if (!contentType) throw new Error('requestMediaPresign: contentType is required');
+
+  const json = await zernioFetch('POST', '/media/presign', {
+    filename,
+    contentType,
+    size,
+  });
+
+  return json.data ?? json;
+}
+
+async function uploadLocalMedia(filePath, options = {}) {
+  const resolvedPath = path.resolve(String(filePath || ''));
+  if (!fs.existsSync(resolvedPath)) {
+    throw new Error(`uploadLocalMedia: file not found at ${resolvedPath}`);
+  }
+
+  const stats = fs.statSync(resolvedPath);
+  const filename = options.filename || path.basename(resolvedPath);
+  const contentType = options.contentType || inferContentType(resolvedPath);
+  const presign = await requestMediaPresign(filename, contentType, stats.size);
+
+  if (!presign.uploadUrl || !presign.publicUrl) {
+    throw new Error('uploadLocalMedia: presign response missing uploadUrl or publicUrl');
+  }
+
+  const uploadResponse = await fetch(presign.uploadUrl, {
+    method: 'PUT',
+    headers: {
+      'Content-Type': contentType,
+    },
+    body: fs.readFileSync(resolvedPath),
+  });
+
+  if (!uploadResponse.ok) {
+    const errorText = await uploadResponse.text().catch(() => '');
+    throw new Error(`uploadLocalMedia: upload failed with ${uploadResponse.status}: ${errorText}`);
+  }
+
+  return {
+    contentType,
+    key: presign.key || '',
+    size: stats.size,
+    type: presign.type || inferMediaType(contentType),
+    url: presign.publicUrl,
+  };
+}
+
 /**
  * Publishes a post immediately to one or more platforms.
  * @param {string} content
  * @param {Array<{platform: string, accountId: string}>} platforms
  * @returns {Promise<object>}
  */
-async function publishPost(content, platforms) {
+async function publishPost(content, platforms, options = {}) {
   if (!content) throw new Error('publishPost: content is required');
   if (!Array.isArray(platforms) || platforms.length === 0) {
     throw new Error('publishPost: platforms must be a non-empty array');
   }
 
+  const normalizedPlatforms = normalizePlatforms(platforms);
+  if (normalizedPlatforms.length === 0 || normalizedPlatforms.some((entry) => !entry.platform || !entry.accountId)) {
+    throw new Error('publishPost: each platform entry requires platform and accountId');
+  }
+
   // Tag trackable URLs with Zernio UTM parameters before publishing
-  content = tagUrlsInText(content, ZERNIO_UTM);
+  content = tagUrlsInText(content, options.utm || ZERNIO_UTM);
 
   const qualityGate = require('../../social-quality-gate');
   const gateResult = qualityGate.gatePost(content);
@@ -71,15 +277,35 @@ async function publishPost(content, platforms) {
     return { blocked: true, reasons: gateResult.findings };
   }
 
-  console.log(`[zernio:publisher] Publishing to ${platforms.length} platform(s): ${platforms.map((p) => p.platform).join(', ')}`);
+  // Dedup: filter out platforms where identical content was posted in last 24h
+  const dedupedPlatforms = normalizedPlatforms.filter((p) => {
+    if (isDuplicate(content, p.platform)) {
+      console.log(`[zernio:publisher] SKIPPED ${p.platform} — duplicate content within 24h`);
+      return false;
+    }
+    return true;
+  });
+
+  if (dedupedPlatforms.length === 0) {
+    console.log('[zernio:publisher] All platforms skipped (duplicate content)');
+    return { blocked: true, reasons: [{ reason: 'duplicate_content_all_platforms' }] };
+  }
+
+  console.log(`[zernio:publisher] Publishing to ${dedupedPlatforms.length} platform(s): ${dedupedPlatforms.map((p) => p.platform).join(', ')}`);
 
   const json = await zernioFetch('POST', '/posts', {
     content,
+    firstComment: options.firstComment,
+    mediaItems: options.mediaItems,
     publishNow: true,
-    platforms,
+    platforms: dedupedPlatforms,
   });
 
-  const data = json.data ?? json;
+  const data = normalizePostResult(json);
+  // Record each platform to prevent future dupes
+  for (const p of dedupedPlatforms) {
+    recordPost(content, p.platform);
+  }
   console.log(`[zernio:publisher] Post published. id=${data.id ?? 'unknown'}`);
   return data;
 }
@@ -92,7 +318,7 @@ async function publishPost(content, platforms) {
  * @param {string} timezone      IANA timezone string
  * @returns {Promise<object>}
  */
-async function schedulePost(content, platforms, scheduledFor, timezone) {
+async function schedulePost(content, platforms, scheduledFor, timezone, options = {}) {
   if (!content) throw new Error('schedulePost: content is required');
   if (!Array.isArray(platforms) || platforms.length === 0) {
     throw new Error('schedulePost: platforms must be a non-empty array');
@@ -100,17 +326,43 @@ async function schedulePost(content, platforms, scheduledFor, timezone) {
   if (!scheduledFor) throw new Error('schedulePost: scheduledFor is required');
   if (!timezone) throw new Error('schedulePost: timezone is required');
 
-  console.log(`[zernio:publisher] Scheduling post for ${scheduledFor} (${timezone}) to ${platforms.length} platform(s)`);
+  const normalizedPlatforms = normalizePlatforms(platforms);
+  if (normalizedPlatforms.length === 0 || normalizedPlatforms.some((entry) => !entry.platform || !entry.accountId)) {
+    throw new Error('schedulePost: each platform entry requires platform and accountId');
+  }
+
+  content = tagUrlsInText(content, options.utm || ZERNIO_UTM);
+
+  // Dedup: filter out platforms where identical content was scheduled in last 24h
+  const dedupedPlatforms = normalizedPlatforms.filter((p) => {
+    if (isDuplicate(content, p.platform)) {
+      console.log(`[zernio:publisher] SKIPPED ${p.platform} schedule — duplicate content within 24h`);
+      return false;
+    }
+    return true;
+  });
+
+  if (dedupedPlatforms.length === 0) {
+    console.log('[zernio:publisher] All platforms skipped (duplicate content)');
+    return { blocked: true, reasons: [{ reason: 'duplicate_content_all_platforms' }] };
+  }
+
+  console.log(`[zernio:publisher] Scheduling post for ${scheduledFor} (${timezone}) to ${dedupedPlatforms.length} platform(s)`);
 
   const json = await zernioFetch('POST', '/posts', {
     content,
+    firstComment: options.firstComment,
+    mediaItems: options.mediaItems,
     publishNow: false,
-    platforms,
+    platforms: dedupedPlatforms,
     scheduledFor,
     timezone,
   });
 
-  const data = json.data ?? json;
+  const data = normalizePostResult(json);
+  for (const p of dedupedPlatforms) {
+    recordPost(content, p.platform);
+  }
   console.log(`[zernio:publisher] Post scheduled. id=${data.id ?? 'unknown'}`);
   return data;
 }
@@ -123,7 +375,9 @@ async function getConnectedAccounts() {
   console.log('[zernio:publisher] Fetching connected accounts');
 
   const json = await zernioFetch('GET', '/accounts');
-  const accounts = Array.isArray(json) ? json : (json.data ?? json.accounts ?? []);
+  const accounts = (Array.isArray(json) ? json : (json.data ?? json.accounts ?? []))
+    .map(normalizeAccount)
+    .filter((account) => account && account.platform && account.accountId);
 
   console.log(`[zernio:publisher] ${accounts.length} connected account(s) found`);
   return accounts;
@@ -134,7 +388,7 @@ async function getConnectedAccounts() {
  * @param {string} content
  * @returns {Promise<{ published: object[], errors: object[] }>}
  */
-async function publishToAllPlatforms(content) {
+async function publishToAllPlatforms(content, options = {}) {
   if (!content) throw new Error('publishToAllPlatforms: content is required');
 
   console.log('[zernio:publisher] Fetching all connected accounts for bulk publish');
@@ -145,20 +399,31 @@ async function publishToAllPlatforms(content) {
     return { published: [], errors: [] };
   }
 
-  const platforms = accounts.map((acc) => ({
-    platform: acc.platform,
-    accountId: acc.accountId,
-  }));
-
   const published = [];
   const errors = [];
+  const requestedPlatforms = Array.isArray(options.platforms) && options.platforms.length > 0
+    ? new Set(options.platforms.map((platform) => String(platform || '').trim()).filter(Boolean))
+    : null;
+  const groupedAccounts = groupAccountsByPlatform(accounts);
+
+  for (const [platform, platformAccounts] of groupedAccounts.entries()) {
+    if (requestedPlatforms && !requestedPlatforms.has(platform)) {
+      continue;
+    }
 
-  try {
-    const result = await publishPost(content, platforms);
-    published.push(result);
-  } catch (err) {
-    console.error(`[zernio:publisher] Bulk publish failed: ${err.message}`);
-    errors.push({ error: err.message, platforms: platforms.map((p) => p.platform) });
+    try {
+      const result = await publishPost(content, platformAccounts, {
+        utm: {
+          source: platform,
+          medium: options.medium || ZERNIO_UTM.medium,
+          campaign: options.campaign || ZERNIO_UTM.campaign,
+        },
+      });
+      published.push({ platform, result });
+    } catch (err) {
+      console.error(`[zernio:publisher] Bulk publish failed for ${platform}: ${err.message}`);
+      errors.push({ error: err.message, platform });
+    }
   }
 
   console.log(`[zernio:publisher] Bulk publish complete. published=${published.length} errors=${errors.length}`);
@@ -166,10 +431,24 @@ async function publishToAllPlatforms(content) {
 }
 
 module.exports = {
+  buildDedupKey,
+  deletePost,
+  isDuplicate,
+  listPosts,
   publishPost,
+  recordPost,
   schedulePost,
   publishToAllPlatforms,
   getConnectedAccounts,
+  groupAccountsByPlatform,
+  inferContentType,
+  inferMediaType,
+  normalizeAccount,
+  normalizePlatforms,
+  normalizePostResult,
+  requestMediaPresign,
+  resolveAccountId,
+  uploadLocalMedia,
 };
 
 if (require.main === module) {

package/scripts/social-analytics/reconcile-thumbgate-campaign.js

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+'use strict';
+
+const {
+  buildCampaignEntries,
+  defaultCampaignSchedule,
+} = require('./publish-thumbgate-launch');
+const {
+  deletePost,
+  listPosts,
+} = require('./publishers/zernio');
+const {
+  buildScheduleKey,
+  DEFAULT_STATE_PATH,
+  writeScheduleState,
+} = require('./schedule-thumbgate-campaign');
+
+const CAMPAIGN_MARKERS = {
+  proof_pack: 'campaign_proof_pack',
+  free_local: 'campaign_free_local',
+  checkout_path: 'campaign_checkout_path',
+};
+
+function parseArgs(argv = []) {
+  const options = {
+    cancelDuplicates: false,
+    limit: 50,
+    scheduleTimes: [],
+    statePath: DEFAULT_STATE_PATH,
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (token === '--cancel-duplicates') {
+      options.cancelDuplicates = true;
+      continue;
+    }
+    if (token.startsWith('--limit=')) {
+      options.limit = Number(token.slice('--limit='.length)) || options.limit;
+      continue;
+    }
+    if (token.startsWith('--times=')) {
+      options.scheduleTimes = token.slice('--times='.length).split(',').map((value) => value.trim()).filter(Boolean);
+      continue;
+    }
+    if (token.startsWith('--state-path=')) {
+      options.statePath = token.slice('--state-path='.length).trim() || DEFAULT_STATE_PATH;
+    }
+  }
+
+  return options;
+}
+
+function normalizePlatform(post) {
+  return String(post?.platforms?.[0]?.platform || '').trim().toLowerCase();
+}
+
+function selectCanonicalPost(posts = []) {
+  return [...posts].sort((left, right) => {
+    const leftCreated = new Date(left.createdAt || 0).getTime();
+    const rightCreated = new Date(right.createdAt || 0).getTime();
+    return leftCreated - rightCreated;
+  })[0] || null;
+}
+
+async function reconcileCampaignState(options = {}, api = {}) {
+  const zernio = {
+    deletePost: api.deletePost || deletePost,
+    listPosts: api.listPosts || listPosts,
+  };
+  const scheduleTimes = options.scheduleTimes && options.scheduleTimes.length > 0
+    ? options.scheduleTimes
+    : defaultCampaignSchedule();
+  const posts = await zernio.listPosts({ limit: options.limit || 50 });
+  const scheduled = {};
+  const duplicates = [];
+  const kept = [];
+  const entries = buildCampaignEntries();
+
+  for (let index = 0; index < entries.length; index += 1) {
+    const entry = entries[index];
+    const scheduleLocal = scheduleTimes[index];
+    if (!scheduleLocal) {
+      continue;
+    }
+
+    const scheduledForUtc = new Date(scheduleLocal).toISOString();
+
+    for (const platform of Object.keys(entry.posts)) {
+      const marker = CAMPAIGN_MARKERS[entry.slug];
+      const matchingPosts = posts.filter((post) => (
+        post.status === 'scheduled' &&
+        normalizePlatform(post) === platform &&
+        String(post.content || '').includes(`utm_content=${marker}`) &&
+        String(post.scheduledFor || '') === scheduledForUtc
+      ));
+
+      if (matchingPosts.length === 0) {
+        continue;
+      }
+
+      const canonical = selectCanonicalPost(matchingPosts);
+      if (!canonical) {
+        continue;
+      }
+
+      const scheduleKey = buildScheduleKey({
+        slug: entry.slug,
+        platform,
+        scheduledFor: scheduleLocal,
+      });
+      scheduled[scheduleKey] = {
+        id: canonical._id,
+        scheduledFor: scheduleLocal,
+        slug: entry.slug,
+        platform,
+        recordedAt: new Date().toISOString(),
+      };
+      kept.push({
+        key: scheduleKey,
+        id: canonical._id,
+      });
+
+      const extras = matchingPosts.filter((post) => post._id !== canonical._id);
+      for (const duplicate of extras) {
+        const duplicateRecord = {
+          key: scheduleKey,
+          id: duplicate._id,
+          platform,
+          slug: entry.slug,
+        };
+        if (options.cancelDuplicates) {
+          duplicateRecord.cancelled = await zernio.deletePost(duplicate._id);
+        }
+        duplicates.push(duplicateRecord);
+      }
+    }
+  }
+
+  writeScheduleState(options.statePath || DEFAULT_STATE_PATH, { scheduled });
+  return {
+    duplicates,
+    kept,
+    statePath: options.statePath || DEFAULT_STATE_PATH,
+  };
+}
+
+if (require.main === module) {
+  reconcileCampaignState(parseArgs(process.argv.slice(2)))
+    .then((result) => {
+      process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    })
+    .catch((error) => {
+      console.error(error && error.message ? error.message : error);
+      process.exit(1);
+    });
+}
+
+module.exports = {
+  CAMPAIGN_MARKERS,
+  normalizePlatform,
+  parseArgs,
+  reconcileCampaignState,
+  selectCanonicalPost,
+};