backend-manager 5.2.9 → 5.2.10

package/CHANGELOG.md

@@ -14,6 +14,18 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - `Fixed` for any bug fixes.
 - `Security` in case of vulnerabilities.
 
+# [5.2.10] - 2026-05-26
+
+### Added
+
+- **`POST /admin/post`: resize images at ingest.** Downloaded post images are now checked against `IMAGE_MAX_DIMENSION` (4096px on the long edge) in `src/manager/routes/admin/post/post.js` and re-encoded as progressive JPEG at `IMAGE_JPEG_QUALITY` (80) when oversized. Prevents downstream Jekyll/imagemin pipelines from stalling on huge sources (a real 16384×10576 source decoded to ~520MB raw and silently broke 4 StudyMonkey posts on production). `resizeImage`, `IMAGE_MAX_DIMENSION`, and `IMAGE_JPEG_QUALITY` are exported for tests. Adds `sharp` as a dependency.
+- **`test/routes/admin/post-resize-image.js`** — 7 unit tests covering the resize contract (pass-through under the limit, boundary at exact limit, landscape/portrait/square scaling, the 16384×10576 case, on-disk overwrite). No network, no auth, no GitHub.
+- **`test/routes/admin/create-post.js`**: extended `create-post-rewrites-body-images` to submit a 5000×3000 header image, plus new `verify-oversized-header-image-was-resized` step that fetches the committed image back from GitHub and asserts long edge ≤ 4096px.
+
+### Changed
+
+- **Dependency bumps**: `sharp` ^0.34.4 → ^0.34.5, `sanitize-html` ^2.17.3 → ^2.17.4 (auto-bumped at install).
+
 # [5.2.9] - 2026-05-25
 
 ### Added

package/CLAUDE.md

@@ -119,7 +119,7 @@ Deep references live in `docs/`. **Whenever you make a behavioral change, update
 
 ### Built-in Routes
 
-- [docs/admin-post-route.md](docs/admin-post-route.md) — `POST/PUT /admin/post` blog creation via GitHub (image extraction + `@post/` rewriting)
+- [docs/admin-post-route.md](docs/admin-post-route.md) — `POST/PUT /admin/post` blog creation via GitHub (image extraction + resize at ingest + `@post/` rewriting)
 - [docs/payment-system.md](docs/payment-system.md) — full payment pipeline: Intent → Webhook → On-Write → Transition; subscription model, statuses, `resolveSubscription()`, transition handlers, processor interface, product config, test processor
 - [docs/marketing-campaigns.md](docs/marketing-campaigns.md) — campaign CRUD routes, recurring campaigns, generator pipeline (newsletter), template-owned schemas, asset hosting, seed campaigns
 - [docs/consent.md](docs/consent.md) — marketing consent capture: canonical `consent.{legal,marketing}` user-doc shape, signup-form capture, account-page toggle, HMAC unsub link, SendGrid+Beehiiv webhook receivers, parent forwarder (`/marketing/webhook/forward`), migration script template

package/docs/admin-post-route.md

@@ -1,24 +1,46 @@
 # Admin Post Route
 
-The `POST /admin/post` route creates blog posts via GitHub's API. It handles image extraction, upload, and body rewriting.
+The `POST /admin/post` route creates blog posts via GitHub's API. It handles image extraction, resize, upload, and body rewriting.
 
 ## Image Processing Flow
 
 1. Receives markdown body with external image URLs (e.g., `![alt](https://images.unsplash.com/...)`)
 2. Extracts all `![alt](url)` patterns from the body using regex
