thumbgate 1.4.2 → 1.4.4

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

@@ -1,385 +0,0 @@
-'use strict';
-
-/**
- * reddit.js
- * Publishes posts and comments to Reddit via the OAuth2 API.
- *
- * Required env vars:
- *   REDDIT_CLIENT_ID      — OAuth2 application client ID (required)
- *   REDDIT_CLIENT_SECRET  — OAuth2 application client secret (required)
- *   REDDIT_USERNAME       — Reddit account username (required)
- *   REDDIT_PASSWORD       — Reddit account password (required)
- *   REDDIT_USER_AGENT     — Custom User-Agent string (default: thumbgate/1.0 by <username>)
- *
- * Target subreddits for our product:
- *   r/ClaudeCode, r/ClaudeAI, r/MCP, r/LocalLLaMA, r/SideProject
- *
- * Reddit API reference:
- *   POST https://oauth.reddit.com/api/submit   — submit a link or text post
- *   POST https://oauth.reddit.com/api/comment  — submit a reply/comment
- */
-
-const { tagUrlsInText, buildUTMLink } = require('../utm');
-
-const REDDIT_UTM = { source: 'reddit', medium: 'social', campaign: 'organic' };
-
-const REDDIT_API_BASE = 'https://oauth.reddit.com';
-const REDDIT_TOKEN_URL = 'https://www.reddit.com/api/v1/access_token';
-
-// ---------------------------------------------------------------------------
-// Auth
-// ---------------------------------------------------------------------------
-
-/**
- * Exchange Reddit credentials for an OAuth2 access token using the password grant flow.
- *
- * @param {string} clientId
- * @param {string} clientSecret
- * @param {string} username
- * @param {string} password
- * @returns {Promise<string>} access_token
- */
-async function getRedditToken(clientId, clientSecret, username, password) {
-  if (!clientId) throw new Error('clientId is required');
-  if (!clientSecret) throw new Error('clientSecret is required');
-  if (!username) throw new Error('username is required');
-  if (!password) throw new Error('password is required');
-
-  const credentials = Buffer.from(`${clientId}:${clientSecret}`).toString('base64');
-  const body = new URLSearchParams({
-    grant_type: 'password',
-    username,
-    password,
-  });
-
-  console.log('[reddit:publisher] Fetching access token');
-
-  const res = await fetch(REDDIT_TOKEN_URL, {
-    method: 'POST',
-    headers: {
-      Authorization: `Basic ${credentials}`,
-      'Content-Type': 'application/x-www-form-urlencoded',
-      'User-Agent': `thumbgate/1.0 by ${username}`,
-    },
-    body: body.toString(),
-  });
-
-  if (!res.ok) {
-    const text = await res.text().catch(() => '');
-    throw new Error(`Reddit token endpoint ${res.status}: ${text}`);
-  }
-
-  const json = await res.json();
-
-  if (json.error) {
-    throw new Error(`Reddit token error: ${json.error} — ${json.message || ''}`);
-  }
-
-  const token = json.access_token;
-  if (!token) {
-    throw new Error(`Reddit token response missing access_token: ${JSON.stringify(json)}`);
-  }
-
-  console.log('[reddit:publisher] Access token obtained');
-  return token;
-}
-
-// ---------------------------------------------------------------------------
-// Post submission
-// ---------------------------------------------------------------------------
-
-/**
- * Submit a self (text) post to a subreddit.
- *
- * @param {string} token - Reddit OAuth2 access token
- * @param {string} userAgent - User-Agent header value
- * @param {{ subreddit: string, title: string, text: string }} options
- * @returns {Promise<object>} Reddit API response data
- */
-async function submitTextPost(token, userAgent, { subreddit, title, text }) {
-  if (!token) throw new Error('token is required');
-  if (!subreddit) throw new Error('subreddit is required');
-  if (!title) throw new Error('title is required');
-  if (!text) throw new Error('text is required');
-
-  const url = `${REDDIT_API_BASE}/api/submit`;
-  const body = new URLSearchParams({
-    kind: 'self',
-    sr: subreddit,
-    title,
-    text,
-    resubmit: 'true',
-    nsfw: 'false',
-    spoiler: 'false',
-  });
-
-  console.log(`[reddit:publisher] Submitting text post to r/${subreddit}: "${title}"`);
-
-  const res = await fetch(url, {
-    method: 'POST',
-    headers: {
-      Authorization: `Bearer ${token}`,
-      'Content-Type': 'application/x-www-form-urlencoded',
-      'User-Agent': userAgent,
-    },
-    body: body.toString(),
-  });
-
-  if (!res.ok) {
-    const text_body = await res.text().catch(() => '');
-    throw new Error(`Reddit API ${res.status} for ${url}: ${text_body}`);
-  }
-
-  const json = await res.json();
-
-  // Reddit wraps errors inside json.json.errors even on HTTP 200.
-  const errors = json.json?.errors ?? [];
-  if (errors.length > 0) {
-    throw new Error(`Reddit submit error: ${JSON.stringify(errors)}`);
-  }
-
-  const postData = json.json?.data ?? json;
-  console.log(
-    `[reddit:publisher] Text post submitted. url=${postData.url || postData.name || 'unknown'}`
-  );
-  return postData;
-}
-
-/**
- * Submit a link post to a subreddit.
- *
- * @param {string} token - Reddit OAuth2 access token
- * @param {string} userAgent - User-Agent header value
- * @param {{ subreddit: string, title: string, url: string }} options
- * @returns {Promise<object>} Reddit API response data
- */
-async function submitLinkPost(token, userAgent, { subreddit, title, url }) {
-  if (!token) throw new Error('token is required');
-  if (!subreddit) throw new Error('subreddit is required');
-  if (!title) throw new Error('title is required');
-  if (!url) throw new Error('url is required');
-
-  const endpoint = `${REDDIT_API_BASE}/api/submit`;
-  const body = new URLSearchParams({
-    kind: 'link',
-    sr: subreddit,
-    title,
-    url,
-    resubmit: 'true',
-    nsfw: 'false',
-    spoiler: 'false',
-  });
-
-  console.log(`[reddit:publisher] Submitting link post to r/${subreddit}: "${title}" -> ${url}`);
-
-  const res = await fetch(endpoint, {
-    method: 'POST',
-    headers: {
-      Authorization: `Bearer ${token}`,
-      'Content-Type': 'application/x-www-form-urlencoded',
-      'User-Agent': userAgent,
-    },
-    body: body.toString(),
-  });
-
-  if (!res.ok) {
-    const text_body = await res.text().catch(() => '');
-    throw new Error(`Reddit API ${res.status} for ${endpoint}: ${text_body}`);
-  }
-
-  const json = await res.json();
-
-  const errors = json.json?.errors ?? [];
-  if (errors.length > 0) {
-    throw new Error(`Reddit submit error: ${JSON.stringify(errors)}`);
-  }
-
-  const postData = json.json?.data ?? json;
-  console.log(
-    `[reddit:publisher] Link post submitted. url=${postData.url || postData.name || 'unknown'}`
-  );
-  return postData;
-}
-
-/**
- * Submit a comment or reply to an existing post or comment.
- *
- * @param {string} token - Reddit OAuth2 access token
- * @param {string} userAgent - User-Agent header value
- * @param {{ parentId: string, text: string }} options
- *   parentId — fullname of the parent thing (e.g. "t3_abc123" for a post, "t1_xyz" for a comment)
- * @returns {Promise<object>} Reddit API response data
- */
-async function submitComment(token, userAgent, { parentId, text }) {
-  if (!token) throw new Error('token is required');
-  if (!parentId) throw new Error('parentId is required');
-  if (!text) throw new Error('text is required');
-
-  const url = `${REDDIT_API_BASE}/api/comment`;
-  const body = new URLSearchParams({
-    thing_id: parentId,
-    text,
-  });
-
-  console.log(`[reddit:publisher] Submitting comment on ${parentId}`);
-
-  const res = await fetch(url, {
-    method: 'POST',
-    headers: {
-      Authorization: `Bearer ${token}`,
-      'Content-Type': 'application/x-www-form-urlencoded',
-      'User-Agent': userAgent,
-    },
-    body: body.toString(),
-  });
-
-  if (!res.ok) {
-    const text_body = await res.text().catch(() => '');
-    throw new Error(`Reddit API ${res.status} for ${url}: ${text_body}`);
-  }
-
-  const json = await res.json();
-
-  const errors = json.json?.errors ?? [];
-  if (errors.length > 0) {
-    throw new Error(`Reddit comment error: ${JSON.stringify(errors)}`);
-  }
-
-  const commentData = json.json?.data?.things?.[0]?.data ?? json.json?.data ?? json;
-  console.log(
-    `[reddit:publisher] Comment submitted. id=${commentData.id || commentData.name || 'unknown'}`
-  );
-  return commentData;
-}
-
-// ---------------------------------------------------------------------------
-// Convenience wrapper
-// ---------------------------------------------------------------------------
-
-/**
- * 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
- * @param {string} [utmContent] - Optional UTM content tag
- * @returns {string} The follow-up comment text
- */
-function buildFollowUpComment(subreddit, utmContent) {
-  return [
-    'Happy to answer questions about the implementation.',
-    '',
-    'Source code (MIT): https://github.com/IgorGanapolsky/ThumbGate',
-    '',
-    'Disclosure: I built this.',
-  ].join('\n');
-}
-
-/**
- * Publish to Reddit — submits a link post if url is provided, otherwise a text post.
- * Optionally posts a follow-up comment with the trial CTA.
- *
- * Reads credentials from environment variables if token is not supplied.
- *
- * @param {{ subreddit: string, title: string, text?: string, url?: string, token?: string, followUpComment?: boolean|string, utmContent?: string }} options
- * @returns {Promise<object>} Reddit API response data for the submitted post
- */
-async function publishToReddit({ subreddit, title, text, url, token, followUpComment, utmContent }) {
-  const clientId = process.env.REDDIT_CLIENT_ID;
-  const clientSecret = process.env.REDDIT_CLIENT_SECRET;
-  const username = process.env.REDDIT_USERNAME;
-  const password = process.env.REDDIT_PASSWORD;
-  const userAgent =
-    process.env.REDDIT_USER_AGENT || `thumbgate/1.0 by ${username}`;
-
-  const accessToken =
-    token ||
-    (await getRedditToken(clientId, clientSecret, username, password));
-
-  const qualityGate = require('../../social-quality-gate');
-  const gateResult = qualityGate.gatePost([title, text].filter(Boolean).join('\n'));
-  if (!gateResult.allowed) {
-    const reasons = gateResult.findings.map(f => f.reason).join(', ');
-    console.error(`[reddit:publisher] BLOCKED by quality gate: ${reasons}`);
-    return { blocked: true, reasons: gateResult.findings };
-  }
-
-  if (!subreddit) throw new Error('subreddit is required');
-  if (!title) throw new Error('title is required');
-
-  // Tag trackable URLs with Reddit UTM parameters
-  if (text) text = tagUrlsInText(text, REDDIT_UTM);
-  if (url) {
-    const taggedUrl = tagUrlsInText(url, REDDIT_UTM);
-    return submitLinkPost(accessToken, userAgent, { subreddit, title, url: taggedUrl });
-  }
-
-  if (!text) throw new Error('text is required when url is not provided');
-  const postData = await submitTextPost(accessToken, userAgent, { subreddit, title, text });
-
-  // Post follow-up comment with trial CTA if requested
-  if (followUpComment && postData.name) {
-    const commentText = typeof followUpComment === 'string'
-      ? followUpComment
-      : buildFollowUpComment(subreddit, utmContent);
-
-    const commentGate = qualityGate.gatePost(commentText);
-    if (!commentGate.allowed) {
-      console.error('[reddit:publisher] Follow-up comment BLOCKED by quality gate');
-    } else {
-      try {
-        await submitComment(accessToken, userAgent, { parentId: postData.name, text: commentText });
-        console.log('[reddit:publisher] Follow-up comment with trial CTA posted');
-      } catch (err) {
-        console.error('[reddit:publisher] Follow-up comment failed:', err.message);
-      }
-    }
-  }
-
-  return postData;
-}
-
-module.exports = {
-  getRedditToken,
-  submitTextPost,
-  submitLinkPost,
-  submitComment,
-  publishToReddit,
-  buildFollowUpComment,
-};
-
-// ---------------------------------------------------------------------------
-// Stand-alone execution
-// ---------------------------------------------------------------------------
-if (require.main === module) {
-  const args = process.argv.slice(2);
-
-  function getArg(flag) {
-    const prefix = `${flag}=`;
-    const entry = args.find((a) => a.startsWith(prefix));
-    return entry ? entry.slice(prefix.length) : null;
-  }
-
-  const subreddit = getArg('--subreddit');
-  const title = getArg('--title');
-  const text = getArg('--text');
-  const url = getArg('--url');
-  const followUp = args.includes('--follow-up');
-  const utmContent = getArg('--utm-content');
-
-  if (!subreddit || !title || (!text && !url)) {
-    console.error(
-      'Usage: node reddit.js --subreddit=<sub> --title=<title> [--text=<body> | --url=<url>] [--follow-up] [--utm-content=<tag>]'
-    );
-    process.exit(1);
-  }
-
-  publishToReddit({ subreddit, title, text, url, followUpComment: followUp, utmContent })
-    .then((data) => {
-      console.log(`[reddit:publisher] Done. response=${JSON.stringify(data)}`);
-    })
-    .catch((err) => {
-      console.error('[reddit:publisher] Publish failed:', err.message);
-      process.exit(1);
-    });
-}

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

