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

package/src/parse-instagram-post.ts

@@ -3,7 +3,11 @@ const INSTAGRAM_POST_RE =
 
 import {
   extractOwnerUsername,
-  fetchProfileDisplayUrl,
+  fetchProfilePostNode,
+  normalizeInstagramHandle,
+  type InstagramProfileCache,
+  type ProfilePostNode,
+  type ProfilePostNodeResult,
 } from "./instagram-profile-image.js";
 import { scoreInstagramImageUrl } from "./instagram-image-url.js";
 
@@ -186,6 +190,11 @@ function extractMetaContent(html: string, property: string): string | undefined
   return undefined;
 }
 
+/**
+ * Warm-up request kept for the diagnostic scripts. Not used in the convert
+ * flow: anonymous instagram.com page loads trip the rate limiter, and fetch()
+ * discards the cookies anyway.
+ */
 async function primeInstagramSession(
   fetchFn: (url: string, init?: RequestInit) => Promise<Response>,
 ): Promise<void> {
@@ -280,10 +289,12 @@ export type FetchedInstagramPost = {
   postUrl: string;
   caption: string;
   displayUrl?: string;
+  accessibilityCaption?: string;
+  likes: number;
   isVideo: boolean;
   /** Shown in admin when no usable thumbnail could be resolved. */
   imageNotice?: string;
-  /** Image bytes downloaded in the same session as the post page (for media upload). */
+  /** Image bytes downloaded during convert (for media upload). */
   imageBytes?: ArrayBuffer;
   imageContentType?: string;
 };
@@ -291,8 +302,54 @@ export type FetchedInstagramPost = {
 export type FetchInstagramPostOptions = {
   /** Override owner handle for web_profile_info lookup (same as brand-bootstrap handle). */
   instagramHandle?: string;
+  /** Profile payload cache (24h TTL, stale fallback on 429) — back with ctx.kv. */
+  profileCache?: InstagramProfileCache;
 };
 
+function imageNoticeFromProfileResult(
+  result: ProfilePostNodeResult,
+): string | undefined {
+  if (result.node?.displayUrl) return undefined;
+  if (result.rateLimited) {
+    return "Instagram rate-limited the profile API (HTTP 429). The recipe was parsed without a featured image — upload one manually, or try Convert again in a few minutes.";
+  }
+  if (result.shortcodeMissing) {
+    return "This post was not found in the latest profile grid (Instagram only returns ~12 posts). Import without a featured image and upload one manually.";
+  }
+  return undefined;
+}
+
+async function postFromProfileNode(
+  fetchFn: (url: string, init?: RequestInit) => Promise<Response>,
+  node: ProfilePostNode,
+  canonicalUrl: string,
+): Promise<FetchedInstagramPost> {
+  let imageBytes: ArrayBuffer | undefined;
+  let imageContentType: string | undefined;
+
+  if (node.displayUrl) {
+    const downloaded = await downloadPostImage(
+      fetchFn,
+      node.displayUrl,
+      canonicalUrl,
+    );
+    imageBytes = downloaded?.bytes;
+    imageContentType = downloaded?.contentType;
+  }
+
+  return {
+    shortcode: node.shortcode,
+    postUrl: canonicalUrl,
+    caption: node.caption,
+    displayUrl: node.displayUrl,
+    accessibilityCaption: node.accessibilityCaption,
+    likes: node.likes,
+    isVideo: node.isVideo,
+    imageBytes,
+    imageContentType,
+  };
+}
+
 export async function fetchInstagramPost(
   postUrl: string,
   fetchFn: (url: string, init?: RequestInit) => Promise<Response>,
@@ -301,8 +358,29 @@ export async function fetchInstagramPost(
   const { shortcode } = parseInstagramPostUrl(postUrl);
   const canonicalUrl = `https://www.instagram.com/p/${shortcode}/`;
 
-  await primeInstagramSession(fetchFn);
+  // Profile-API-first, like init-brand-resources brand-bootstrap: a single
+  // (cached) web_profile_info request supplies caption, display_url, and
+  // is_video. Anonymous HTML page loads are what trip Instagram's rate
+  // limiter, so they are reserved for the fallback below.
+  const configuredHandle = options.instagramHandle
+    ? normalizeInstagramHandle(options.instagramHandle)
+    : undefined;
+  let profileResult: ProfilePostNodeResult | undefined;
 
+  if (configuredHandle) {
+    profileResult = await fetchProfilePostNode(
+      fetchFn,
+      configuredHandle,
+      shortcode,
+      options.profileCache,
+    );
+    if (profileResult.node?.caption.trim()) {
+      return postFromProfileNode(fetchFn, profileResult.node, canonicalUrl);
+    }
+  }
+
+  // Fallback: scrape the post page (no handle configured, the post is older
+  // than the latest profile grid, or the grid caption was empty).
   const res = await fetchFn(canonicalUrl, {
     method: "GET",
     redirect: "follow",
@@ -332,31 +410,25 @@ export async function fetchInstagramPost(
     /"media_type":2[,}]/i.test(html);
 
   const cookieHeader = cookieHeaderFromResponse(res);
-  const ownerHandle =
-    options.instagramHandle ?? extractOwnerUsername(html);
+  const ownerHandle = extractOwnerUsername(html);
 
-  let displayUrl: string | undefined;
-  let imageNotice: string | undefined;
-
-  // Same image source as init-brand-resources: web_profile_info → node.display_url
-  if (ownerHandle) {
-    const profile = await fetchProfileDisplayUrl(
+  // Same image source as init-brand-resources: web_profile_info → node.display_url.
+  // Skip the lookup when the configured handle already answered for this owner.
+  if (ownerHandle && ownerHandle !== configuredHandle) {
+    profileResult = await fetchProfilePostNode(
       fetchFn,
       ownerHandle,
       shortcode,
+      options.profileCache,
     );
-    displayUrl = profile.url;
-    if (!displayUrl) {
-      if (profile.rateLimited) {
-        imageNotice =
-          "Instagram rate-limited the profile API (HTTP 429). The recipe was parsed without a featured image — upload one manually, or try Convert again in a few minutes.";
-      } else if (profile.shortcodeMissing) {
-        imageNotice =
-          "This post was not found in the latest profile grid (Instagram only returns ~12 posts). Import without a featured image and upload one manually.";
-      }
-    }
   }
 
+  const node = profileResult?.node;
+  const displayUrl = node?.displayUrl;
+  const imageNotice = profileResult
+    ? imageNoticeFromProfileResult(profileResult)
+    : undefined;
+
   let imageBytes: ArrayBuffer | undefined;
   let imageContentType: string | undefined;
   if (displayUrl) {
@@ -373,8 +445,10 @@ export async function fetchInstagramPost(
   return {
     shortcode,
     postUrl: canonicalUrl,
-    caption,
+    caption: caption || node?.caption || "",
     displayUrl,
+    accessibilityCaption: node?.accessibilityCaption,
+    likes: node?.likes ?? 0,
     isVideo,
     imageNotice,
     imageBytes,

package/src/sandbox-entry.ts

@@ -2,31 +2,52 @@ import type { PluginContext } from "emdash";
 import { z } from "astro/zod";
 
 import {
+  bulkPreviewBlocks,
+  bulkResultBlocks,
   errorBlocks,
   importFormBlocks,
+  pageBlocks,
   previewBlocks,
+  type BulkCandidate,
 } from "./admin-blocks.js";
 import {
+  buildBulkRecipesFromPosts,
   buildParsedRecipeFromPost,
   buildParsedRecipeFromPostLenient,
+  type InstagramPostForRecipes,
 } from "./instagram-recipes.js";
 import {
   fetchInstagramPost,
   instagramBrowserUserAgent,
   parseInstagramPostUrl,
 } from "./parse-instagram-post.js";
+import {
+  fetchProfileGrid,
+  normalizeInstagramHandle,
+  type CachedInstagramProfile,
+  type InstagramProfileCache,
+  type ProfilePostNode,
+} from "./instagram-profile-image.js";
 import { recipeToPostWriteData } from "./recipe-content.js";
 
 const DEFAULT_COLLECTION = "posts";
 const PARSE_CACHE_PREFIX = "parse:";
 const IMPORT_MAP_PREFIX = "imported:";
+const PROFILE_CACHE_PREFIX = "igprofile:";
+
+/** Delay between draft creations so per-post image downloads stay polite. */
+const BULK_CREATE_DELAY_MS = 600;
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 
 type AdminInteraction = {
   type: string;
   page?: string;
   action_id?: string;
   block_id?: string;
-  values?: Record<string, string | boolean | number>;
+  values?: Record<string, string | boolean | number | string[]>;
   value?: unknown;
 };
 
@@ -49,6 +70,22 @@ async function httpFetch(ctx: PluginContext, url: string, init?: RequestInit) {
   return ctx.http.fetch(url, init);
 }
 
+/** Same role as brand-bootstrap's `.cache/instagram/` files, backed by KV. */
+function profileCacheForCtx(ctx: PluginContext): InstagramProfileCache {
+  return {
+    async get(handle) {
+      return (
+        (await ctx.kv.get<CachedInstagramProfile>(
+          `${PROFILE_CACHE_PREFIX}${handle}`,
+        )) ?? undefined
+      );
+    },
+    async set(handle, entry) {
+      await ctx.kv.set(`${PROFILE_CACHE_PREFIX}${handle}`, entry);
+    },
+  };
+}
+
 async function convertInstagramUrl(
   ctx: PluginContext,
   instagramUrl: string,
@@ -62,24 +99,20 @@ async function convertInstagramUrl(
   const instagramHandle = await ctx.kv.get<string>("config:instagram_handle");
   const post = await fetchInstagramPost(instagramUrl, fetchFn, {
     instagramHandle: instagramHandle ?? undefined,
+    profileCache: profileCacheForCtx(ctx),
   });
+  const postForRecipe = {
+    shortcode: post.shortcode,
+    caption: post.caption,
+    displayUrl: post.displayUrl,
+    accessibilityCaption: post.accessibilityCaption,
+    likes: post.likes,
+    isVideo: post.isVideo,
+    postUrl: post.postUrl,
+  };
   const recipe =
-    buildParsedRecipeFromPost({
-      shortcode: post.shortcode,
-      caption: post.caption,
-      displayUrl: post.displayUrl,
-      likes: 0,
-      isVideo: post.isVideo,
-      postUrl: post.postUrl,
-    }) ??
-    buildParsedRecipeFromPostLenient({
-      shortcode: post.shortcode,
-      caption: post.caption,
-      displayUrl: post.displayUrl,
-      likes: 0,
-      isVideo: post.isVideo,
-      postUrl: post.postUrl,
-    });
+    buildParsedRecipeFromPost(postForRecipe) ??
+    buildParsedRecipeFromPostLenient(postForRecipe);
 
   if (!recipe) {
     throw new Error(
@@ -229,6 +262,123 @@ async function createDraftFromRecipe(
   };
 }
 
+function nodeToPostForRecipes(node: ProfilePostNode): InstagramPostForRecipes {
+  return {
+    shortcode: node.shortcode,
+    caption: node.caption,
+    displayUrl: node.displayUrl,
+    accessibilityCaption: node.accessibilityCaption,
+    likes: node.likes,
+    isVideo: node.isVideo,
+    postUrl: `https://www.instagram.com/p/${node.shortcode}/`,
+  };
+}
+
+type ScanResult = {
+  handle: string;
+  candidates: BulkCandidate[];
+  scanned: number;
+  rateLimited?: boolean;
+  fromCache?: boolean;
+};
+
+/**
+ * One web_profile_info request → all recipe posts in the grid. Each parsed
+ * recipe is cached under the same `parse:<shortcode>` key the single-post flow
+ * uses, so `create-draft` / bulk-create can reuse it (and lazily download the
+ * featured image) without re-hitting the rate-limited profile API.
+ */
+async function scanProfileRecipes(
+  ctx: PluginContext,
+  handleInput: string,
+): Promise<ScanResult> {
+  const fallbackHandle =
+    (await ctx.kv.get<string>("config:instagram_handle")) ?? "";
+  const handle = normalizeInstagramHandle(handleInput || fallbackHandle);
+
+  const fetchFn = (input: string, init?: RequestInit) =>
+    httpFetch(ctx, input, init);
+  const grid = await fetchProfileGrid(fetchFn, handle, profileCacheForCtx(ctx));
+
+  const posts = [...grid.posts]
+    .sort((a, b) => b.likes - a.likes)
+    .map(nodeToPostForRecipes);
+  const recipes = buildBulkRecipesFromPosts(posts);
+
+  const candidates: BulkCandidate[] = [];
+  for (const recipe of recipes) {
+    await ctx.kv.set(parseCacheKey(recipe.source.shortcode), recipe);
+    const existing = await ctx.kv.get<string>(
+      importMapKey(recipe.source.shortcode),
+    );
+    candidates.push({ recipe, alreadyImported: Boolean(existing) });
+  }
+
+  return {
+    handle: grid.handle,
+    candidates,
+    scanned: grid.posts.length,
+    rateLimited: grid.rateLimited,
+    fromCache: grid.fromCache,
+  };
+}
+
+type BulkDraft = { shortcode: string; contentId: string; title: string };
+
+/**
+ * Create a draft for each shortcode, skipping any post already in the
+ * `imported:` map so bulk import is idempotent — re-scanning and creating
+ * again is a no-op for posts you already have. Pass `force` to re-import.
+ */
+async function createDraftsForShortcodes(
+  ctx: PluginContext,
+  shortcodes: string[],
+  options: { force?: boolean } = {},
+): Promise<{
+  created: BulkDraft[];
+  skipped: BulkDraft[];
+  failed: Array<{ shortcode: string; message: string }>;
+}> {
+  const created: BulkDraft[] = [];
+  const skipped: BulkDraft[] = [];
+  const failed: Array<{ shortcode: string; message: string }> = [];
+
+  for (const shortcode of shortcodes) {
+    if (!options.force) {
+      const existing = await ctx.kv.get<string>(importMapKey(shortcode));
+      if (existing) {
+        const recipe = await ctx.kv.get<
+          NonNullable<ReturnType<typeof buildParsedRecipeFromPost>>
+        >(parseCacheKey(shortcode));
+        skipped.push({
+          shortcode,
+          contentId: existing,
+          title: recipe?.title ?? shortcode,
+        });
+        continue;
+      }
+    }
+
+    // Throttle the per-draft image downloads to *.cdninstagram.com — only a
+    // gap between actual creates, not after cheap skips.
+    if (created.length + failed.length > 0) {
+      await sleep(BULK_CREATE_DELAY_MS);
+    }
+
+    try {
+      const { contentId, title } = await createDraftFromRecipe(ctx, shortcode);
+      created.push({ shortcode, contentId, title });
+    } catch (error) {
+      failed.push({
+        shortcode,
+        message: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
+  return { created, skipped, failed };
+}
+
 export default {
   hooks: {
     "plugin:install": {
@@ -269,12 +419,129 @@ export default {
       },
     },
 
+    "bulk-scan": {
+      input: z.object({
+        handle: z.string().min(1),
+      }),
+      handler: async (
+        routeCtx: { input: { handle: string } },
+        ctx: PluginContext,
+      ) => {
+        const result = await scanProfileRecipes(ctx, routeCtx.input.handle);
+        return { ok: true, ...result };
+      },
+    },
+
+    "bulk-create": {
+      input: z.object({
+        shortcodes: z.array(z.string().min(1)).min(1),
+      }),
+      handler: async (
+        routeCtx: { input: { shortcodes: string[] } },
+        ctx: PluginContext,
+      ) => {
+        const result = await createDraftsForShortcodes(
+          ctx,
+          routeCtx.input.shortcodes,
+        );
+        return { ok: true, ...result };
+      },
+    },
+
     admin: {
       handler: async (routeCtx: { input?: AdminInteraction }, ctx: PluginContext) => {
         const interaction = routeCtx.input ?? { type: "page_load" };
 
         if (interaction.type === "page_load") {
-          return { blocks: importFormBlocks() };
+          return { blocks: pageBlocks() };
+        }
+
+        const instagramHandle = String(
+          interaction.values?.instagram_handle ?? "",
+        ).trim();
+
+        if (
+          interaction.type === "form_submit" &&
+          interaction.action_id === "bulk_scan"
+        ) {
+          try {
+            const { handle, candidates, scanned, rateLimited, fromCache } =
+              await scanProfileRecipes(ctx, instagramHandle);
+            return {
+              blocks: bulkPreviewBlocks(handle, candidates, {
+                scanned,
+                rateLimited,
+                fromCache,
+              }),
+              toast: {
+                message: candidates.length
+                  ? `Found ${candidates.length} recipe(s)`
+                  : "No recipes found",
+                type: candidates.length ? "success" : "error",
+              },
+            };
+          } catch (error) {
+            const message =
+              error instanceof Error ? error.message : String(error);
+            return {
+              blocks: [
+                ...pageBlocks(),
+                {
+                  type: "banner",
+                  title: "Could not scan profile",
+                  description: message,
+                  variant: "error",
+                },
+              ],
+              toast: { message, type: "error" },
+            };
+          }
+        }
+
+        if (
+          interaction.type === "form_submit" &&
+          interaction.action_id === "bulk_create"
+        ) {
+          const raw = interaction.values?.bulk_select;
+          const shortcodes = Array.isArray(raw)
+            ? raw.map((s) => String(s).trim()).filter(Boolean)
+            : [];
+
+          if (shortcodes.length === 0) {
+            return {
+              blocks: pageBlocks(),
+              toast: { message: "Select at least one recipe", type: "error" },
+            };
+          }
+
+          try {
+            const result = await createDraftsForShortcodes(ctx, shortcodes);
+            const notes = [
+              result.skipped.length
+                ? `${result.skipped.length} skipped`
+                : "",
+              result.failed.length ? `${result.failed.length} failed` : "",
+            ].filter(Boolean);
+            return {
+              blocks: bulkResultBlocks(instagramHandle, result),
+              toast: {
+                message: `Created ${result.created.length} draft(s)${
+                  notes.length ? `, ${notes.join(", ")}` : ""
+                }`,
+                type:
+                  result.failed.length && !result.created.length
+                    ? "error"
+                    : "success",
+              },
+            };
+          } catch (error) {
+            const message =
+              error instanceof Error ? error.message : String(error);
+            return {
+              blocks: pageBlocks(),
+              toast: { message, type: "error" },
+            };
+          }
         }
 
         const instagramUrl = String(