-3. Downloads each image and uploads it to `src/assets/images/blog/post-{id}/` on GitHub
-4. **Rewrites the body** to replace external URLs with `@post/{filename}` format
-5. The `@post/` prefix is resolved at Jekyll build time by `jekyll-uj-powertools` to the full path
+3. Downloads each image to a tmp dir
+4. **Resizes** each image in place if its long edge exceeds `IMAGE_MAX_DIMENSION` (see below)
+5. Commits all images to `src/assets/images/blog/post-{id}/` on GitHub (single commit via Git Trees API)
+6. **Rewrites the body** to replace external URLs with `@post/{filename}` format
+7. The `@post/` prefix is resolved at Jekyll build time by `jekyll-uj-powertools` to the full path
+
+## Image resize
+
+Sources from guest-post submissions can be enormous (16384×10576 has been seen in the wild — ~520MB raw RGB). Sources that large stall downstream Jekyll/imagemin pipelines on the consumer site, which silently ship the site missing those images.
+
+To prevent this, every downloaded image is checked against `IMAGE_MAX_DIMENSION` (4096px on the long edge) and re-encoded as a progressive JPEG at `IMAGE_JPEG_QUALITY` (80) if it exceeds the limit. Images already at or below the limit pass through untouched.
+
+The resize happens in `downloadImage()` (after the `.jpg` extension check, before returning to the caller), so:
+- The base64 content that gets committed to GitHub is the resized version
+- The consumer repo never sees the giant source
+- Future downstream optimization (UJM imagemin, etc.) starts from a sane source size
+
+Constants live in `src/manager/routes/admin/post/post.js`:
+```js
+const IMAGE_MAX_DIMENSION = 4096;
+const IMAGE_JPEG_QUALITY = 80;
+```
+
+If these need to become configurable later, promote to `backend-manager-config.json` rather than env vars (deploy-environment-specific overrides aren't a real use case — the values are algorithm constants).
 
 ## Key Details
 
 - Image filenames are derived from `hyphenate(alt_text)` + downloaded extension
+- Only `.jpg` is accepted; other formats reject with a 400
 - Header image (`headerImageURL`) is uploaded but NOT rewritten in the body (it's in frontmatter)
 - Failed image downloads are skipped — the original external URL stays in the body
-- The `extractImages()` function returns a URL mapping used for body rewriting
+- All images + the post markdown are committed in a single commit via the Git Trees API
 
 ## Files
 
-- `src/manager/routes/admin/post/post.js` — POST handler (create)
-- `src/manager/routes/admin/post/put.js` — PUT handler (edit)
+- `src/manager/routes/admin/post/post.js` — POST handler (create), includes `downloadImage()` + `resizeImage()` helpers
+- `src/manager/routes/admin/post/put.js` — PUT handler (edit) — does NOT download images, just edits frontmatter/body in place
 - `src/manager/routes/admin/post/templates/post.html` — Post template

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backend-manager",
-  "version": "5.2.9",
+  "version": "5.2.10",
   "description": "Quick tools for developing Firebase functions",
   "main": "src/manager/index.js",
   "bin": {
@@ -49,18 +49,18 @@
     }
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.140",
-    "@anthropic-ai/sdk": "^0.95.2",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.152",
+    "@anthropic-ai/sdk": "^0.99.0",
     "@firebase/rules-unit-testing": "^5.0.1",
     "@google-cloud/firestore": "^7.11.6",
     "@google-cloud/pubsub": "^5.3.0",
     "@google-cloud/storage": "^7.19.0",
-    "@inquirer/prompts": "^8.4.3",
+    "@inquirer/prompts": "^8.5.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@octokit/rest": "^22.0.1",
     "@resvg/resvg-js": "^2.6.2",
     "@sendgrid/mail": "^8.1.6",
-    "@sentry/node": "^10.53.1",
+    "@sentry/node": "^10.54.0",
     "body-parser": "^2.2.2",
     "busboy": "^1.6.0",
     "chalk": "^5.6.2",
@@ -76,15 +76,16 @@
     "lodash": "^4.18.1",
     "lowdb": "^7.0.1",
     "mailchimp-api-v3": "^1.15.0",
-    "markdown-it": "^14.1.1",
+    "markdown-it": "^14.2.0",
     "mime-types": "^3.0.2",
-    "mjml": "^5.2.1",
+    "mjml": "^5.3.0",
     "moment": "^2.30.1",
     "nanoid": "^5.1.11",
     "node-powertools": "^3.0.0",
     "npm-api": "^1.0.1",
     "pushid": "^1.0.0",
-    "sanitize-html": "^2.17.3",
+    "sanitize-html": "^2.17.4",
+    "sharp": "^0.34.5",
     "stripe": "^22.1.1",
     "uid-generator": "^2.0.0",
     "uuid": "^14.0.0",
@@ -98,7 +99,7 @@
     "prepare-package": "^2.1.0"
   },
   "peerDependencies": {
-    "firebase-admin": "^13.9.0",
+    "firebase-admin": "^13.10.0",
     "firebase-functions": "^7.2.5"
   }
 }

