@peristyle/emdash-plugin-instagram-to-recipe 0.1.0 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peristyle/emdash-plugin-instagram-to-recipe",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
   "description": "Import Instagram post URLs as recipe drafts in the EmDash admin",
   "publishConfig": {
@@ -21,11 +21,6 @@
     "dist",
     "src"
   ],
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "typecheck": "tsc --noEmit"
-  },
   "peerDependencies": {
     "astro": ">=6.0.0-beta.0",
     "emdash": "^0.14.0"
@@ -34,5 +29,13 @@
     "emdash": "^0.14.0",
     "tsup": "^8.0.0",
     "typescript": "^5.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "preversion": "pnpm typecheck",
+    "version": "pnpm build",
+    "postversion": "git push --follow-tags"
   }
-}
+}

package/src/admin-blocks.ts

@@ -30,6 +30,11 @@ export function importFormBlocks(initialUrl = ""): Block[] {
   ];
 }
 
+/** Landing view: single-post import on top, bulk profile import below. */
+export function pageBlocks(): Block[] {
+  return [...importFormBlocks(), { type: "divider" }, ...bulkFormBlocks()];
+}
+
 export function previewBlocks(
   recipe: ParsedInstagramRecipe,
   options?: { existingContentId?: string },
@@ -132,6 +137,158 @@ export function previewBlocks(
   return blocks;
 }
 
+export type BulkCandidate = {
+  recipe: ParsedInstagramRecipe;
+  alreadyImported: boolean;
+};
+
+export function bulkFormBlocks(initialHandle = ""): Block[] {
+  return [
+    {
+      type: "header",
+      text: "Bulk import from a profile",
+    },
+    {
+      type: "context",
+      text: "Enter a public Instagram handle. Its latest posts are scanned in a single request, and only captions that parse as recipes are listed for import — pick the ones to create.",
+    },
+    {
+      type: "form",
+      block_id: "bulk-form",
+      fields: [
+        {
+          type: "text_input",
+          action_id: "instagram_handle",
+          label: "Instagram handle",
+          placeholder: "@cookingwithashhhh",
+          initial_value: initialHandle,
+        },
+      ],
+      submit: { label: "Scan profile", action_id: "bulk_scan" },
+    },
+  ];
+}
+
+export function bulkPreviewBlocks(
+  handle: string,
+  candidates: BulkCandidate[],
+  meta: { scanned: number; rateLimited?: boolean; fromCache?: boolean } = {
+    scanned: 0,
+  },
+): Block[] {
+  const blocks: Block[] = [...bulkFormBlocks(handle), { type: "divider" }];
+
+  if (meta.rateLimited) {
+    blocks.push({
+      type: "banner",
+      title: "Instagram rate-limited the profile API",
+      description:
+        "Showing whatever could be recovered (possibly from cache). Try again in a few minutes for a full scan.",
+      variant: "alert",
+    });
+  }
+
+  if (candidates.length === 0) {
+    blocks.push({
+      type: "banner",
+      title: "No recipes found",
+      description: `Scanned ${meta.scanned} recent post(s) for @${handle} but none had a parseable recipe caption (ingredients + numbered steps). Use the single-post import above for an individual post.`,
+      variant: "default",
+    });
+    return blocks;
+  }
+
+  blocks.push({
+    type: "banner",
+    title: `${candidates.length} recipe${candidates.length === 1 ? "" : "s"} found`,
+    description: `Scanned ${meta.scanned} recent post(s) for @${handle}${meta.fromCache ? " (from cache)" : ""}. Already-imported posts are unchecked by default.`,
+    variant: "default",
+  });
+
+  const options = candidates.map((c) => ({
+    label: `${c.recipe.title} — ${c.recipe.source.likes} likes${
+      c.alreadyImported ? " (already imported)" : ""
+    }`,
+    value: c.recipe.source.shortcode,
+  }));
+
+  const initialSelected = candidates
+    .filter((c) => !c.alreadyImported)
+    .map((c) => c.recipe.source.shortcode);
+
+  blocks.push({
+    type: "form",
+    block_id: "bulk-select-form",
+    fields: [
+      {
+        type: "checkbox",
+        action_id: "bulk_select",
+        label: "Recipes to import",
+        options,
+        initial_value: initialSelected,
+      },
+    ],
+    submit: { label: "Create selected drafts", action_id: "bulk_create" },
+  });
+
+  for (const c of candidates) {
+    if (c.recipe.featured_image?.url) {
+      blocks.push({
+        type: "image",
+        url: c.recipe.featured_image.url,
+        alt: c.recipe.featured_image.alt,
+        title: c.recipe.title,
+      });
+    }
+  }
+
+  return blocks;
+}
+
+export function bulkResultBlocks(
+  handle: string,
+  result: {
+    created: Array<{ title: string }>;
+    skipped: Array<{ title: string }>;
+    failed: Array<{ shortcode: string; message: string }>;
+  },
+): Block[] {
+  const blocks: Block[] = [...bulkFormBlocks(handle), { type: "divider" }];
+
+  blocks.push({
+    type: "banner",
+    title: `Created ${result.created.length} draft${result.created.length === 1 ? "" : "s"}`,
+    description: result.created.length
+      ? `Saved: ${result.created.map((c) => c.title).join(", ")}. Open Posts in the admin to review and publish.`
+      : "No new drafts were created.",
+    variant: "default",
+  });
+
+  if (result.skipped.length > 0) {
+    blocks.push({
+      type: "banner",
+      title: `Skipped ${result.skipped.length} already imported`,
+      description: `Already in your library: ${result.skipped
+        .map((s) => s.title)
+        .join(", ")}.`,
+      variant: "default",
+    });
+  }
+
+  if (result.failed.length > 0) {
+    blocks.push({
+      type: "banner",
+      title: `${result.failed.length} failed`,
+      description: result.failed
+        .map((f) => `${f.shortcode}: ${f.message}`)
+        .join(" · "),
+      variant: "alert",
+    });
+  }
+
+  return blocks;
+}
+
 export function errorBlocks(message: string, initialUrl = ""): Block[] {
   return [
     ...importFormBlocks(initialUrl),

package/src/index.ts

@@ -1,5 +1,8 @@
 import type { PluginDescriptor } from "emdash";
 
+/** Replaced at build time by tsup `define` from package.json — single source of truth. */
+declare const __PLUGIN_VERSION__: string;
+
 export type InstagramToRecipePluginOptions = {
   /** Content collection slug for imported recipes (default: posts). */
   collection?: string;
@@ -15,7 +18,7 @@ export function instagramToRecipePlugin(
 ): PluginDescriptor<InstagramToRecipePluginOptions> {
   return {
     id: "peristyle-instagram-to-recipe",
-    version: "0.1.0",
+    version: __PLUGIN_VERSION__,
     format: "standard",
     entrypoint: "@peristyle/emdash-plugin-instagram-to-recipe/sandbox",
     options,

package/src/instagram-profile-image.ts

@@ -6,6 +6,12 @@ const BROWSER_UA =
 type TimelineNode = {
   shortcode?: string;
   display_url?: string;
+  is_video?: boolean;
+  accessibility_caption?: string;
+  edge_liked_by?: { count?: number };
+  edge_media_to_caption?: {
+    edges?: Array<{ node?: { text?: string } }>;
+  };
 };
 
 type WebProfileUser = {
@@ -37,22 +43,75 @@ export function extractOwnerUsername(html: string): string | undefined {
   return undefined;
 }
 
-/** Same field brand-bootstrap uses: node.display_url from the profile grid. */
-export function displayUrlFromProfileUser(
-  user: unknown,
-  shortcode: string,
-): string | undefined {
+/** Post data resolved from the profile grid — same fields brand-bootstrap maps. */
+export type ProfilePostNode = {
+  shortcode: string;
+  caption: string;
+  displayUrl?: string;
+  accessibilityCaption?: string;
+  likes: number;
+  isVideo: boolean;
+};
+
+/** Same shape brand-bootstrap persists under `.cache/instagram/<handle>.json`. */
+export type CachedInstagramProfile = {
+  fetchedAt: string;
+  handle: string;
+  httpStatus: number;
+  user: unknown;
+};
+
+/** Storage adapter so the sandbox can back the cache with ctx.kv. */
+export type InstagramProfileCache = {
+  get(handle: string): Promise<CachedInstagramProfile | undefined>;
+  set(handle: string, entry: CachedInstagramProfile): Promise<void>;
+};
+
+const PROFILE_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+
+export function isProfileCacheFresh(entry: CachedInstagramProfile): boolean {
+  const age = Date.now() - Date.parse(entry.fetchedAt);
+  return Number.isFinite(age) && age >= 0 && age <= PROFILE_CACHE_TTL_MS;
+}
+
+/** Map every post in the profile grid payload to a ProfilePostNode. */
+export function postsFromProfileUser(user: unknown): ProfilePostNode[] {
   const edges =
     (user as WebProfileUser)?.edge_owner_to_timeline_media?.edges ?? [];
+  const posts: ProfilePostNode[] = [];
 
   for (const edge of edges) {
     const node = edge.node;
-    if (node?.shortcode === shortcode && node.display_url) {
-      return node.display_url;
-    }
+    if (!node?.shortcode) continue;
+
+    const capEdges = node.edge_media_to_caption?.edges ?? [];
+    posts.push({
+      shortcode: node.shortcode,
+      caption: capEdges[0]?.node?.text?.trim() ?? "",
+      displayUrl: node.display_url,
+      accessibilityCaption: node.accessibility_caption,
+      likes: node.edge_liked_by?.count ?? 0,
+      isVideo: Boolean(node.is_video),
+    });
   }
 
-  return undefined;
+  return posts;
+}
+
+/** Find a post in the profile grid payload by shortcode. */
+export function postNodeFromProfileUser(
+  user: unknown,
+  shortcode: string,
+): ProfilePostNode | undefined {
+  return postsFromProfileUser(user).find((p) => p.shortcode === shortcode);
+}
+
+/** Same field brand-bootstrap uses: node.display_url from the profile grid. */
+export function displayUrlFromProfileUser(
+  user: unknown,
+  shortcode: string,
+): string | undefined {
+  return postNodeFromProfileUser(user, shortcode)?.displayUrl;
 }
 
 function profileApiHeaders(handle: string): HeadersInit {
@@ -68,13 +127,26 @@ function profileApiHeaders(handle: string): HeadersInit {
   };
 }
 
-const PROFILE_FETCH_RETRIES = 2;
-const PROFILE_RETRY_DELAY_MS = 2500;
+// Match brand-bootstrap: 3 retries with exponential backoff (2.5s, 5s, 10s).
+const PROFILE_FETCH_RETRIES = 3;
+const PROFILE_RETRY_BASE_DELAY_MS = 2500;
+
+function retryDelayMs(attempt: number): number {
+  return PROFILE_RETRY_BASE_DELAY_MS * Math.pow(2, attempt);
+}
 
 function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+export type ProfilePostNodeResult = {
+  node?: ProfilePostNode;
+  httpStatus?: number;
+  rateLimited?: boolean;
+  shortcodeMissing?: boolean;
+  fromCache?: boolean;
+};
+
 export type ProfileDisplayUrlResult = {
   url?: string;
   httpStatus?: number;
@@ -126,25 +198,72 @@ async function fetchProfileUserOnce(
   return { ok: true, user, httpStatus };
 }
 
-export async function fetchProfileDisplayUrl(
+async function cacheGet(
+  cache: InstagramProfileCache | undefined,
+  handle: string,
+): Promise<CachedInstagramProfile | undefined> {
+  try {
+    return await cache?.get(handle);
+  } catch {
+    return undefined;
+  }
+}
+
+async function cacheSet(
+  cache: InstagramProfileCache | undefined,
+  handle: string,
+  user: unknown,
+  httpStatus: number,
+): Promise<void> {
+  try {
+    await cache?.set(handle, {
+      fetchedAt: new Date().toISOString(),
+      handle,
+      httpStatus,
+      user,
+    });
+  } catch {
+    // Cache write failures must not break the import flow.
+  }
+}
+
+/**
+ * Fetch the post's grid node via web_profile_info, mirroring brand-bootstrap:
+ * fresh cache first, then live fetch with backoff, then stale cache on
+ * failure, then the curl cookie-jar fallback.
+ */
+export async function fetchProfilePostNode(
   fetchFn: (url: string, init?: RequestInit) => Promise<Response>,
   handle: string,
   shortcode: string,
-): Promise<ProfileDisplayUrlResult> {
+  cache?: InstagramProfileCache,
+): Promise<ProfilePostNodeResult> {
   const username = normalizeInstagramHandle(handle);
+
+  const cached = await cacheGet(cache, username);
+  if (cached && isProfileCacheFresh(cached)) {
+    const node = postNodeFromProfileUser(cached.user, shortcode);
+    // A fresh cache that lacks the shortcode may simply predate the post,
+    // so only short-circuit on a hit.
+    if (node) {
+      return { node, httpStatus: cached.httpStatus, fromCache: true };
+    }
+  }
+
   let lastHttpStatus: number | undefined;
   let rateLimited = false;
 
   for (let attempt = 0; attempt <= PROFILE_FETCH_RETRIES; attempt++) {
     if (attempt > 0) {
-      await sleep(PROFILE_RETRY_DELAY_MS * attempt);
+      await sleep(retryDelayMs(attempt - 1));
     }
 
     const result = await fetchProfileUserOnce(fetchFn, username);
     if (result.ok) {
-      const url = displayUrlFromProfileUser(result.user, shortcode);
-      if (url) {
-        return { url, httpStatus: result.httpStatus };
+      await cacheSet(cache, username, result.user, result.httpStatus);
+      const node = postNodeFromProfileUser(result.user, shortcode);
+      if (node) {
+        return { node, httpStatus: result.httpStatus };
       }
       return { httpStatus: result.httpStatus, shortcodeMissing: true };
     }
@@ -156,20 +275,29 @@ export async function fetchProfileDisplayUrl(
     if (!result.retryable) break;
   }
 
-  if (
-    typeof process !== "undefined" &&
-    process.versions?.node
-  ) {
+  // Stale cache beats no image — same trade-off brand-bootstrap makes on 429.
+  if (cached) {
+    const node = postNodeFromProfileUser(cached.user, shortcode);
+    if (node) {
+      return { node, httpStatus: cached.httpStatus, fromCache: true };
+    }
+  }
+
+  if (typeof process !== "undefined" && process.versions?.node) {
     try {
-      const { shouldTryInstagramCurlFallback, curlAvailable, fetchInstagramProfileViaCurl } =
-        await import("./instagram-curl-profile.js");
+      const {
+        shouldTryInstagramCurlFallback,
+        curlAvailable,
+        fetchInstagramProfileViaCurl,
+      } = await import("./instagram-curl-profile.js");
 
       if (shouldTryInstagramCurlFallback() && (await curlAvailable())) {
         const curlResult = await fetchInstagramProfileViaCurl(username);
         if (curlResult.ok) {
-          const url = displayUrlFromProfileUser(curlResult.user, shortcode);
-          if (url) {
-            return { url, httpStatus: curlResult.httpStatus };
+          await cacheSet(cache, username, curlResult.user, curlResult.httpStatus);
+          const node = postNodeFromProfileUser(curlResult.user, shortcode);
+          if (node) {
+            return { node, httpStatus: curlResult.httpStatus };
           }
           return {
             httpStatus: curlResult.httpStatus,
@@ -178,7 +306,7 @@ export async function fetchProfileDisplayUrl(
         }
       }
     } catch {
-      // Fall through.
+      // Sandbox without child_process — fall through.
     }
   }
 
@@ -188,3 +316,122 @@ export async function fetchProfileDisplayUrl(
     shortcodeMissing: false,
   };
 }
+
+export type ProfileGridResult = {
+  handle: string;
+  posts: ProfilePostNode[];
+  httpStatus?: number;
+  rateLimited?: boolean;
+  fromCache?: boolean;
+};
+
+/**
+ * Fetch the whole profile grid (~12 most recent posts) in a single
+ * web_profile_info request — the bulk-import counterpart to
+ * fetchProfilePostNode. Same cache → live-with-backoff → stale-cache → curl
+ * fallback chain, so a bulk scan costs at most one live API call per handle
+ * (and zero on a 24h cache hit).
+ */
+export async function fetchProfileGrid(
+  fetchFn: (url: string, init?: RequestInit) => Promise<Response>,
+  handle: string,
+  cache?: InstagramProfileCache,
+): Promise<ProfileGridResult> {
+  const username = normalizeInstagramHandle(handle);
+
+  const cached = await cacheGet(cache, username);
+  if (cached && isProfileCacheFresh(cached)) {
+    return {
+      handle: username,
+      posts: postsFromProfileUser(cached.user),
+      httpStatus: cached.httpStatus,
+      fromCache: true,
+    };
+  }
+
+  let lastHttpStatus: number | undefined;
+  let rateLimited = false;
+
+  for (let attempt = 0; attempt <= PROFILE_FETCH_RETRIES; attempt++) {
+    if (attempt > 0) {
+      await sleep(retryDelayMs(attempt - 1));
+    }
+
+    const result = await fetchProfileUserOnce(fetchFn, username);
+    if (result.ok) {
+      await cacheSet(cache, username, result.user, result.httpStatus);
+      return {
+        handle: username,
+        posts: postsFromProfileUser(result.user),
+        httpStatus: result.httpStatus,
+      };
+    }
+
+    lastHttpStatus = result.httpStatus;
+    if (result.httpStatus === 429 || result.httpStatus === 503) {
+      rateLimited = true;
+    }
+    if (!result.retryable) break;
+  }
+
+  // Stale cache beats no posts — same trade-off the single-post flow makes.
+  if (cached) {
+    return {
+      handle: username,
+      posts: postsFromProfileUser(cached.user),
+      httpStatus: cached.httpStatus,
+      fromCache: true,
+    };
+  }
+
+  if (typeof process !== "undefined" && process.versions?.node) {
+    try {
+      const {
+        shouldTryInstagramCurlFallback,
+        curlAvailable,
+        fetchInstagramProfileViaCurl,
+      } = await import("./instagram-curl-profile.js");
+
+      if (shouldTryInstagramCurlFallback() && (await curlAvailable())) {
+        const curlResult = await fetchInstagramProfileViaCurl(username);
+        if (curlResult.ok) {
+          await cacheSet(
+            cache,
+            username,
+            curlResult.user,
+            curlResult.httpStatus,
+          );
+          return {
+            handle: username,
+            posts: postsFromProfileUser(curlResult.user),
+            httpStatus: curlResult.httpStatus,
+          };
+        }
+      }
+    } catch {
+      // Sandbox without child_process — fall through.
+    }
+  }
+
+  return {
+    handle: username,
+    posts: [],
+    httpStatus: lastHttpStatus,
+    rateLimited,
+  };
+}
+
+export async function fetchProfileDisplayUrl(
+  fetchFn: (url: string, init?: RequestInit) => Promise<Response>,
+  handle: string,
+  shortcode: string,
+  cache?: InstagramProfileCache,
+): Promise<ProfileDisplayUrlResult> {
+  const result = await fetchProfilePostNode(fetchFn, handle, shortcode, cache);
+  return {
+    url: result.node?.displayUrl,
+    httpStatus: result.httpStatus,
+    rateLimited: result.rateLimited,
+    shortcodeMissing: result.shortcodeMissing,
+  };
+}

package/src/instagram-recipes.ts

@@ -213,6 +213,40 @@ export function buildParsedRecipeFromPost(
   return recipe;
 }
 
+/**
+ * Build recipes for every post whose caption is an actual recipe (strict
+ * parse only — bulk import favours precision over recall so non-recipe posts
+ * like grocery hauls are dropped). Slugs and image filenames are de-duplicated
+ * across the batch.
+ */
+export function buildBulkRecipesFromPosts(
+  posts: InstagramPostForRecipes[],
+): ParsedInstagramRecipe[] {
+  const recipes: ParsedInstagramRecipe[] = [];
+  const usedSlugs = new Set<string>();
+
+  for (const post of posts) {
+    const recipe = buildParsedRecipeFromPost(post);
+    if (!recipe) continue;
+
+    let slug = recipe.suggested_slug;
+    let n = 2;
+    while (usedSlugs.has(slug)) {
+      slug = `${recipe.suggested_slug}-${n}`;
+      n++;
+    }
+    usedSlugs.add(slug);
+    recipe.suggested_slug = slug;
+    if (recipe.featured_image) {
+      recipe.featured_image.filename = imageFilenameForSlug(slug);
+    }
+
+    recipes.push(recipe);
+  }
+
+  return recipes;
+}
+
 /** Looser parse when caption has steps/ingredients but fails strict recipe heuristics. */
 export function buildParsedRecipeFromPostLenient(
   post: InstagramPostForRecipes,