thumbgate 0.9.10 → 0.9.11

package/scripts/social-analytics/publish-thumbgate-launch.js

@@ -0,0 +1,316 @@
+#!/usr/bin/env node
+'use strict';
+
+const { buildUTMLink } = require('./utm');
+const { publishInstagramThumbGate } = require('./publish-instagram-thumbgate');
+const {
+  getConnectedAccounts,
+  groupAccountsByPlatform,
+  publishPost,
+  schedulePost,
+} = require('./publishers/zernio');
+const { THUMBGATE_CAPTION } = require('./instagram-thumbgate-post');
+const { resolveHostedBillingConfig } = require('../hosted-config');
+
+const APP_ORIGIN = resolveHostedBillingConfig({
+  requestOrigin: 'https://thumbgate-production.up.railway.app',
+}).appOrigin;
+const DEFAULT_TIMEZONE = 'America/New_York';
+const LAUNCH_CAMPAIGN = 'first_customer_push';
+const DEFAULT_LAUNCH_PLATFORMS = ['twitter', 'linkedin', 'instagram'];
+
+function parseArgs(argv = []) {
+  const options = {
+    dryRun: false,
+    platforms: [],
+    schedule: '',
+    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((platform) => platform.trim())
+        .filter(Boolean);
+      continue;
+    }
+
+    if (token === '--platforms' && argv[index + 1]) {
+      options.platforms = String(argv[index + 1])
+        .split(',')
+        .map((platform) => platform.trim())
+        .filter(Boolean);
+      index += 1;
+      continue;
+    }
+
+    if (token.startsWith('--schedule=')) {
+      options.schedule = token.slice('--schedule='.length).trim();
+      continue;
+    }
+
+    if (token === '--schedule' && argv[index + 1]) {
+      options.schedule = String(argv[index + 1]).trim();
+      index += 1;
+      continue;
+    }
+
+    if (token.startsWith('--timezone=')) {
+      options.timezone = token.slice('--timezone='.length).trim() || DEFAULT_TIMEZONE;
+      continue;
+    }
+
+    if (token === '--timezone' && argv[index + 1]) {
+      options.timezone = String(argv[index + 1]).trim() || DEFAULT_TIMEZONE;
+      index += 1;
+    }
+  }
+
+  return options;
+}
+
+function buildLandingUrl(platform, content) {
+  return buildUTMLink(`${APP_ORIGIN}/`, {
+    source: platform,
+    medium: 'organic_social',
+    campaign: LAUNCH_CAMPAIGN,
+    content,
+  });
+}
+
+function buildPlatformPost(platform) {
+  const normalized = String(platform || '').trim().toLowerCase();
+
+  if (normalized === 'twitter' || normalized === 'x') {
+    return [
+      'Claude Code kept repeating the same mistakes across sessions.',
+      'ThumbGate turns thumbs-down feedback into a prevention rule that blocks the same pattern next time.',
+      'Local-first. Free path. Pro trial.',
+      buildLandingUrl('x', 'launch_post_twitter'),
+    ].join(' ');
+  }
+
+  if (normalized === 'linkedin') {
+    return [
+      'AI coding agents do not reliably learn from your repo-level pain.',
+      'That is the problem I kept hitting with Claude Code and Cursor: the same broken config, import, or workflow mistake would come back in the next session.',
+      'ThumbGate turns thumbs-down feedback into a prevention rule and blocks the same pattern before the next tool call lands.',
+      'Local-first. Free path. Pro adds the personal dashboard, DPO export, and a gate debugger.',
+      buildLandingUrl('linkedin', 'launch_post_linkedin'),
+    ].join(' ');
+  }
+
+  if (normalized === 'instagram') {
+    return `${THUMBGATE_CAPTION}\n\n${buildLandingUrl('instagram', 'launch_post_instagram')}`;
+  }
+
+  if (normalized === 'reddit') {
+    return [
+      'I built ThumbGate after watching Claude Code repeat the same repo mistakes across sessions.',
+      'It turns thumbs-down feedback into a prevention rule so the same pattern gets blocked next time.',
+      'Free local path, no cloud account required.',
+      buildLandingUrl('reddit', 'launch_post_reddit'),
+    ].join(' ');
+  }
+
+  return [
+    'ThumbGate turns AI coding-agent feedback into enforced prevention rules so the same mistake gets blocked in the next session.',
+    'Local-first. Free path. Pro adds the personal dashboard and DPO export.',
+    buildLandingUrl(normalized || 'zernio', `launch_post_${normalized || 'generic'}`),
+  ].join(' ');
+}
+
+function buildCampaignEntries() {
+  return [
+    {
+      slug: 'proof_pack',
+      posts: {
+        twitter: [
+          'AI coding agents do not need more hype. They need proof-backed workflow hardening.',
+          'ThumbGate turns thumbs-down feedback into a prevention rule that blocks the same mistake next session.',
+          'Proof pack:',
+          buildLandingUrl('x', 'campaign_proof_pack'),
+        ].join(' '),
+        linkedin: [
+          'Workflow hardening beats generic AI hype.',
+          'ThumbGate captures failure signals, promotes them into prevention rules, and blocks the same bad pattern before the next tool call executes.',
+          'This is about one workflow becoming safe enough to ship, not abstract "agent memory."',
+          buildLandingUrl('linkedin', 'campaign_proof_pack'),
+        ].join(' '),
+        instagram: `${THUMBGATE_CAPTION}\n\nProof-backed workflow hardening.\n\n${buildLandingUrl('instagram', 'campaign_proof_pack')}`,
+      },
+    },
+    {
+      slug: 'free_local',
+      posts: {
+        twitter: [
+          'The free path is the point.',
+          'ThumbGate runs local-first, keeps lesson state in .thumbgate, and blocks repeated coding-agent mistakes without a cloud account.',
+          buildLandingUrl('x', 'campaign_free_local'),
+        ].join(' '),
+        linkedin: [
+          'Most AI tooling tries to sell a hosted layer first. ThumbGate does not.',
+          'The free local path gives you feedback capture, prevention rules, and blocking on your machine. Pro adds the personal dashboard and exports when the workflow is already valuable.',
+          buildLandingUrl('linkedin', 'campaign_free_local'),
+        ].join(' '),
+        instagram: [
+          'Your AI coding agent forgets everything between sessions.',
+          'ThumbGate keeps the feedback loop local, durable, and enforceable.',
+          buildLandingUrl('instagram', 'campaign_free_local'),
+        ].join('\n\n'),
+      },
+    },
+    {
+      slug: 'checkout_path',
+      posts: {
+        twitter: [
+          'If your agent repeats the same repo mistake every week, the fix is not another prompt.',
+          'ThumbGate blocks known-bad patterns before the next tool call lands.',
+          'Free local path, Pro trial here:',
+          buildLandingUrl('x', 'campaign_checkout_path'),
+        ].join(' '),
+        linkedin: [
+          'Repeated agent mistakes are a systems problem, not a prompt-writing problem.',
+          'ThumbGate turns explicit feedback into prevention rules and gives individual operators a paid path when they want the dashboard, exports, and gate debugger.',
+          buildLandingUrl('linkedin', 'campaign_checkout_path'),
+        ].join(' '),
+        instagram: [
+          'ThumbGate turns thumbs-down feedback into a prevention rule.',
+          'Next session, the same mistake gets blocked.',
+          buildLandingUrl('instagram', 'campaign_checkout_path'),
+        ].join('\n\n'),
+      },
+    },
+  ];
+}
+
+function defaultCampaignSchedule(now = new Date()) {
+  const target = new Date(now.getTime());
+  target.setDate(target.getDate() + 1);
+  const year = target.getFullYear();
+  const month = String(target.getMonth() + 1).padStart(2, '0');
+  const day = String(target.getDate()).padStart(2, '0');
+  return [
+    `${year}-${month}-${day}T10:15:00-04:00`,
+    `${year}-${month}-${day}T14:30:00-04:00`,
+    `${year}-${month}-${day}T18:45:00-04:00`,
+  ];
+}
+
+async function publishLaunchCampaign(options = {}, publisher = {}) {
+  const api = {
+    getConnectedAccounts: publisher.getConnectedAccounts || getConnectedAccounts,
+    groupAccountsByPlatform: publisher.groupAccountsByPlatform || groupAccountsByPlatform,
+    publishPost: publisher.publishPost || publishPost,
+    schedulePost: publisher.schedulePost || schedulePost,
+    publishInstagramThumbGate: publisher.publishInstagramThumbGate || publishInstagramThumbGate,
+  };
+
+  const platforms = Array.isArray(options.platforms) && options.platforms.length > 0
+    ? options.platforms
+    : DEFAULT_LAUNCH_PLATFORMS;
+  const schedule = String(options.schedule || '').trim();
+  const timezone = String(options.timezone || DEFAULT_TIMEZONE).trim() || DEFAULT_TIMEZONE;
+  const accounts = await api.getConnectedAccounts();
+  const groupedAccounts = api.groupAccountsByPlatform(accounts);
+  const results = {
+    dryRun: options.dryRun === true,
+    platforms,
+    previews: [],
+    published: [],
+    scheduled: [],
+    skipped: [],
+    errors: [],
+  };
+
+  for (const platform of platforms) {
+    const normalizedPlatform = String(platform || '').trim().toLowerCase();
+    const platformAccounts = groupedAccounts.get(normalizedPlatform) || [];
+    if (platformAccounts.length === 0) {
+      results.skipped.push({ platform: normalizedPlatform, reason: 'not_connected' });
+      continue;
+    }
+
+    const content = buildPlatformPost(normalizedPlatform);
+    results.previews.push({
+      platform: normalizedPlatform,
+      content,
+      accountCount: platformAccounts.length,
+    });
+
+    if (results.dryRun) {
+      continue;
+    }
+
+    const utm = {
+      source: normalizedPlatform === 'twitter' ? 'x' : normalizedPlatform,
+      medium: 'organic_social',
+      campaign: LAUNCH_CAMPAIGN,
+    };
+
+    try {
+      if (normalizedPlatform === 'instagram') {
+        if (schedule) {
+          results.skipped.push({ platform: normalizedPlatform, reason: 'schedule_not_supported_for_instagram_launch' });
+          continue;
+        }
+
+        const instagramResult = await api.publishInstagramThumbGate({ caption: content });
+        results.published.push({ platform: normalizedPlatform, result: instagramResult });
+        continue;
+      }
+
+      if (schedule) {
+        const scheduledResult = await api.schedulePost(content, platformAccounts, schedule, timezone, { utm });
+        results.scheduled.push({ platform: normalizedPlatform, result: scheduledResult });
+      } else {
+        const publishResult = await api.publishPost(content, platformAccounts, { utm });
+        results.published.push({ platform: normalizedPlatform, result: publishResult });
+      }
+    } catch (error) {
+      results.errors.push({
+        platform: normalizedPlatform,
+        error: error && error.message ? error.message : String(error),
+      });
+    }
+  }
+
+  return results;
+}
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  const results = await publishLaunchCampaign(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 = {
+  APP_ORIGIN,
+  DEFAULT_LAUNCH_PLATFORMS,
+  DEFAULT_TIMEZONE,
+  LAUNCH_CAMPAIGN,
+  buildCampaignEntries,
+  buildLandingUrl,
+  buildPlatformPost,
+  defaultCampaignSchedule,
+  parseArgs,
+  publishLaunchCampaign,
+};

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

@@ -257,24 +257,19 @@ async function submitComment(token, userAgent, { parentId, text }) {
 // ---------------------------------------------------------------------------
 
 /**
- * Build the standard follow-up comment for a Reddit post.
- * This comment contains the trial CTA and source code link.
+ * Build a follow-up comment for a Reddit post.
+ * Kept minimal and non-promotional to avoid spam flags.
+ * Reddit communities aggressively downvote/ban promotional CTAs.
  *
- * @param {string} subreddit - The subreddit name (used for UTM tracking)
- * @param {string} [utmContent] - Optional UTM content tag (defaults to subreddit name)
+ * @param {string} subreddit - The subreddit name
+ * @param {string} [utmContent] - Optional UTM content tag
  * @returns {string} The follow-up comment text
  */
 function buildFollowUpComment(subreddit, utmContent) {
-  const content = utmContent || `${subreddit}_post`;
-  const trialUrl = `https://thumbgate-production.up.railway.app/?utm_source=reddit&utm_medium=organic_social&utm_campaign=reddit_followup_comment&utm_content=${encodeURIComponent(content)}&community=${encodeURIComponent(subreddit)}`;
   return [
-    'The problem: AI coding agents repeat the same mistakes every session. You correct a force-push, it does it again tomorrow. Prompt rules get ignored after context compaction.',
+    'Happy to answer questions about the implementation.',
     '',
-    'ThumbGate fixes this with enforcement, not memory. You give a thumbs-down, it auto-generates a prevention rule, and a gate physically blocks the agent from repeating that action. Thumbs-up reinforces good behavior.',
-    '',
-    `Try free for 7 days (no credit card, 2-minute setup): ${trialUrl}`,
-    '',
-    'Source code (MIT licensed): https://github.com/IgorGanapolsky/ThumbGate',
+    'Source code (MIT): https://github.com/IgorGanapolsky/ThumbGate',
     '',
     'Disclosure: I built this.',
   ].join('\n');

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

@@ -8,12 +8,17 @@
  *   ZERNIO_API_KEY — Bearer token for https://zernio.com/api/v1
  */
 
+const fs = require('node:fs');
+const path = require('node:path');
 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';
 
+loadLocalEnv();
+
 function requireApiKey() {
   const key = process.env.ZERNIO_API_KEY;
   if (!key) {
@@ -22,6 +27,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 +129,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 +224,17 @@ 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(', ')}`);
+  console.log(`[zernio:publisher] Publishing to ${normalizedPlatforms.length} platform(s): ${normalizedPlatforms.map((p) => p.platform).join(', ')}`);
 
   const json = await zernioFetch('POST', '/posts', {
     content,
+    firstComment: options.firstComment,
+    mediaItems: options.mediaItems,
     publishNow: true,
-    platforms,
+    platforms: normalizedPlatforms,
   });
 
-  const data = json.data ?? json;
+  const data = normalizePostResult(json);
   console.log(`[zernio:publisher] Post published. id=${data.id ?? 'unknown'}`);
   return data;
 }
@@ -92,7 +247,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 +255,26 @@ 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);
+
+  console.log(`[zernio:publisher] Scheduling post for ${scheduledFor} (${timezone}) to ${normalizedPlatforms.length} platform(s)`);
 
   const json = await zernioFetch('POST', '/posts', {
     content,
+    firstComment: options.firstComment,
+    mediaItems: options.mediaItems,
     publishNow: false,
-    platforms,
+    platforms: normalizedPlatforms,
     scheduledFor,
     timezone,
   });
 
-  const data = json.data ?? json;
+  const data = normalizePostResult(json);
   console.log(`[zernio:publisher] Post scheduled. id=${data.id ?? 'unknown'}`);
   return data;
 }
@@ -123,7 +287,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 +300,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 +311,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 +343,21 @@ async function publishToAllPlatforms(content) {
 }
 
 module.exports = {
+  deletePost,
+  listPosts,
   publishPost,
   schedulePost,
   publishToAllPlatforms,
   getConnectedAccounts,
+  groupAccountsByPlatform,
+  inferContentType,
+  inferMediaType,
+  normalizeAccount,
+  normalizePlatforms,
+  normalizePostResult,
+  requestMediaPresign,
+  resolveAccountId,
+  uploadLocalMedia,
 };
 
 if (require.main === module) {