package/src/manager/libraries/email/data/disposable-domains.json

@@ -3081,6 +3081,7 @@
   "mannawo.com",
   "mansiondev.com",
   "maohe.cloud",
+  "marineso.com",
   "mark-compressoren.ru",
   "marketlink.info",
   "markmurfin.com",

package/src/manager/routes/admin/post/post.js

@@ -17,6 +17,13 @@ const POST_TEMPLATE = jetpack.read(`${__dirname}/templates/post.html`);
 const IMAGE_PATH_SRC = `src/assets/images/blog/post-{id}/`;
 const IMAGE_REGEX = /(?:!\[(.*?)\]\((.*?)\))/img;
 
+// Max dimension (px) for downloaded post images on the long edge, and JPEG
+// re-encode quality. Sources above the max cause downstream Jekyll/imagemin
+// pipelines to stall on huge decodes (e.g. a 16384×10576 source decodes to
+// ~520MB raw), so resize at ingest time.
+const IMAGE_MAX_DIMENSION = 4096;
+const IMAGE_JPEG_QUALITY = 80;
+
 module.exports = async ({ assistant, Manager, user, settings, analytics }) => {
 
   // Require authentication
@@ -218,9 +225,47 @@ async function downloadImage(assistant, src, alt) {
     throw new Error(`Images must be .jpg (not ${result.ext})`);
   }
 
+  // Resize in place if the long edge exceeds IMAGE_MAX_DIMENSION
+  await resizeImage(assistant, result.path);
+
   return result;
 }
 
