thumbgate 0.9.10 → 0.9.11

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,
+};

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

@@ -0,0 +1,275 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { publishInstagramThumbGate } = require('./publish-instagram-thumbgate');
+const {
+  DEFAULT_TIMEZONE,
+  buildCampaignEntries,
+  defaultCampaignSchedule,
+} = require('./publish-thumbgate-launch');
+const {
+  getConnectedAccounts,
+  groupAccountsByPlatform,
+  schedulePost,
+} = require('./publishers/zernio');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const DEFAULT_STATE_PATH = path.join(REPO_ROOT, '.thumbgate', 'social-campaign-schedule-state.json');
+
+function parseArgs(argv = []) {
+  const options = {
+    dryRun: false,
+    platforms: [],
+    scheduleTimes: [],
+    statePath: DEFAULT_STATE_PATH,
+    timezone: DEFAULT_TIMEZONE,
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (token === '--dry-run') {
+      options.dryRun = true;
+      continue;
+    }
+
+    if (token.startsWith('--platforms=')) {
+      options.platforms = token.slice('--platforms='.length).split(',').map((value) => value.trim()).filter(Boolean);
+      continue;
+    }
+
+    if (token === '--platforms' && argv[index + 1]) {
+      options.platforms = String(argv[index + 1]).split(',').map((value) => value.trim()).filter(Boolean);
+      index += 1;
+      continue;
+    }
+
+    if (token.startsWith('--times=')) {
+      options.scheduleTimes = token.slice('--times='.length).split(',').map((value) => value.trim()).filter(Boolean);
+      continue;
+    }
+
+    if (token === '--times' && argv[index + 1]) {
+      options.scheduleTimes = String(argv[index + 1]).split(',').map((value) => value.trim()).filter(Boolean);
+      index += 1;
+      continue;
+    }
+
+    if (token.startsWith('--timezone=')) {
+      options.timezone = token.slice('--timezone='.length).trim() || DEFAULT_TIMEZONE;
+      continue;
+    }
+
+    if (token.startsWith('--state-path=')) {
+      options.statePath = token.slice('--state-path='.length).trim() || DEFAULT_STATE_PATH;
+      continue;
+    }
+
+    if (token === '--timezone' && argv[index + 1]) {
+      options.timezone = String(argv[index + 1]).trim() || DEFAULT_TIMEZONE;
+      index += 1;
+      continue;
+    }
+
+    if (token === '--state-path' && argv[index + 1]) {
+      options.statePath = String(argv[index + 1]).trim() || DEFAULT_STATE_PATH;
+      index += 1;
+    }
+  }
+
+  return options;
+}
+
+function readScheduleState(statePath = DEFAULT_STATE_PATH) {
+  if (!fs.existsSync(statePath)) {
+    return { scheduled: {} };
+  }
+
+  try {
+    return JSON.parse(fs.readFileSync(statePath, 'utf8'));
+  } catch {
+    return { scheduled: {} };
+  }
+}
+
+function writeScheduleState(statePath = DEFAULT_STATE_PATH, state = { scheduled: {} }) {
+  fs.mkdirSync(path.dirname(statePath), { recursive: true });
+  fs.writeFileSync(statePath, `${JSON.stringify(state, null, 2)}\n`);
+}
+
+function buildScheduleKey({ slug, platform, scheduledFor }) {
+  return `${scheduledFor}::${slug}::${platform}`;
+}
+
+async function scheduleCampaign(options = {}, api = {}) {
+  const scheduleApi = {
+    getConnectedAccounts: api.getConnectedAccounts || getConnectedAccounts,
+    groupAccountsByPlatform: api.groupAccountsByPlatform || groupAccountsByPlatform,
+    publishInstagramThumbGate: api.publishInstagramThumbGate || publishInstagramThumbGate,
+    schedulePost: api.schedulePost || schedulePost,
+  };
+
+  const campaignEntries = buildCampaignEntries();
+  const scheduleTimes = options.scheduleTimes && options.scheduleTimes.length > 0
+    ? options.scheduleTimes
+    : defaultCampaignSchedule();
+  const platforms = options.platforms && options.platforms.length > 0
+    ? options.platforms
+    : ['twitter', 'linkedin', 'instagram'];
+  const statePath = options.statePath || DEFAULT_STATE_PATH;
+  const state = readScheduleState(statePath);
+  const scheduledState = state.scheduled && typeof state.scheduled === 'object' ? state.scheduled : {};
+  const accounts = await scheduleApi.getConnectedAccounts();
+  const groupedAccounts = scheduleApi.groupAccountsByPlatform(accounts);
+  const results = {
+    dryRun: options.dryRun === true,
+    statePath,
+    timezone: options.timezone || DEFAULT_TIMEZONE,
+    scheduleTimes,
+    platforms,
+    scheduled: [],
+    skipped: [],
+    errors: [],
+  };
+
+  for (let index = 0; index < campaignEntries.length; index += 1) {
+    const entry = campaignEntries[index];
+    const scheduledFor = scheduleTimes[index];
+    if (!scheduledFor) {
+      results.skipped.push({ slug: entry.slug, reason: 'missing_schedule_time' });
+      continue;
+    }
+
+    for (const platform of platforms) {
+      const normalizedPlatform = String(platform || '').trim().toLowerCase();
+      const platformAccounts = groupedAccounts.get(normalizedPlatform) || [];
+      if (platformAccounts.length === 0) {
+        results.skipped.push({ slug: entry.slug, platform: normalizedPlatform, reason: 'not_connected' });
+        continue;
+      }
+
+      const content = entry.posts[normalizedPlatform];
+      if (!content) {
+        results.skipped.push({ slug: entry.slug, platform: normalizedPlatform, reason: 'no_content' });
+        continue;
+      }
+
+      const scheduleKey = buildScheduleKey({
+        slug: entry.slug,
+        platform: normalizedPlatform,
+        scheduledFor,
+      });
+      if (!results.dryRun && scheduledState[scheduleKey]) {
+        results.skipped.push({
+          slug: entry.slug,
+          platform: normalizedPlatform,
+          reason: 'already_scheduled',
+          scheduledFor,
+          existing: scheduledState[scheduleKey],
+        });
+        continue;
+      }
+
+      if (results.dryRun) {
+        results.scheduled.push({
+          slug: entry.slug,
+          platform: normalizedPlatform,
+          scheduledFor,
+          dryRun: true,
+          content,
+        });
+        continue;
+      }
+
+      const utm = {
+        source: normalizedPlatform === 'twitter' ? 'x' : normalizedPlatform,
+        medium: 'organic_social',
+        campaign: 'first_customer_push',
+      };
+
+      try {
+        if (normalizedPlatform === 'instagram') {
+          const scheduledResult = await scheduleApi.publishInstagramThumbGate({
+            caption: content,
+            schedule: scheduledFor,
+            timezone: options.timezone || DEFAULT_TIMEZONE,
+            utm,
+          });
+          scheduledState[scheduleKey] = {
+            id: scheduledResult.postId || scheduledResult.id || null,
+            scheduledFor,
+            slug: entry.slug,
+            platform: normalizedPlatform,
+            recordedAt: new Date().toISOString(),
+          };
+          results.scheduled.push({
+            slug: entry.slug,
+            platform: normalizedPlatform,
+            scheduledFor,
+            result: scheduledResult,
+          });
+          continue;
+        }
+
+        const scheduledResult = await scheduleApi.schedulePost(
+          content,
+          platformAccounts,
+          scheduledFor,
+          options.timezone || DEFAULT_TIMEZONE,
+          { utm }
+        );
+        scheduledState[scheduleKey] = {
+          id: scheduledResult.id || scheduledResult.post?._id || null,
+          scheduledFor,
+          slug: entry.slug,
+          platform: normalizedPlatform,
+          recordedAt: new Date().toISOString(),
+        };
+        results.scheduled.push({
+          slug: entry.slug,
+          platform: normalizedPlatform,
+          scheduledFor,
+          result: scheduledResult,
+        });
+      } catch (error) {
+        results.errors.push({
+          slug: entry.slug,
+          platform: normalizedPlatform,
+          error: error && error.message ? error.message : String(error),
+        });
+      }
+    }
+  }
+
+  if (!results.dryRun) {
+    writeScheduleState(statePath, { scheduled: scheduledState });
+  }
+
+  return results;
+}
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  const results = await scheduleCampaign(options);
+  process.stdout.write(`${JSON.stringify(results, null, 2)}\n`);
+  if (results.errors.length > 0) {
+    process.exitCode = 1;
+  }
+}
+
+if (require.main === module) {
+  main().catch((error) => {
+    console.error(error && error.message ? error.message : error);
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  buildScheduleKey,
+  DEFAULT_STATE_PATH,
+  parseArgs,
+  readScheduleState,
+  scheduleCampaign,
+  writeScheduleState,
+};

package/scripts/social-analytics/sync-launch-assets.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const {
+  listPosts,
+} = require('./publishers/zernio');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const DEFAULT_STATE_PATH = path.join(REPO_ROOT, '.thumbgate', 'social-launch-assets.json');
+
+const LAUNCH_MARKERS = {
+  twitter: 'launch_post_twitter',
+  linkedin: 'launch_post_linkedin',
+  instagram: 'launch_post_instagram',
+  reddit: 'launch_post_reddit',
+};
+
+const CAMPAIGN_MARKERS = {
+  proof_pack: 'campaign_proof_pack',
+  free_local: 'campaign_free_local',
+  checkout_path: 'campaign_checkout_path',
+};
+
+function parseArgs(argv = []) {
+  const options = {
+    limit: 50,
+    statePath: DEFAULT_STATE_PATH,
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = String(argv[index] || '').trim();
+    if (token.startsWith('--limit=')) {
+      options.limit = Number.parseInt(token.slice('--limit='.length), 10) || options.limit;
+      continue;
+    }
+    if (token === '--limit' && argv[index + 1]) {
+      options.limit = Number.parseInt(String(argv[index + 1]), 10) || options.limit;
+      index += 1;
+      continue;
+    }
+    if (token.startsWith('--state-path=')) {
+      options.statePath = token.slice('--state-path='.length).trim() || DEFAULT_STATE_PATH;
+      continue;
+    }
+    if (token === '--state-path' && argv[index + 1]) {
+      options.statePath = String(argv[index + 1]).trim() || DEFAULT_STATE_PATH;
+      index += 1;
+    }
+  }
+
+  return options;
+}
+
+function normalizePlatform(post = {}) {
+  return String(post?.platforms?.[0]?.platform || '').trim().toLowerCase();
+}
+
+function extractMarker(post = {}) {
+  const content = String(post.content || '');
+
+  for (const marker of Object.values(LAUNCH_MARKERS)) {
+    if (content.includes(`utm_content=${marker}`)) {
+      return marker;
+    }
+  }
+
+  for (const marker of Object.values(CAMPAIGN_MARKERS)) {
+    if (content.includes(`utm_content=${marker}`)) {
+      return marker;
+    }
+  }
+
+  return '';
+}
+
+function toTimestamp(post = {}) {
+  return new Date(post.createdAt || post.updatedAt || post.scheduledFor || 0).getTime();
+}
+
+function selectNewestPost(posts = []) {
+  return [...posts].sort((left, right) => toTimestamp(right) - toTimestamp(left))[0] || null;
+}
+
+function summarizePost(post = {}, marker = '') {
+  return {
+    id: post._id || post.id || null,
+    platform: normalizePlatform(post),
+    status: post.status || null,
+    marker,
+    createdAt: post.createdAt || null,
+    updatedAt: post.updatedAt || null,
+    scheduledFor: post.scheduledFor || null,
+    content: post.content || '',
+  };
+}
+
+function buildLaunchAssetState(posts = []) {
+  const state = {
+    updatedAt: new Date().toISOString(),
+    launchPosts: {},
+    campaignPosts: {},
+  };
+
+  for (const [platform, marker] of Object.entries(LAUNCH_MARKERS)) {
+    const matching = posts.filter((post) => extractMarker(post) === marker);
+    const selected = selectNewestPost(matching);
+    if (selected) {
+      state.launchPosts[platform] = summarizePost(selected, marker);
+    }
+  }
+
+  for (const [slug, marker] of Object.entries(CAMPAIGN_MARKERS)) {
+    const matching = posts.filter((post) => extractMarker(post) === marker);
+    if (matching.length === 0) {
+      continue;
+    }
+
+    const byPlatform = {};
+    for (const post of matching) {
+      const platform = normalizePlatform(post);
+      if (!platform) continue;
+      const existing = byPlatform[platform];
+      if (!existing || toTimestamp(post) > toTimestamp(existing)) {
+        byPlatform[platform] = post;
+      }
+    }
+
+    state.campaignPosts[slug] = {};
+    for (const [platform, post] of Object.entries(byPlatform)) {
+      state.campaignPosts[slug][platform] = summarizePost(post, marker);
+    }
+  }
+
+  return state;
+}
+
+function writeLaunchAssetState(statePath = DEFAULT_STATE_PATH, state = {}) {
+  fs.mkdirSync(path.dirname(statePath), { recursive: true });
+  fs.writeFileSync(statePath, `${JSON.stringify(state, null, 2)}\n`, 'utf8');
+  return statePath;
+}
+
+async function syncLaunchAssets(options = {}, api = {}) {
+  const zernio = {
+    listPosts: api.listPosts || listPosts,
+  };
+
+  const posts = await zernio.listPosts({ limit: options.limit || 50 });
+  const state = buildLaunchAssetState(Array.isArray(posts) ? posts : []);
+  const statePath = options.statePath || DEFAULT_STATE_PATH;
+  writeLaunchAssetState(statePath, state);
+  return {
+    statePath,
+    launchCount: Object.keys(state.launchPosts).length,
+    campaignCount: Object.keys(state.campaignPosts).length,
+    state,
+  };
+}
+
+if (require.main === module) {
+  syncLaunchAssets(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,
+  DEFAULT_STATE_PATH,
+  LAUNCH_MARKERS,
+  buildLaunchAssetState,
+  extractMarker,
+  normalizePlatform,
+  parseArgs,
+  selectNewestPost,
+  summarizePost,
+  syncLaunchAssets,
+  writeLaunchAssetState,
+};