@@ -1,275 +0,0 @@
-'use strict';
-
-/**
- * Threads post publisher using the Threads API (Meta, launched June 2024).
- *
- * Publishing flow:
- *   1. Create a media container (TEXT, IMAGE, or CAROUSEL).
- *   2. Publish the container via threads_publish.
- *
- * For carousels:
- *   1. Create child containers for each item (IMAGE).
- *   2. Create a CAROUSEL parent container referencing the child IDs.
- *   3. Publish the parent container.
- *
- * Required environment variables:
- *   THREADS_ACCESS_TOKEN — long-lived Threads user access token
- *   THREADS_USER_ID      — Threads user ID (numeric string)
- *
- * Handle: @igor.ganapolsky
- */
-
-const THREADS_BASE = 'https://graph.threads.net/v1.0';
-
-/**
- * Creates a Threads media container.
- *
- * @param {string} token  - Threads access token.
- * @param {string} userId - Threads user ID.
- * @param {object} opts
- * @param {string}  opts.text            - Post text content.
- * @param {string}  [opts.mediaType]     - 'TEXT' (default), 'IMAGE', or 'CAROUSEL'.
- * @param {string}  [opts.imageUrl]      - Public HTTPS URL of image (required for IMAGE type).
- * @param {string}  [opts.linkAttachment] - URL to attach as a link preview (TEXT posts only).
- * @returns {Promise<string>} The container ID returned by the API.
- */
-async function createThreadContainer(token, userId, { text, mediaType, imageUrl, linkAttachment } = {}) {
-  const resolvedMediaType = (mediaType ?? 'TEXT').toUpperCase();
-
-  console.log(`[threads:publisher] Creating ${resolvedMediaType} container…`);
-
-  const params = new URLSearchParams({
-    media_type: resolvedMediaType,
-    access_token: token,
-  });
-
-  if (text) params.set('text', text);
-  if (resolvedMediaType === 'IMAGE' && imageUrl) params.set('image_url', imageUrl);
-  if (resolvedMediaType === 'TEXT' && linkAttachment) params.set('link_attachment', linkAttachment);
-
-  const res = await fetch(`${THREADS_BASE}/${userId}/threads`, {
-    method: 'POST',
-    body: params,
-  });
-
-  const json = await res.json();
-
-  if (!res.ok || json.error) {
-    throw new Error(
-      `createThreadContainer failed (HTTP ${res.status}): ${JSON.stringify(json.error ?? json)}`
-    );
-  }
-
-  console.log(`[threads:publisher] Container created: ${json.id}`);
-  return json.id;
-}
-
-/**
- * Publishes a finalised Threads media container.
- *
- * @param {string} token       - Threads access token.
- * @param {string} userId      - Threads user ID.
- * @param {string} containerId - ID of the container to publish.
- * @returns {Promise<string>} The published thread ID.
- */
-async function publishThread(token, userId, containerId) {
-  console.log(
-    `[threads:publisher] Publishing container ${containerId}…`
-  );
-
-  const params = new URLSearchParams({
-    creation_id: containerId,
-    access_token: token,
-  });
-
-  const res = await fetch(`${THREADS_BASE}/${userId}/threads_publish`, {
-    method: 'POST',
-    body: params,
-  });
-
-  const json = await res.json();
-
-  if (!res.ok || json.error) {
-    throw new Error(
-      `publishThread failed (HTTP ${res.status}): ${JSON.stringify(json.error ?? json)}`
-    );
-  }
-
-  console.log(`[threads:publisher] Published thread ID: ${json.id}`);
-  return json.id;
-}
-
-/**
- * Creates and publishes a Threads carousel post.
- *
- * Multi-step flow:
- *   1. Create child IMAGE containers for each item.
- *   2. Create a CAROUSEL parent container referencing all child IDs.
- *   3. Publish the parent container.
- *
- * @param {string} token  - Threads access token.
- * @param {string} userId - Threads user ID.
- * @param {object} opts
- * @param {string}   opts.text  - Caption for the carousel.
- * @param {object[]} opts.items - Array of { imageUrl, text } for each slide.
- * @returns {Promise<string>} The published thread ID.
- */
-async function createCarouselThread(token, userId, { text, items }) {
-  if (!items || items.length < 2) {
-    throw new Error('createCarouselThread requires at least 2 items');
-  }
-  if (items.length > 20) {
-    throw new Error('Threads carousels support a maximum of 20 items');
-  }
-
-  console.log(
-    `[threads:publisher] Creating carousel thread with ${items.length} items…`
-  );
-
-  // Step 1: Create child containers for each item.
-  const childIds = [];
-  for (const item of items) {
-    const childParams = new URLSearchParams({
-      media_type: 'IMAGE',
-      is_carousel_item: 'true',
-      access_token: token,
-    });
-    if (item.imageUrl) childParams.set('image_url', item.imageUrl);
-    if (item.text) childParams.set('text', item.text);
-
-    const childRes = await fetch(`${THREADS_BASE}/${userId}/threads`, {
-      method: 'POST',
-      body: childParams,
-    });
-    const childJson = await childRes.json();
-
-    if (!childRes.ok || childJson.error) {
-      throw new Error(
-        `createCarouselThread child failed (HTTP ${childRes.status}): ${JSON.stringify(childJson.error ?? childJson)}`
-      );
-    }
-
-    console.log(`[threads:publisher] Child container created: ${childJson.id}`);
-    childIds.push(childJson.id);
-  }
-
-  // Step 2: Create the CAROUSEL parent container.
-  const parentParams = new URLSearchParams({
-    media_type: 'CAROUSEL',
-    children: childIds.join(','),
-    access_token: token,
-  });
-  if (text) parentParams.set('text', text);
-
-  const parentRes = await fetch(`${THREADS_BASE}/${userId}/threads`, {
-    method: 'POST',
-    body: parentParams,
-  });
-  const parentJson = await parentRes.json();
-
-  if (!parentRes.ok || parentJson.error) {
-    throw new Error(
-      `createCarouselThread parent failed (HTTP ${parentRes.status}): ${JSON.stringify(parentJson.error ?? parentJson)}`
-    );
-  }
-
-  console.log(`[threads:publisher] Carousel parent container created: ${parentJson.id}`);
-
-  // Step 3: Publish the parent container.
-  const publishedId = await publishThread(token, userId, parentJson.id);
-
-  console.log(`[threads:publisher] Carousel thread published: ${publishedId}`);
-  return publishedId;
-}
-
-/**
- * Convenience: creates and publishes a plain-text Threads post.
- *
- * @param {object} opts
- * @param {string} opts.text   - Post text content.
- * @param {string} opts.token  - Threads access token (defaults to env var).
- * @param {string} opts.userId - Threads user ID (defaults to env var).
- * @returns {Promise<string>} The published thread ID.
- */
-async function postTextThread({ text, token, userId }) {
-  const resolvedToken = token ?? process.env.THREADS_ACCESS_TOKEN;
-  const resolvedUserId = userId ?? process.env.THREADS_USER_ID;
-
-  if (!resolvedToken) throw new Error('THREADS_ACCESS_TOKEN is not set');
-  if (!resolvedUserId) throw new Error('THREADS_USER_ID is not set');
-  if (!text) throw new Error('postTextThread: text is required');
-
-  const containerId = await createThreadContainer(resolvedToken, resolvedUserId, {
-    text,
-    mediaType: 'TEXT',
-  });
-  return publishThread(resolvedToken, resolvedUserId, containerId);
-}
-
-/**
- * Convenience: creates and publishes a Threads post with an image.
- *
- * @param {object} opts
- * @param {string} opts.text     - Post text content.
- * @param {string} opts.imageUrl - Public HTTPS URL of the image.
- * @param {string} opts.token    - Threads access token (defaults to env var).
- * @param {string} opts.userId   - Threads user ID (defaults to env var).
- * @returns {Promise<string>} The published thread ID.
- */
-async function postImageThread({ text, imageUrl, token, userId }) {
-  const resolvedToken = token ?? process.env.THREADS_ACCESS_TOKEN;
-  const resolvedUserId = userId ?? process.env.THREADS_USER_ID;
-
-  if (!resolvedToken) throw new Error('THREADS_ACCESS_TOKEN is not set');
-  if (!resolvedUserId) throw new Error('THREADS_USER_ID is not set');
-  if (!imageUrl) throw new Error('postImageThread: imageUrl is required');
-
-  const containerId = await createThreadContainer(resolvedToken, resolvedUserId, {
-    text,
-    mediaType: 'IMAGE',
-    imageUrl,
-  });
-  return publishThread(resolvedToken, resolvedUserId, containerId);
-}
-
-module.exports = {
-  createThreadContainer,
-  publishThread,
-  createCarouselThread,
-  postTextThread,
-  postImageThread,
-};
-
-// Allow running directly:
-//   node scripts/social-analytics/publishers/threads.js --text "Hello Threads!"
-//   node scripts/social-analytics/publishers/threads.js --text "Check this out" --image "https://example.com/img.jpg"
-if (require.main === module) {
-  (async () => {
-    const args = process.argv.slice(2);
-    const get = (flag) => {
-      const idx = args.indexOf(flag);
-      return idx !== -1 ? args[idx + 1] : null;
-    };
-
-    const text = get('--text');
-    const image = get('--image');
-
-    if (!text) {
-      console.error('Usage: node threads.js --text "..." [--image "https://..."]');
-      process.exit(1);
-    }
-
-    try {
-      let publishedId;
-      if (image) {
-        publishedId = await postImageThread({ text, imageUrl: image });
-      } else {
-        publishedId = await postTextThread({ text });
-      }
-      console.log(`[threads:publisher] Success. Published thread ID: ${publishedId}`);
-    } catch (err) {
-      console.error('[threads:publisher] Fatal error:', err.message);
-      process.exit(1);
-    }
-  })();
-}