+// Helper: Resize image in place if the long edge exceeds IMAGE_MAX_DIMENSION.
+// Re-encodes as progressive JPEG at IMAGE_JPEG_QUALITY. Short-circuits when the
+// source is already within the limit.
+async function resizeImage(assistant, filepath) {
+  const sharp = assistant.Manager.require('sharp');
+
+  const meta = await sharp(filepath).metadata();
+  const longEdge = Math.max(meta.width, meta.height);
+
+  if (longEdge <= IMAGE_MAX_DIMENSION) {
+    assistant.log(`resizeImage(): No resize needed (${meta.width}x${meta.height})`);
+    return { resized: false, width: meta.width, height: meta.height };
+  }
+
+  // Resize to a buffer (cannot read+write the same path in one sharp pipeline)
+  const buffer = await sharp(filepath)
+    .resize({
+      width: IMAGE_MAX_DIMENSION,
+      height: IMAGE_MAX_DIMENSION,
+      fit: 'inside',
+      withoutEnlargement: true,
+    })
+    .jpeg({ quality: IMAGE_JPEG_QUALITY, progressive: true })
+    .toBuffer();
+
+  // Overwrite the file on disk
+  jetpack.write(filepath, buffer);
+
+  // Read the resized dimensions back for the log
+  const resizedMeta = await sharp(filepath).metadata();
+  assistant.log(`resizeImage(): Resized ${meta.width}x${meta.height} -> ${resizedMeta.width}x${resizedMeta.height} (max ${IMAGE_MAX_DIMENSION}px, q${IMAGE_JPEG_QUALITY})`);
+
+  return { resized: true, width: resizedMeta.width, height: resizedMeta.height };
+}
+
 // Helper: Commit all files (images + post) in a single commit using Git Trees API
 async function commitAll(assistant, octokit, settings, files) {
   const owner = settings.githubUser;
@@ -326,3 +371,8 @@ function formatClone(payload) {
   return payload;
 }
 
+// Expose helpers + constants for tests
+module.exports.resizeImage = resizeImage;
+module.exports.IMAGE_MAX_DIMENSION = IMAGE_MAX_DIMENSION;
+module.exports.IMAGE_JPEG_QUALITY = IMAGE_JPEG_QUALITY;
+

package/test/routes/admin/create-post.js

@@ -5,6 +5,9 @@
  * Requires admin/blogger role, GitHub API key, and repo_website config
  */
 const { Octokit } = require('@octokit/rest');
+const sharp = require('sharp');
+
+const { IMAGE_MAX_DIMENSION } = require('../../../src/manager/routes/admin/post/post');
 
 module.exports = {
   description: 'Admin create post on GitHub',
@@ -130,12 +133,15 @@ module.exports = {
 
         // Use a real public .jpg for the inline image
         const inlineImageURL = 'https://picsum.photos/id/10/200/200.jpg';
+        // Oversized header image (long edge 5000px > IMAGE_MAX_DIMENSION 4096px) to
+        // verify the resize step runs end-to-end and the committed file is clamped.
+        const headerImageURL = 'https://picsum.photos/id/1/5000/3000.jpg';
 
         const response = await http.post('admin/post', {
           title: 'BEM Test Create Post',
           url: 'bem-test-create-post',
           description: 'Test post created by BEM test suite to verify @post/ body rewriting.',
-          headerImageURL: 'https://picsum.photos/id/1/400/300.jpg',
+          headerImageURL: headerImageURL,
           body: `# BEM Test Create Post\n\nSome intro text.\n\n![Test inline image](${inlineImageURL})\n\nMore text after the image.`,
           postPath: 'guest',
         });
@@ -186,6 +192,53 @@ module.exports = {
       },
     },
 
+    {
+      name: 'verify-oversized-header-image-was-resized',
+      auth: 'admin',
+      timeout: 30000,
+      skip: !process.env.TEST_EXTENDED_MODE ? 'TEST_EXTENDED_MODE env var not set' : false,
+
+      async run({ assert, state }) {
+        if (!state.postId) {
+          return; // Previous test didn't run
+        }
+
+        const octokit = new Octokit({ auth: process.env.GITHUB_TOKEN });
+        const imageDir = `src/assets/images/blog/post-${state.postId}/`;
+
+        // List committed images and pick the header (matches the slugified URL "bem-test-create-post")
+        const { data: dirData } = await octokit.rest.repos.getContent({
+          owner: state.owner,
+          repo: state.repo,
+          path: imageDir,
+        });
+
+        const headerFile = dirData.find((f) => f.name === 'bem-test-create-post.jpg');
+        assert.ok(headerFile, 'Header image should be committed at expected slug');
+
+        // Fetch the raw bytes and read dimensions
+        const { data: blob } = await octokit.rest.git.getBlob({
+          owner: state.owner,
+          repo: state.repo,
+          file_sha: headerFile.sha,
+        });
+
+        const buffer = Buffer.from(blob.content, 'base64');
+        const meta = await sharp(buffer).metadata();
+
+        // The source we requested was 5000x3000 (over the 4096 limit).
+        // After resize, the long edge should be clamped to IMAGE_MAX_DIMENSION.
+        const longEdge = Math.max(meta.width, meta.height);
+        assert.ok(
+          longEdge <= IMAGE_MAX_DIMENSION,
+          `Committed header image long edge (${meta.width}x${meta.height}) should be <= IMAGE_MAX_DIMENSION (${IMAGE_MAX_DIMENSION})`,
+        );
+
+        // And the resize should actually have happened (source was 5000x3000 → expect width=4096)
+        assert.equal(meta.width, IMAGE_MAX_DIMENSION, 'Resized width should equal IMAGE_MAX_DIMENSION');
+      },
+    },
+
     // --- Auth rejection tests ---
 
     {

package/test/routes/admin/post-resize-image.js

@@ -0,0 +1,187 @@
+/**
+ * Test: routes/admin/post/post.resizeImage
+ * Unit tests for the in-place image resize used by the admin/post route.
+ *
+ * Run: npx mgr test routes/admin/post-resize-image
+ *
+ * Contract:
+ *   - Images with both dimensions <= IMAGE_MAX_DIMENSION pass through untouched.
+ *   - Images with either dimension > IMAGE_MAX_DIMENSION are resized in place,
+ *     preserving aspect ratio, with the long edge clamped to IMAGE_MAX_DIMENSION.
+ *   - Resize re-encodes as JPEG at IMAGE_JPEG_QUALITY (lossy is expected).
+ *   - The file at the original path is overwritten with the resized bytes.
+ */
+const os = require('os');
+const path = require('path');
+const jetpack = require('fs-jetpack');
+const sharp = require('sharp');
+
+const post = require('../../../src/manager/routes/admin/post/post');
+
+const { resizeImage, IMAGE_MAX_DIMENSION, IMAGE_JPEG_QUALITY } = post;
+
+// Generate a synthetic JPEG of the given dimensions and write it to a tmp path.
+// Returns the absolute path on disk.
+async function makeJpeg(width, height) {
+  const filepath = path.join(os.tmpdir(), `bem-test-resize-${Date.now()}-${width}x${height}.jpg`);
+  const buffer = await sharp({
+    create: {
+      width: width,
+      height: height,
+      channels: 3,
+      background: { r: 128, g: 128, b: 128 },
+    },
+  })
+    .jpeg({ quality: 90 })
+    .toBuffer();
+
+  jetpack.write(filepath, buffer);
+  return filepath;
+}
+
+// Minimal assistant stub — resizeImage only uses Manager.require + log.
+function makeAssistant() {
+  return {
+    log: () => {},
+    Manager: {
+      require: (mod) => require(mod),
+    },
+  };
+}
+
+module.exports = {
+  description: 'routes/admin/post/post.resizeImage',
+  type: 'group',
+
+  tests: [
+    // ─── Constants exposed ───
+
+    {
+      name: 'exports-constants',
+      async run({ assert }) {
+        assert.equal(IMAGE_MAX_DIMENSION, 4096, 'IMAGE_MAX_DIMENSION should be 4096');
+        assert.equal(IMAGE_JPEG_QUALITY, 80, 'IMAGE_JPEG_QUALITY should be 80');
+        assert.isType(resizeImage, 'function', 'resizeImage should be exported as a function');
+      },
+    },
+
+    // ─── Pass-through: image already within bounds ───
+
+    {
+      name: 'small-image-passes-through-untouched',
+      async run({ assert }) {
+        const filepath = await makeJpeg(800, 600);
+        const sizeBefore = jetpack.inspect(filepath).size;
+
+        const result = await resizeImage(makeAssistant(), filepath);
+
+        assert.equal(result.resized, false, 'Small image should not be resized');
+        assert.equal(result.width, 800, 'Width should be reported as-is');
+        assert.equal(result.height, 600, 'Height should be reported as-is');
+
+        const sizeAfter = jetpack.inspect(filepath).size;
+        assert.equal(sizeAfter, sizeBefore, 'File on disk should be byte-identical (no re-encode)');
+
+        jetpack.remove(filepath);
+      },
+    },
+
+    {
+      name: 'image-exactly-at-max-passes-through',
+      async run({ assert }) {
+        // Long edge exactly === IMAGE_MAX_DIMENSION → no resize (boundary condition)
+        const filepath = await makeJpeg(IMAGE_MAX_DIMENSION, 2000);
+
+        const result = await resizeImage(makeAssistant(), filepath);
+
+        assert.equal(result.resized, false, 'Image exactly at the limit should not be resized');
+        assert.equal(result.width, IMAGE_MAX_DIMENSION, 'Width unchanged');
+
+        jetpack.remove(filepath);
+      },
+    },
+
+    // ─── Resize: landscape (width > height) ───
+
+    {
+      name: 'landscape-oversized-is-resized-to-max-width',
+      async run({ assert }) {
+        // 8000x4000 landscape → long edge is width → clamp width to 4096, scale height proportionally to 2048
+        const filepath = await makeJpeg(8000, 4000);
+
+        const result = await resizeImage(makeAssistant(), filepath);
+
+        assert.equal(result.resized, true, 'Oversized landscape should be resized');
+        assert.equal(result.width, IMAGE_MAX_DIMENSION, 'Width clamped to IMAGE_MAX_DIMENSION');
+        assert.equal(result.height, IMAGE_MAX_DIMENSION / 2, 'Height scaled proportionally (8000:4000 → 4096:2048)');
+
+        // Verify the file on disk was actually overwritten
+        const meta = await sharp(filepath).metadata();
+        assert.equal(meta.width, IMAGE_MAX_DIMENSION, 'On-disk width matches reported width');
+        assert.equal(meta.height, IMAGE_MAX_DIMENSION / 2, 'On-disk height matches reported height');
+        assert.equal(meta.format, 'jpeg', 'On-disk format is JPEG');
+
+        jetpack.remove(filepath);
+      },
+    },
+
+    // ─── Resize: portrait (height > width) ───
+
+    {
+      name: 'portrait-oversized-is-resized-to-max-height',
+      async run({ assert }) {
+        // 4000x8000 portrait → long edge is height → clamp height to 4096, width proportionally to 2048
+        const filepath = await makeJpeg(4000, 8000);
+
+        const result = await resizeImage(makeAssistant(), filepath);
+
+        assert.equal(result.resized, true, 'Oversized portrait should be resized');
+        assert.equal(result.width, IMAGE_MAX_DIMENSION / 2, 'Width scaled proportionally');
+        assert.equal(result.height, IMAGE_MAX_DIMENSION, 'Height clamped to IMAGE_MAX_DIMENSION');
+
+        jetpack.remove(filepath);
+      },
+    },
+
+    // ─── Resize: huge image (the bug we are guarding against) ───
+
+    {
+      name: 'huge-image-is-resized-down',
+      async run({ assert }) {
+        // 16384x10576 — the actual size from post-1779087609 (the-importance-of-feedback-loops).
+        // Raw RGB this size is ~520MB, which is what stalled UJM's imagemin stream.
+        const filepath = await makeJpeg(16384, 10576);
+        const sizeBefore = jetpack.inspect(filepath).size;
+
+        const result = await resizeImage(makeAssistant(), filepath);
+
+        assert.equal(result.resized, true, 'Huge image should be resized');
+        assert.equal(result.width, IMAGE_MAX_DIMENSION, 'Long edge clamped to IMAGE_MAX_DIMENSION');
+        // 16384:10576 ratio → height = 4096 * (10576/16384) = 2644
+        assert.inRange(result.height, 2643, 2645, 'Height scaled proportionally (within rounding)');
+
+        const sizeAfter = jetpack.inspect(filepath).size;
+        assert.ok(sizeAfter < sizeBefore, 'Resized file on disk should be smaller than original');
+
+        jetpack.remove(filepath);
+      },
+    },
+
+    // ─── Square images ───
+
+    {
+      name: 'square-oversized-is-resized-to-square',
+      async run({ assert }) {
+        const filepath = await makeJpeg(8000, 8000);
+
+        const result = await resizeImage(makeAssistant(), filepath);
+
+        assert.equal(result.resized, true, 'Oversized square should be resized');
+        assert.equal(result.width, IMAGE_MAX_DIMENSION, 'Width clamped');
+        assert.equal(result.height, IMAGE_MAX_DIMENSION, 'Height clamped');
+
+        jetpack.remove(filepath);
+      },
+    },
+  ],
+};