overlay-factory-worker 0.1.0

package/scripts/check-safe-area.ts

@@ -0,0 +1,148 @@
+/**
+ * Does anything land where Instagram's UI will sit on top of it?
+ *
+ * Measures rather than assumes: renders a frame with and without the overlays,
+ * diffs them to get the exact pixels the composition draws, and reports the
+ * bounding box of each overlay against the safe area. No hand-measuring a
+ * screenshot, and it re-checks itself every time the layout changes.
+ *
+ *   npx tsx scripts/check-safe-area.ts episodes/what-prints-002.json
+ */
+import { execFileSync } from "node:child_process";
+import { readFileSync, writeFileSync, mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import sharp from "sharp";
+import {
+  UI_ZONES,
+  FRAME,
+  GRID_CROP,
+  overlaps,
+} from "../src/overlay/safeArea";
+
+const ROOT = join(import.meta.dirname, "..");
+const { width: W, height: H } = FRAME;
+
+/** Vertical bands to attribute overlay pixels to, so the report names names. */
+const BANDS = [
+  { name: "title", from: 0, to: 600 },
+  { name: "card", from: 600, to: 1300 },
+  { name: "meter", from: 1300, to: H },
+];
+
+type Episode = { revealAtSec: number; durationSec: number };
+
+const renderStill = (
+  episodePath: string,
+  frame: number,
+  out: string,
+  hideOverlays: boolean,
+) => {
+  const episode = JSON.parse(readFileSync(episodePath, "utf8")) as object;
+  const props = join(ROOT, ".safe-area-props.json");
+  writeFileSync(props, JSON.stringify({ ...episode, hideOverlays }));
+  try {
+    execFileSync(
+      "npx",
+      [
+        "remotion",
+        "still",
+        "WhatPrints",
+        out,
+        `--props=${props}`,
+        `--frame=${frame}`,
+        "--log=error",
+      ],
+      { cwd: ROOT, stdio: "inherit" },
+    );
+  } finally {
+    rmSync(props, { force: true });
+  }
+};
+
+const raw = async (file: string) => {
+  const { data, info } = await sharp(file)
+    .resize(W, H, { fit: "fill" })
+    .removeAlpha()
+    .raw()
+    .toBuffer({ resolveWithObject: true });
+  return { data, channels: info.channels };
+};
+
+const main = async () => {
+  const episodePath = process.argv[2];
+  if (!episodePath) {
+    console.error("usage: check-safe-area.ts <episode.json>");
+    process.exit(1);
+  }
+  const ep = JSON.parse(readFileSync(episodePath, "utf8")) as Episode;
+  const dir = mkdtempSync(join(tmpdir(), "reel-safe-"));
+  const frame = Math.round((ep.revealAtSec + 0.5) * 30);
+
+  const a = join(dir, "full.png");
+  const b = join(dir, "bg.png");
+  renderStill(episodePath, frame, a, false);
+  renderStill(episodePath, frame, b, true);
+  const [full, bg] = [await raw(a), await raw(b)];
+  const ch = full.channels;
+
+  // Bounding box of drawn pixels, per band. The scrim is a full-frame gradient
+  // and would swamp everything, so only strongly-changed pixels count.
+  const boxes = BANDS.map((band) => {
+    let top: number = H;
+    let bottom = -1;
+    let left: number = W;
+    let right = -1;
+    for (let y = band.from; y < band.to; y++) {
+      for (let x = 0; x < W; x++) {
+        const i = (y * W + x) * ch;
+        const d =
+          Math.abs(full.data[i] - bg.data[i]) +
+          Math.abs(full.data[i + 1] - bg.data[i + 1]) +
+          Math.abs(full.data[i + 2] - bg.data[i + 2]);
+        if (d < 120) continue;
+        if (y < top) top = y;
+        if (y > bottom) bottom = y;
+        if (x < left) left = x;
+        if (x > right) right = x;
+      }
+    }
+    return bottom < 0 ? null : { name: band.name, top, bottom, left, right };
+  }).filter((b): b is NonNullable<typeof b> => b !== null);
+
+  rmSync(dir, { recursive: true, force: true });
+
+  console.log(`\n${episodePath} — overlay bounds vs Instagram's UI`);
+  for (const z of UI_ZONES)
+    console.log(
+      `  IG ${z.name.padEnd(11)} x ${z.x}-${z.x + z.width}  y ${z.y}-${z.y + z.height}`,
+    );
+  console.log("");
+
+  let bad = false;
+  for (const box of boxes) {
+    const hits = UI_ZONES.filter((z) => overlaps(box, z)).map((z) => z.name);
+
+    const grid =
+      box.top < GRID_CROP.top || box.bottom > H - GRID_CROP.bottom
+        ? "  (also cropped out of the profile grid thumbnail)"
+        : "";
+
+    if (hits.length) bad = true;
+    console.log(
+      `  ${box.name.padEnd(6)} x ${String(box.left).padStart(4)}-${String(box.right).padEnd(4)} ` +
+        `y ${String(box.top).padStart(4)}-${String(box.bottom).padEnd(4)}  ` +
+        (hits.length ? `UNDER ${hits.join(" + ")}` : "ok") +
+        grid,
+    );
+  }
+
+  if (bad)
+    console.log(
+      `\nInstagram draws its own controls over those areas. Move the element in\n` +
+        `src/series/what-prints/Composition.tsx, or shrink it.`,
+    );
+  process.exit(bad ? 1 : 0);
+};
+
+main();

package/scripts/custom-fonts.ts

@@ -0,0 +1,114 @@
+/**
+ * Fonts the user uploaded, made usable by the renderer.
+ *
+ * A font file is arbitrary binary handed to a browser's font parser, and it
+ * arrives from an upload form. So it is checked rather than trusted:
+ *
+ *  - the magic bytes must actually be a font (the browser's reported content
+ *    type is worthless here — .woff2 routinely uploads as octet-stream)
+ *  - it's fetched to disk once and rendered from a local file, so a render
+ *    never waits on the network mid-frame
+ *  - the family name is quoted into a CSS stack, so anything that could close
+ *    a declaration is rejected upstream in addBrandFont
+ *
+ * A file that fails any of that is skipped with a warning. One bad font must
+ * not take down a render that would otherwise be fine.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+const ROOT = join(__dirname, "..");
+const DIR = join(ROOT, "public/fonts/custom");
+
+export type CustomFont = { family: string; url: string };
+export type ResolvedFont = { family: string; file: string; format: string };
+
+/**
+ * Font container signatures.
+ *
+ * TrueType is 0x00010000, and "true"/"ttcf" are the Apple variants. Anything
+ * else — a renamed zip, an image, a script — is not a font and is dropped.
+ */
+const sniff = (buf: Buffer): string | null => {
+  const tag = buf.subarray(0, 4).toString("latin1");
+  if (tag === "wOF2") return "woff2";
+  if (tag === "wOFF") return "woff";
+  if (tag === "OTTO") return "otf";
+  if (tag === "true" || tag === "ttcf") return "ttf";
+  if (buf.readUInt32BE(0) === 0x00010000) return "ttf";
+  return null;
+};
+
+const safeName = (family: string) =>
+  family.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+
+/**
+ * Download and verify each font, returning the ones that are usable.
+ * Cached on disk by family + extension, so repeat renders don't refetch.
+ */
+export const resolveCustomFonts = async (
+  fonts: CustomFont[],
+): Promise<ResolvedFont[]> => {
+  if (!fonts.length) return [];
+  mkdirSync(DIR, { recursive: true });
+  const out: ResolvedFont[] = [];
+
+  for (const f of fonts) {
+    if (!f.family || !/^https:\/\//.test(f.url)) continue;
+    const base = safeName(f.family);
+    if (!base) continue;
+
+    try {
+      const cached = ["woff2", "woff", "otf", "ttf"]
+        .map((ext) => ({ ext, p: join(DIR, `${base}.${ext}`) }))
+        .find(({ p }) => existsSync(p));
+
+      if (cached) {
+        out.push({
+          family: f.family,
+          file: `fonts/custom/${base}.${cached.ext}`,
+          format: cached.ext,
+        });
+        continue;
+      }
+
+      const res = await fetch(f.url);
+      if (!res.ok) throw new Error(`download failed: ${res.status}`);
+      const buf = Buffer.from(await res.arrayBuffer());
+
+      const format = sniff(buf);
+      if (!format) {
+        console.warn(`  ! "${f.family}" isn't a font file — skipped`);
+        continue;
+      }
+
+      const file = join(DIR, `${base}.${format}`);
+      writeFileSync(file, buf);
+      out.push({
+        family: f.family,
+        file: `fonts/custom/${base}.${format}`,
+        format,
+      });
+    } catch (e) {
+      console.warn(
+        `  ! "${f.family}" skipped (${e instanceof Error ? e.message : e})`,
+      );
+    }
+  }
+  return out;
+};
+
+/** What a verified font is called on disk, for the @font-face src. */
+export const fontFaceCss = (
+  fonts: ResolvedFont[],
+  staticFileUrl: (p: string) => string,
+) =>
+  fonts
+    .map(
+      (f) => `@font-face{font-family:"${f.family}";src:url("${staticFileUrl(
+        f.file,
+      )}") format("${f.format}");font-display:block;}`,
+    )
+    .join("\n");
+
+export { readFileSync };

package/scripts/export.sh

@@ -0,0 +1,31 @@
+#!/bin/bash
+# Copy a rendered MP4 (and its caption, if present) to
+# ~/Desktop/Automate Editing/exports/ via Finder (TCC workaround).
+# Usage: scripts/export.sh out/what-prints-001.mp4
+set -euo pipefail
+
+FILE="${1:?usage: export.sh <rendered.mp4>}"
+FILE="$(cd "$(dirname "$FILE")" && pwd)/$(basename "$FILE")"
+CAPTION="${FILE%.mp4}.caption.txt"
+
+osascript >/dev/null <<EOF
+tell application "Finder"
+  set base to folder "Automate Editing" of desktop
+  if not (exists folder "exports" of base) then
+    make new folder at base with properties {name:"exports"}
+  end if
+  set dest to folder "exports" of base
+  duplicate (POSIX file "$FILE" as alias) to dest with replacing
+end tell
+EOF
+
+if [ -f "$CAPTION" ]; then
+  osascript >/dev/null <<EOF
+tell application "Finder"
+  set dest to folder "exports" of folder "Automate Editing" of desktop
+  duplicate (POSIX file "$CAPTION" as alias) to dest with replacing
+end tell
+EOF
+fi
+
+echo "Exported $(basename "$FILE") to Desktop/Automate Editing/exports/"

package/scripts/field-images.ts

@@ -0,0 +1,93 @@
+/**
+ * Photos a series asks for, fetched to disk before anything renders.
+ *
+ * Templates are forbidden from containing remote URLs, and that rule stays:
+ * a render that pauses mid-frame waiting on someone's CDN is a render that
+ * can hang for minutes or produce a frame with a hole in it. Instead the
+ * worker downloads the picture first and substitutes a LOCAL path, so by the
+ * time Chrome sees the markup the file is already on the disk beside it.
+ *
+ * The bytes are sniffed for the same reason uploaded fonts are: this is a file
+ * from an upload form being handed to a browser's image decoder.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { join } from "node:path";
+
+const ROOT = join(__dirname, "..");
+const DIR = join(ROOT, "public/assets/field-images");
+
+/** Container signatures for the formats the upload form accepts. */
+const sniff = (buf: Buffer): string | null => {
+  if (buf.length > 8 && buf.subarray(0, 8).toString("latin1") === "\x89PNG\r\n\x1a\n") {
+    return "png";
+  }
+  if (buf.length > 3 && buf[0] === 0xff && buf[1] === 0xd8 && buf[2] === 0xff) {
+    return "jpg";
+  }
+  if (
+    buf.length > 12 &&
+    buf.subarray(0, 4).toString("latin1") === "RIFF" &&
+    buf.subarray(8, 12).toString("latin1") === "WEBP"
+  ) {
+    return "webp";
+  }
+  return null;
+};
+
+/**
+ * Download one image and return its path under public/, or null if it isn't a
+ * usable picture. Cached by URL hash so repeat renders don't refetch.
+ */
+export const fetchFieldImage = async (url: string): Promise<string | null> => {
+  if (!/^https:\/\//.test(url)) return null;
+  mkdirSync(DIR, { recursive: true });
+
+  const key = createHash("sha1").update(url).digest("hex").slice(0, 16);
+  for (const ext of ["png", "jpg", "webp"]) {
+    if (existsSync(join(DIR, `${key}.${ext}`))) {
+      return `assets/field-images/${key}.${ext}`;
+    }
+  }
+
+  try {
+    const res = await fetch(url);
+    if (!res.ok) throw new Error(`download failed: ${res.status}`);
+    const buf = Buffer.from(await res.arrayBuffer());
+    const ext = sniff(buf);
+    if (!ext) {
+      console.warn("  ! an uploaded photo isn't an image file — skipped");
+      return null;
+    }
+    writeFileSync(join(DIR, `${key}.${ext}`), buf);
+    return `assets/field-images/${key}.${ext}`;
+  } catch (e) {
+    console.warn(
+      `  ! photo skipped (${e instanceof Error ? e.message : e})`,
+    );
+    return null;
+  }
+};
+
+/**
+ * Replace every image-typed field's URL with a local path.
+ *
+ * Fields that aren't images pass through untouched, and an image that fails to
+ * download becomes an empty string — a template with a missing picture still
+ * renders, which beats failing the whole episode over one asset.
+ */
+export const resolveFieldImages = async (
+  values: Record<string, string>,
+  imageKeys: string[],
+): Promise<Record<string, string>> => {
+  if (!imageKeys.length) return values;
+  const out = { ...values };
+  for (const key of imageKeys) {
+    const url = values[key];
+    if (!url) continue;
+    out[key] = (await fetchFieldImage(url)) ?? "";
+  }
+  return out;
+};
+
+export { readFileSync };

package/scripts/ig-probe.ts

@@ -0,0 +1,83 @@
+/**
+ * Read-only probe: can the Instagram tokens Erin already has read post insights?
+ *
+ * Checks the token identity, lists recent media, and tries to pull per-post
+ * insights for one item. Prints no secrets — only lengths and API responses.
+ *
+ *   npx tsx scripts/ig-probe.ts
+ */
+import { readFileSync } from "node:fs";
+
+const ENV_FILES = [
+  `${process.env.HOME}/code/ig-auto-dm/.env`,
+  `${process.env.HOME}/code/crossposter/.env`,
+];
+
+const loadEnv = (file: string) => {
+  const env: Record<string, string> = {};
+  for (const line of readFileSync(file, "utf8").split("\n")) {
+    const m = line.match(/^\s*([A-Z0-9_]+)\s*=\s*(.*)$/);
+    if (m) env[m[1]] = m[2].replace(/^["']|["']$/g, "").trim();
+  }
+  return env;
+};
+
+const get = async (url: string) => {
+  const r = await fetch(url);
+  const body = (await r.json()) as unknown;
+  return { status: r.status, body };
+};
+
+const show = (label: string, v: unknown) =>
+  console.log(`  ${label}: ${JSON.stringify(v).slice(0, 500)}`);
+
+const probe = async (file: string) => {
+  console.log(`\n=== ${file.split("/").slice(-2).join("/")}`);
+  let env: Record<string, string>;
+  try {
+    env = loadEnv(file);
+  } catch {
+    console.log("  unreadable / missing");
+    return;
+  }
+
+  const token = env.IG_ACCESS_TOKEN;
+  const userId = env.IG_USER_ID;
+  console.log(
+    `  token: ${token ? `present (${token.length} chars)` : "MISSING"}   user id: ${userId ?? "MISSING"}`,
+  );
+  if (!token) return;
+
+  // Who is this token for, and is it still valid?
+  const me = await get(
+    `https://graph.instagram.com/v21.0/me?fields=id,username,account_type,media_count&access_token=${token}`,
+  );
+  show(`me [${me.status}]`, me.body);
+  if (me.status !== 200) return;
+
+  // Recent posts.
+  const media = await get(
+    `https://graph.instagram.com/v21.0/me/media?fields=id,caption,media_type,media_product_type,timestamp,permalink,like_count,comments_count&limit=5&access_token=${token}`,
+  );
+  const items = (media.body as { data?: Record<string, unknown>[] }).data ?? [];
+  console.log(`  media [${media.status}]: ${items.length} returned`);
+  for (const m of items.slice(0, 3))
+    console.log(
+      `    ${m.timestamp} ${m.media_type}/${m.media_product_type} likes=${m.like_count} comments=${m.comments_count} ${String(m.caption ?? "").slice(0, 60).replace(/\n/g, " ")}`,
+    );
+  if (!items.length) return;
+
+  // The one that actually matters: per-post insights.
+  const id = items[0].id as string;
+  const metrics = "reach,saved,shares,total_interactions,views";
+  const ins = await get(
+    `https://graph.instagram.com/v21.0/${id}/insights?metric=${metrics}&access_token=${token}`,
+  );
+  show(`insights [${ins.status}]`, ins.body);
+};
+
+const main = async () => {
+  for (const f of ENV_FILES) await probe(f);
+};
+
+main();

package/scripts/ig-sync.ts

@@ -0,0 +1,204 @@
+/**
+ * Pull Instagram post performance into episodes/performance.json.
+ *
+ * Two passes so we don't burn the insights rate limit on unrelated posts:
+ *   1. page through all media (cheap, captions + likes + comments)
+ *   2. fetch per-post insights only for posts that look like series episodes
+ *
+ *   npx tsx scripts/ig-sync.ts            # refresh media, insights for matches
+ *   npx tsx scripts/ig-sync.ts --all      # insights for every reel
+ *
+ * Reads IG_ACCESS_TOKEN from ~/code/crossposter/.env. Read-only against the API.
+ */
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+
+const ROOT = join(import.meta.dirname, "..");
+const OUT = join(ROOT, "episodes/performance.json");
+/**
+ * Where the Instagram token lives.
+ *
+ * IG_ACCESS_TOKEN wins; otherwise this falls back to the crossposter checkout,
+ * which is where it happens to live on the machine this was written on. That
+ * fallback is a convenience, not a requirement — anyone else sets the env var.
+ */
+const ENV = process.env.IG_TOKEN_FILE ?? `${process.env.HOME}/code/crossposter/.env`;
+
+export type Post = {
+  id: string;
+  caption: string;
+  timestamp: string;
+  permalink: string;
+  mediaType: string;
+  productType: string;
+  likes: number;
+  comments: number;
+  insights?: Record<string, number>;
+};
+
+const token = () => {
+  if (process.env.IG_ACCESS_TOKEN) return process.env.IG_ACCESS_TOKEN;
+  if (!existsSync(ENV)) {
+    throw new Error(
+      `No Instagram token. Set IG_ACCESS_TOKEN, or point IG_TOKEN_FILE at a file containing it (looked in ${ENV}).`,
+    );
+  }
+  const m = readFileSync(ENV, "utf8").match(/^\s*IG_ACCESS_TOKEN\s*=\s*(.*)$/m);
+  if (!m) throw new Error(`no IG_ACCESS_TOKEN in ${ENV}`);
+  return m[1].replace(/^["']|["']$/g, "").trim();
+};
+
+const api = async <T>(url: string): Promise<T> => {
+  const r = await fetch(url);
+  const body = (await r.json()) as T & { error?: { message: string } };
+  if (body.error) throw new Error(body.error.message);
+  return body;
+};
+
+const fetchAllMedia = async (tok: string) => {
+  const fields =
+    "id,caption,media_type,media_product_type,timestamp,permalink,like_count,comments_count";
+  let url = `https://graph.instagram.com/v21.0/me/media?fields=${fields}&limit=100&access_token=${tok}`;
+  const posts: Post[] = [];
+  while (url) {
+    const page = await api<{
+      data: Record<string, unknown>[];
+      paging?: { next?: string };
+    }>(url);
+    for (const m of page.data)
+      posts.push({
+        id: m.id as string,
+        caption: (m.caption as string) ?? "",
+        timestamp: m.timestamp as string,
+        permalink: m.permalink as string,
+        mediaType: m.media_type as string,
+        productType: (m.media_product_type as string) ?? "",
+        likes: (m.like_count as number) ?? 0,
+        comments: (m.comments_count as number) ?? 0,
+      });
+    url = page.paging?.next ?? "";
+  }
+  return posts;
+};
+
+/** Reels report a different metric set than feed posts; ask for both shapes. */
+const fetchInsights = async (tok: string, post: Post) => {
+  const metrics =
+    post.productType === "REELS"
+      ? "reach,saved,shares,total_interactions,views,comments,likes"
+      : "reach,saved,shares,total_interactions,views";
+  try {
+    const res = await api<{
+      data: { name: string; values: { value: number }[] }[];
+    }>(
+      `https://graph.instagram.com/v21.0/${post.id}/insights?metric=${metrics}&access_token=${tok}`,
+    );
+    return Object.fromEntries(
+      res.data.map((d) => [d.name, d.values[0]?.value ?? 0]),
+    );
+  } catch (e) {
+    console.warn(`  ! insights failed for ${post.id}: ${(e as Error).message}`);
+    return undefined;
+  }
+};
+
+/** Captions that read like a code-quiz episode. */
+export const isSeriesPost = (p: Post) =>
+  /what (does this |will this )?print|what prints|guess the output|\bpython\b.*\?|comment your answer/i.test(
+    p.caption,
+  );
+
+/** Captions minus hashtags, punctuation and case — enough to match a post to a card. */
+const captionKey = (s: string) =>
+  s
+    .replace(/#\w+/g, "")
+    .toLowerCase()
+    .replace(/[^a-z0-9 ]/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+
+type Episode = {
+  card: string;
+  name: string;
+  caption: string | null;
+  permalink?: string;
+  postedAt?: string;
+  metrics?: Record<string, number>;
+};
+
+/**
+ * Attach each published post back to the card it came from. We write the
+ * captions, so a card's caption appears verbatim on its post — that's the join
+ * key. Anything Erin rewrote by hand before posting simply won't match.
+ */
+const linkEpisodes = (posts: Post[]) => {
+  const file = join(ROOT, "episodes/index.json");
+  const index = JSON.parse(readFileSync(file, "utf8")) as Episode[];
+  let linked = 0;
+
+  for (const e of index) {
+    // An explicit permalink wins — that's how episodes posted before we wrote
+    // their captions, or captions Erin rewrote by hand, get attached.
+    const key = e.caption ? captionKey(e.caption) : "";
+    const hit = e.permalink
+      ? posts.find((p) => p.permalink === e.permalink)
+      : key.length >= 20
+        ? posts.find((p) => {
+            const pk = captionKey(p.caption);
+            return pk.includes(key) || key.includes(pk);
+          })
+        : undefined;
+    if (!hit) continue;
+
+    e.permalink = hit.permalink;
+    e.postedAt = hit.timestamp;
+    e.metrics = {
+      likes: hit.likes,
+      comments: hit.comments,
+      ...(hit.insights ?? {}),
+    };
+    linked++;
+  }
+
+  writeFileSync(file, JSON.stringify(index, null, 2) + "\n");
+  console.log(`linked ${linked} cards to published posts`);
+};
+
+const main = async () => {
+  const tok = token();
+  const all = await fetchAllMedia(tok);
+  console.log(`fetched ${all.length} posts`);
+
+  const wantAll = process.argv.includes("--all");
+  const since = process.argv
+    .find((a) => a.startsWith("--since="))
+    ?.split("=")[1];
+  const targets = all.filter(
+    (p) =>
+      (wantAll && p.productType === "REELS") ||
+      (since ? p.timestamp >= since : false) ||
+      isSeriesPost(p),
+  );
+  console.log(`fetching insights for ${targets.length}`);
+
+  // Keep insights we already pulled so re-runs stay cheap.
+  const prev: Post[] = existsSync(OUT)
+    ? (JSON.parse(readFileSync(OUT, "utf8")) as Post[])
+    : [];
+  const cached = new Map(prev.filter((p) => p.insights).map((p) => [p.id, p]));
+
+  // Carry every insight we've ever fetched onto the fresh media list first —
+  // otherwise a narrow run would throw away earlier, wider ones.
+  for (const p of all) {
+    const hit = cached.get(p.id);
+    if (hit?.insights) p.insights = hit.insights;
+  }
+  for (const p of targets)
+    if (!p.insights) p.insights = await fetchInsights(tok, p);
+
+  writeFileSync(OUT, JSON.stringify(all, null, 2) + "\n");
+  console.log(`wrote ${OUT}`);
+  linkEpisodes(all);
+};
+
+if (process.argv[1]?.endsWith("ig-sync.ts")) main();