@julioventura/opensquad 0.1.17

package/skills/instagram-publisher/scripts/publish.js

@@ -0,0 +1,521 @@
+#!/usr/bin/env node
+// Instagram Carousel Publisher (with optional Facebook cross-post)
+// Usage: node --env-file=.env publish.js --images "slide1.jpg,slide2.jpg" --caption "..." [--dry-run] [--facebook]
+
+import { readFileSync } from 'node:fs';
+import { extname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+// ── Argument parsing ──────────────────────────────────────────
+
+export function parseArgs(argv) {
+  const args = {
+    images: [],
+    caption: '',
+    dryRun: false,
+    facebook: false,
+    facebookOnly: false,
+    instagramAccessTokenEnv: null,
+    instagramUserIdEnv: null,
+    facebookPageIdEnv: null,
+    facebookPageAccessTokenEnv: null,
+  };
+  for (let i = 2; i < argv.length; i++) {
+    if (argv[i] === '--images') {
+      if (i + 1 < argv.length) args.images = argv[++i].split(',').map(s => s.trim());
+    }
+    else if (argv[i] === '--caption') {
+      if (i + 1 < argv.length) args.caption = argv[++i];
+    }
+    else if (argv[i] === '--dry-run') args.dryRun = true;
+    else if (argv[i] === '--facebook') args.facebook = true;
+    else if (argv[i] === '--facebook-only') {
+      args.facebook = true;
+      args.facebookOnly = true;
+    }
+    else if (argv[i] === '--instagram-access-token-env') {
+      if (i + 1 < argv.length) args.instagramAccessTokenEnv = argv[++i];
+    }
+    else if (argv[i] === '--instagram-user-id-env') {
+      if (i + 1 < argv.length) args.instagramUserIdEnv = argv[++i];
+    }
+    else if (argv[i] === '--facebook-page-id-env') {
+      if (i + 1 < argv.length) args.facebookPageIdEnv = argv[++i];
+    }
+    else if (argv[i] === '--facebook-page-access-token-env') {
+      if (i + 1 < argv.length) args.facebookPageAccessTokenEnv = argv[++i];
+    }
+  }
+  return args;
+}
+
+const DEFAULT_ENV_KEYS = {
+  instagramAccessToken: 'INSTAGRAM_ACCESS_TOKEN',
+  instagramUserId: 'INSTAGRAM_USER_ID',
+  facebookPageId: 'FACEBOOK_PAGE_ID',
+  facebookPageAccessToken: 'FACEBOOK_PAGE_ACCESS_TOKEN',
+};
+
+export function resolveConfiguredEnv(env, options = {}) {
+  const instagramAccessTokenKey = options.instagramAccessTokenEnv || DEFAULT_ENV_KEYS.instagramAccessToken;
+  const instagramUserIdKey = options.instagramUserIdEnv || DEFAULT_ENV_KEYS.instagramUserId;
+  const facebookPageIdKey = options.facebookPageIdEnv || DEFAULT_ENV_KEYS.facebookPageId;
+  const facebookPageAccessTokenKey = options.facebookPageAccessTokenEnv || DEFAULT_ENV_KEYS.facebookPageAccessToken;
+
+  return {
+    instagramAccessTokenKey,
+    instagramUserIdKey,
+    facebookPageIdKey,
+    facebookPageAccessTokenKey,
+    instagramAccessToken: env[instagramAccessTokenKey],
+    instagramUserId: env[instagramUserIdKey],
+    facebookPageId: env[facebookPageIdKey],
+    facebookPageAccessToken: env[facebookPageAccessTokenKey],
+    imgbbApiKey: env.IMGBB_API_KEY,
+  };
+}
+
+// ── Image upload (imgBB) ──────────────────────────────────────
+
+export async function uploadToImgBB(imagePath, apiKey) {
+  const absolutePath = resolve(imagePath);
+  const fileBuffer = readFileSync(absolutePath);
+  const base64Image = fileBuffer.toString('base64');
+  const form = new FormData();
+  form.append('key', apiKey);
+  form.append('image', base64Image);
+  const res = await fetch('https://api.imgbb.com/1/upload', {
+    method: 'POST',
+    body: form,
+  });
+  if (!res.ok) throw new Error(`imgBB upload failed [${res.status}]: ${await res.text()}`);
+  const json = await res.json();
+  if (!json.success) throw new Error(`imgBB upload failed: ${JSON.stringify(json)}`);
+  return json.data.url;
+}
+
+// ── Facebook Pages API ────────────────────────────────────────
+
+const FB_BASE = 'https://graph.facebook.com/v21.0';
+
+function detectImageMimeType(imagePath) {
+  const extension = extname(imagePath).toLowerCase();
+  if (extension === '.png') return 'image/png';
+  return 'image/jpeg';
+}
+
+function shouldRetryFacebookPhotoUploadLocally(errorText) {
+  const normalized = errorText.toLowerCase();
+  return normalized.includes('missing or invalid image file')
+    || normalized.includes('imagem obrigat')
+    || normalized.includes('invalid image file')
+    || normalized.includes('error_subcode":2069019');
+}
+
+export async function uploadPhotoToPage(pageId, imageUrl, pageToken, deps = {}) {
+  const {
+    fetchImpl = fetch,
+    localImagePath = null,
+  } = deps;
+  const params = new URLSearchParams({
+    url: imageUrl,
+    published: 'false',
+    access_token: pageToken,
+  });
+  const res = await fetchImpl(`${FB_BASE}/${pageId}/photos?${params}`, { method: 'POST' });
+  if (!res.ok) {
+    const errorText = await res.text();
+
+    if (!localImagePath || !shouldRetryFacebookPhotoUploadLocally(errorText)) {
+      throw new Error(`uploadPhotoToPage failed [${res.status}]: ${errorText}`);
+    }
+
+    const absolutePath = resolve(localImagePath);
+    const fileBuffer = readFileSync(absolutePath);
+    const form = new FormData();
+    form.append('published', 'false');
+    form.append('access_token', pageToken);
+    form.append('source', new Blob([fileBuffer], { type: detectImageMimeType(absolutePath) }), absolutePath.split(/[/\\]/).pop() || 'upload.jpg');
+
+    const fallbackRes = await fetchImpl(`${FB_BASE}/${pageId}/photos`, {
+      method: 'POST',
+      body: form,
+    });
+
+    if (!fallbackRes.ok) {
+      throw new Error(`uploadPhotoToPage failed [${fallbackRes.status}]: ${await fallbackRes.text()}`);
+    }
+
+    return (await fallbackRes.json()).id;
+  }
+  return (await res.json()).id;
+}
+
+export async function createFacebookPost(pageId, photoIds, caption, pageToken, deps = {}) {
+  const { fetchImpl = fetch } = deps;
+  const params = new URLSearchParams({
+    message: caption,
+    access_token: pageToken,
+    attached_media: JSON.stringify(photoIds.map(id => ({ media_fbid: id }))),
+  });
+  const res = await fetchImpl(`${FB_BASE}/${pageId}/feed`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/x-www-form-urlencoded',
+    },
+    body: params,
+  });
+  if (!res.ok) throw new Error(`createFacebookPost failed [${res.status}]: ${await res.text()}`);
+  return (await res.json()).id;
+}
+
+export async function getFacebookIdentity(accessToken) {
+  const params = new URLSearchParams({ fields: 'id,name', access_token: accessToken });
+  const res = await fetch(`${FB_BASE}/me?${params}`);
+  if (!res.ok) throw new Error(`getFacebookIdentity failed [${res.status}]: ${await res.text()}`);
+  return res.json();
+}
+
+export async function listFacebookAccounts(accessToken) {
+  const params = new URLSearchParams({
+    fields: 'id,name,access_token',
+    limit: '200',
+    access_token: accessToken,
+  });
+  const res = await fetch(`${FB_BASE}/me/accounts?${params}`);
+  if (!res.ok) throw new Error(`listFacebookAccounts failed [${res.status}]: ${await res.text()}`);
+  const json = await res.json();
+  return json.data ?? [];
+}
+
+export async function resolveFacebookPageAccessToken(options, deps = {}) {
+  const {
+    pageId,
+    configuredToken,
+    fallbackUserToken,
+  } = options;
+  const {
+    getFacebookIdentityImpl = getFacebookIdentity,
+    listFacebookAccountsImpl = listFacebookAccounts,
+  } = deps;
+
+  if (!pageId) return null;
+
+  const tryResolveFromToken = async (token, sourceBase) => {
+    if (!token) return null;
+
+    try {
+      const identity = await getFacebookIdentityImpl(token);
+      if (identity?.id === pageId) {
+        return { token, source: `${sourceBase}-page-token` };
+      }
+    } catch {
+      // Some tokens are not valid for /me identity introspection. Continue to /me/accounts.
+    }
+
+    try {
+      const accounts = await listFacebookAccountsImpl(token);
+      const matchingPage = accounts.find(account => account.id === pageId && account.access_token);
+      if (matchingPage) {
+        return { token: matchingPage.access_token, source: `${sourceBase}-accounts` };
+      }
+    } catch {
+      return null;
+    }
+
+    return null;
+  };
+
+  const configuredResolution = await tryResolveFromToken(configuredToken, 'configured');
+  if (configuredResolution) return configuredResolution;
+
+  if (fallbackUserToken && fallbackUserToken !== configuredToken) {
+    const fallbackResolution = await tryResolveFromToken(fallbackUserToken, 'instagram');
+    if (fallbackResolution) return fallbackResolution;
+  }
+
+  return null;
+}
+
+// ── Instagram Graph API ───────────────────────────────────────
+
+const IG_BASE = 'https://graph.facebook.com/v21.0';
+
+export async function createChildContainer(userId, imageUrl, accessToken) {
+  const params = new URLSearchParams({
+    image_url: imageUrl,
+    is_carousel_item: 'true',
+    access_token: accessToken,
+  });
+  const res = await fetch(`${IG_BASE}/${userId}/media?${params}`, { method: 'POST' });
+  if (!res.ok) throw new Error(`createChildContainer failed [${res.status}]: ${await res.text()}`);
+  return (await res.json()).id;
+}
+
+export async function getContainerStatus(containerId, accessToken) {
+  const params = new URLSearchParams({ fields: 'status_code', access_token: accessToken });
+  const res = await fetch(`${IG_BASE}/${containerId}?${params}`);
+  if (!res.ok) throw new Error(`getContainerStatus failed [${res.status}]: ${await res.text()}`);
+  return (await res.json()).status_code;
+}
+
+export async function pollUntilFinished(containerId, accessToken, timeoutMs = 60_000, intervalMs = 3_000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const status = await getContainerStatus(containerId, accessToken);
+    if (status === 'FINISHED') return;
+    if (status === 'ERROR') throw new Error(`Container ${containerId} entered ERROR state`);
+    await new Promise(r => setTimeout(r, intervalMs));
+  }
+  throw new Error(`Container ${containerId} timed out after ${timeoutMs}ms`);
+}
+
+export async function createCarouselContainer(userId, childIds, caption, accessToken) {
+  const params = new URLSearchParams({
+    media_type: 'CAROUSEL',
+    children: childIds.join(','),
+    caption,
+    access_token: accessToken,
+  });
+  const res = await fetch(`${IG_BASE}/${userId}/media?${params}`, { method: 'POST' });
+  if (!res.ok) throw new Error(`createCarouselContainer failed [${res.status}]: ${await res.text()}`);
+  return (await res.json()).id;
+}
+
+export async function publishMedia(userId, containerId, accessToken) {
+  const params = new URLSearchParams({ creation_id: containerId, access_token: accessToken });
+  const res = await fetch(`${IG_BASE}/${userId}/media_publish?${params}`, { method: 'POST' });
+  if (!res.ok) throw new Error(`publishMedia failed [${res.status}]: ${await res.text()}`);
+  return (await res.json()).id;
+}
+
+export function enrichInstagramPublishErrorMessage(message) {
+  const text = String(message || '');
+  const normalized = text.toLowerCase();
+  const isKnownLivePublishBlock = normalized.includes('publishmedia failed')
+    && (
+      normalized.includes('error_subcode":2207051')
+      || normalized.includes('"code":4')
+      || normalized.includes('application request limit reached')
+      || normalized.includes('application-level rate limit')
+    );
+
+  if (!isKnownLivePublishBlock) {
+    return text;
+  }
+
+  return `${text}\nMeta blocked the live Graph API publish step for this app/account. If the media containers were created successfully, treat this as a platform restriction rather than an asset-order failure. Use Meta Business Suite with the approved images and caption, confirm the carousel order before the final click, then record the final Instagram/Facebook URLs and post IDs in the run artifacts.`;
+}
+
+export async function getPermalink(mediaId, accessToken) {
+  const params = new URLSearchParams({ fields: 'permalink', access_token: accessToken });
+  const res = await fetch(`${IG_BASE}/${mediaId}?${params}`);
+  if (!res.ok) return null; // non-fatal — just skip the URL display
+  const json = await res.json();
+  return json.permalink ?? null;
+}
+
+// ── Main ──────────────────────────────────────────────────────
+
+export async function publishCarousel(options, env = process.env, deps = {}) {
+  const {
+    uploadToImgBB: uploadToImgBBImpl = uploadToImgBB,
+    createChildContainer: createChildContainerImpl = createChildContainer,
+    pollUntilFinished: pollUntilFinishedImpl = pollUntilFinished,
+    createCarouselContainer: createCarouselContainerImpl = createCarouselContainer,
+    publishMedia: publishMediaImpl = publishMedia,
+    getPermalink: getPermalinkImpl = getPermalink,
+    uploadPhotoToPage: uploadPhotoToPageImpl = uploadPhotoToPage,
+    createFacebookPost: createFacebookPostImpl = createFacebookPost,
+    resolveFacebookPageAccessToken: resolveFacebookPageAccessTokenImpl = resolveFacebookPageAccessToken,
+    logger = console,
+  } = deps;
+
+  const {
+    images,
+    caption,
+    dryRun,
+    facebook,
+    facebookOnly,
+    instagramAccessTokenEnv,
+    instagramUserIdEnv,
+    facebookPageIdEnv,
+    facebookPageAccessTokenEnv,
+  } = options;
+
+  if (!images.length) throw new Error('--images is required (e.g. --images "slide1.jpg,slide2.jpg")');
+  if (!caption) throw new Error('--caption is required');
+  if (!facebookOnly && (images.length < 2 || images.length > 10)) {
+    throw new Error(`Instagram carousels require 2–10 images (got ${images.length})`);
+  }
+  if (caption.length > 2200) {
+    throw new Error(`Caption exceeds Instagram's 2200-character limit (got ${caption.length})`);
+  }
+  if (facebookOnly && !facebook) {
+    throw new Error('--facebook-only requires --facebook behavior to be enabled');
+  }
+
+  const configuredEnv = resolveConfiguredEnv(env, {
+    instagramAccessTokenEnv,
+    instagramUserIdEnv,
+    facebookPageIdEnv,
+    facebookPageAccessTokenEnv,
+  });
+  const {
+    instagramAccessTokenKey,
+    instagramUserIdKey,
+    facebookPageIdKey,
+    facebookPageAccessTokenKey,
+    instagramAccessToken,
+    instagramUserId,
+    facebookPageId,
+    facebookPageAccessToken,
+    imgbbApiKey,
+  } = configuredEnv;
+
+  if (!facebookOnly && !instagramAccessToken) throw new Error(`${instagramAccessTokenKey} is not set in environment`);
+  if (!facebookOnly && !instagramUserId) throw new Error(`${instagramUserIdKey} is not set in environment`);
+  if (!imgbbApiKey) throw new Error('IMGBB_API_KEY is not set in environment. Get one at https://api.imgbb.com/');
+  if (facebook && !facebookPageId) throw new Error(`${facebookPageIdKey} is not set in environment — required for --facebook`);
+  if (facebook && !facebookPageAccessToken) {
+    throw new Error(`${facebookPageAccessTokenKey} is not set in environment — required for --facebook`);
+  }
+
+  let fbToken = null;
+  if (facebook) {
+    const resolvedFacebookToken = await resolveFacebookPageAccessTokenImpl(
+      {
+        pageId: facebookPageId,
+        configuredToken: facebookPageAccessToken,
+        fallbackUserToken: instagramAccessToken,
+      },
+    );
+
+    if (!resolvedFacebookToken?.token) {
+      throw new Error(
+        `Could not resolve a Facebook Page access token for Page ${facebookPageId}. Checked ${facebookPageAccessTokenKey} and ${instagramAccessTokenKey}.`,
+      );
+    }
+
+    fbToken = resolvedFacebookToken.token;
+    if (resolvedFacebookToken.source !== 'configured-page-token') {
+      logger.log(`ℹ️ Facebook Page token resolved via ${resolvedFacebookToken.source} for Page ${facebookPageId}.`);
+    }
+  }
+
+  const result = {
+    status: dryRun ? 'dry-run' : 'published',
+    instagramPostId: null,
+    instagramUrl: null,
+    facebookPostId: null,
+    facebookUrl: null,
+    error: null,
+  };
+
+  logger.log(`📸 Uploading ${images.length} image(s) to imgBB...`);
+  const imageUrls = await Promise.all(images.map(p => uploadToImgBBImpl(p, imgbbApiKey)));
+  imageUrls.forEach((url, i) => logger.log(`   [${i + 1}] ${url}`));
+
+  if (facebookOnly) {
+    if (dryRun) {
+      logger.log('\n✅ DRY RUN complete — skipping final Facebook publish call.');
+      logger.log(`   Facebook cross-post: would post ${images.length} images to Page ${facebookPageId}`);
+      return result;
+    }
+
+    logger.log(`\n📘 Publishing to Facebook Page ${facebookPageId}...`);
+    const fbPhotoIds = await Promise.all(
+      imageUrls.map((url, index) => uploadPhotoToPageImpl(facebookPageId, url, fbToken, { localImagePath: images[index] }))
+    );
+    logger.log(`   Photo IDs: ${fbPhotoIds.join(', ')}`);
+    const fbPostId = await createFacebookPostImpl(facebookPageId, fbPhotoIds, caption, fbToken);
+    result.facebookPostId = fbPostId;
+    result.facebookUrl = `https://www.facebook.com/${fbPostId}`;
+    logger.log(`\n✅ Facebook: Published successfully!`);
+    logger.log(`   Post ID: ${fbPostId}`);
+    logger.log(`   URL: ${result.facebookUrl}`);
+    return result;
+  }
+
+  logger.log('\n📦 Creating Instagram media containers...');
+  const childIds = await Promise.all(
+    imageUrls.map(url => createChildContainerImpl(instagramUserId, url, instagramAccessToken))
+  );
+  logger.log(`   Container IDs: ${childIds.join(', ')}`);
+
+  logger.log('\n⏳ Waiting for containers to finish processing...');
+  await Promise.all(childIds.map(id => pollUntilFinishedImpl(id, instagramAccessToken)));
+  logger.log('   All containers ready.');
+
+  logger.log('\n🎠 Creating carousel container...');
+  const carouselId = await createCarouselContainerImpl(
+    instagramUserId, childIds, caption, instagramAccessToken
+  );
+  await pollUntilFinishedImpl(carouselId, instagramAccessToken);
+  logger.log(`   Carousel container ID: ${carouselId}`);
+
+  if (dryRun) {
+    logger.log('\n✅ DRY RUN complete — skipping final publish call.');
+    logger.log(`   Carousel container ready: ${carouselId}`);
+    if (facebook) logger.log(`   Facebook cross-post: would post ${images.length} images to Page ${facebookPageId}`);
+    return result;
+  }
+
+  logger.log('\n🚀 Publishing to Instagram...');
+  let postId;
+
+  try {
+    postId = await publishMediaImpl(instagramUserId, carouselId, instagramAccessToken);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(enrichInstagramPublishErrorMessage(message));
+  }
+
+  const permalink = await getPermalinkImpl(postId, instagramAccessToken);
+  result.instagramPostId = postId;
+  result.instagramUrl = permalink;
+  logger.log(`\n✅ Instagram: Published successfully!`);
+  logger.log(`   Post ID: ${postId}`);
+  if (permalink) logger.log(`   URL: ${permalink}`);
+
+  if (facebook) {
+    try {
+      logger.log(`\n📘 Cross-posting to Facebook Page ${facebookPageId}...`);
+      const fbPhotoIds = await Promise.all(
+        imageUrls.map((url, index) => uploadPhotoToPageImpl(facebookPageId, url, fbToken, { localImagePath: images[index] }))
+      );
+      logger.log(`   Photo IDs: ${fbPhotoIds.join(', ')}`);
+      const fbPostId = await createFacebookPostImpl(facebookPageId, fbPhotoIds, caption, fbToken);
+      result.facebookPostId = fbPostId;
+      result.facebookUrl = `https://www.facebook.com/${fbPostId}`;
+      logger.log(`\n✅ Facebook: Published successfully!`);
+      logger.log(`   Post ID: ${fbPostId}`);
+      logger.log(`   URL: ${result.facebookUrl}`);
+    } catch (error) {
+      result.status = 'partial';
+      result.error = error instanceof Error ? error.message : String(error);
+      logger.error(`\n⚠️ Partial result: Instagram published, but Facebook failed.`);
+      logger.error(`   ${result.error}`);
+      return result;
+    }
+  }
+
+  return result;
+}
+
+async function main() {
+  const result = await publishCarousel(parseArgs(process.argv));
+
+  if (result.status === 'partial') {
+    process.exitCode = 2;
+  }
+}
+
+// Run only when executed directly (not when imported for tests)
+const isMain = process.argv[1] === fileURLToPath(import.meta.url);
+if (isMain) {
+  main().catch(err => {
+    console.error(`\n❌ ${err.message}`);
+    process.exit(1);
+  });
+}