thumbgate 0.9.9

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/devto.js

@@ -0,0 +1,122 @@
+'use strict';
+
+/**
+ * devto.js
+ * Publishes articles to Dev.to via their REST API.
+ *
+ * Required env vars:
+ *   DEVTO_API_KEY — API key from Settings > Extensions > API Keys
+ *
+ * Dev.to API reference:
+ *   POST https://dev.to/api/articles — create/update an article
+ *   GET  https://dev.to/api/articles/me — list my articles
+ */
+
+const DEVTO_API_BASE = 'https://dev.to/api';
+
+// ---------------------------------------------------------------------------
+// Article creation
+// ---------------------------------------------------------------------------
+
+/**
+ * Create and publish an article on Dev.to.
+ *
+ * @param {{ title: string, body_markdown: string, tags?: string[], published?: boolean, series?: string, canonical_url?: string }} options
+ * @returns {Promise<object>} Dev.to API response (includes id, url, slug)
+ */
+async function publishArticle({ title, body_markdown, tags, published = true, series, canonical_url }) {
+  const apiKey = process.env.DEVTO_API_KEY;
+  if (!apiKey) throw new Error('DEVTO_API_KEY env var is required');
+  if (!title) throw new Error('title is required');
+  if (!body_markdown) throw new Error('body_markdown is required');
+
+  const article = { title, body_markdown, published };
+  if (tags && tags.length > 0) article.tags = tags;
+  if (series) article.series = series;
+  if (canonical_url) article.canonical_url = canonical_url;
+
+  console.log(`[devto:publisher] Publishing article: "${title}"`);
+
+  const res = await fetch(`${DEVTO_API_BASE}/articles`, {
+    method: 'POST',
+    headers: {
+      'api-key': apiKey,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({ article }),
+  });
+
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    throw new Error(`Dev.to API ${res.status}: ${text}`);
+  }
+
+  const data = await res.json();
+  console.log(`[devto:publisher] Article published. url=${data.url || data.slug || 'unknown'}`);
+  return data;
+}
+
+/**
+ * List my published articles.
+ *
+ * @param {{ page?: number, per_page?: number }} options
+ * @returns {Promise<object[]>}
+ */
+async function listMyArticles({ page = 1, per_page = 30 } = {}) {
+  const apiKey = process.env.DEVTO_API_KEY;
+  if (!apiKey) throw new Error('DEVTO_API_KEY env var is required');
+
+  const url = `${DEVTO_API_BASE}/articles/me?page=${page}&per_page=${per_page}`;
+  const res = await fetch(url, {
+    headers: { 'api-key': apiKey },
+  });
+
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    throw new Error(`Dev.to API ${res.status}: ${text}`);
+  }
+
+  return res.json();
+}
+
+module.exports = {
+  publishArticle,
+  listMyArticles,
+};
+
+// ---------------------------------------------------------------------------
+// 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 title = getArg('--title');
+  const body = getArg('--body');
+  const tags = getArg('--tags');
+  const draft = args.includes('--draft');
+
+  if (!title || !body) {
+    console.error('Usage: node devto.js --title=<title> --body=<markdown> [--tags=js,automation] [--draft]');
+    process.exit(1);
+  }
+
+  publishArticle({
+    title,
+    body_markdown: body,
+    tags: tags ? tags.split(',').map((t) => t.trim()) : [],
+    published: !draft,
+  })
+    .then((data) => {
+      console.log(`[devto:publisher] Done. url=${data.url}`);
+    })
+    .catch((err) => {
+      console.error('[devto:publisher] Publish failed:', err.message);
+      process.exit(1);
+    });
+}