backend-manager 5.2.19 → 5.3.0

package/src/manager/helpers/assistant.js

@@ -56,11 +56,13 @@ function tryUrl(self) {
     const host = req.get('host');
     const forwardedHost = req.get('x-forwarded-host');
     const path = req.path;
-    const functionsUrl = Manager.project.functionsUrl;
+    const functionsUrl = Manager.getFunctionsUrl();
 
     // Like this becuse "req.originalUrl" does NOT have path for all cases (like when calling https://us-central1-{id}.cloudfunctions.net/giftImport)
     if (projectType === 'firebase') {
-      if (self.isDevelopment()) {
+      // Non-production (development OR testing) reconstructs the URL from the local
+      // functions URL; production uses the request host.
+      if (!self.isProduction()) {
         return forwardedHost
           ? `${protocol}://${forwardedHost}${path}`
           : `${functionsUrl}/${self.meta.name}`;
@@ -116,6 +118,26 @@ BackendAssistant.prototype.init = function (ref, options) {
   self.settings = null;
   self.schema = null;
 
+  // Set ref FIRST so self.Manager is available below — meta.environment forwards to the
+  // Manager's canonical getEnvironment() (the Manager is the SSOT), so the Manager ref must
+  // be wired before we resolve the environment.
+  ref = ref || {};
+
+  // An assistant has no independent identity — it's a request-scoped face for its Manager,
+  // and forwards environment/url resolution to it. A Manager ref is REQUIRED; constructing
+  // one without it is a programming error (use Manager.Assistant(), which injects it).
+  if (!ref.Manager || typeof ref.Manager.getEnvironment !== 'function') {
+    throw new Error('BackendAssistant.init(): a Manager reference is required (ref.Manager). Construct via Manager.Assistant() so it is injected automatically.');
+  }
+
+  self.ref = {};
+  self.ref.req = ref.req || {};
+  self.ref.res = ref.res || {};
+  self.ref.admin = ref.admin || {};
+  self.ref.functions = ref.functions || {};
+  self.ref.Manager = ref.Manager;
+  self.Manager = self.ref.Manager;
+
   // Set meta
   self.meta = {};
 
@@ -127,16 +149,6 @@ BackendAssistant.prototype.init = function (ref, options) {
   self.meta.environment = options.environment || self.getEnvironment();
   self.meta.type = options.functionType || process.env.FUNCTION_SIGNATURE_TYPE || 'unknown';
 
-  // Set ref
-  self.ref = {};
-  ref = ref || {};
-  self.ref.req = ref.req || {};
-  self.ref.res = ref.res || {};
-  self.ref.admin = ref.admin || {};
-  self.ref.functions = ref.functions || {};
-  self.ref.Manager = ref.Manager || {};
-  self.Manager = self.ref.Manager;
-
   // Set ID
   try {
     const headers = self?.ref?.req.headers || {};
@@ -274,39 +286,31 @@ BackendAssistant.prototype.init = function (ref, options) {
   return self;
 };
 
+// Environment helpers — the Manager is the SINGLE SOURCE OF TRUTH (see index.js). The
+// assistant is a request-scoped face for its Manager and FORWARDS these straight through,
+// so request handlers can call `assistant.getEnvironment()` / `assistant.isTesting()` and
+// get exactly the same answer as `Manager.getEnvironment()`. No duplicated env-var logic
+// lives here — there is one implementation, on the Manager. A Manager ref is guaranteed by
+// init() (it throws otherwise), so these never need a fallback.
+//
+// Returns exactly ONE of 'development' | 'testing' | 'production' (mutually exclusive,
+// testing wins). isDevelopment() is NOT true in testing; isProduction() is a real positive
+// check (never `!isDevelopment()`). Gate "anything non-production" with `!isProduction()`
+// or `isDevelopment() || isTesting()` intentionally.
 BackendAssistant.prototype.getEnvironment = function () {
-  // return (process.env.FUNCTIONS_EMULATOR === true || process.env.FUNCTIONS_EMULATOR === 'true' || process.env.ENVIRONMENT !== 'production' ? 'development' : 'production')
-  if (process.env.ENVIRONMENT === 'production') {
-    return 'production';
-  } else if (
-    process.env.ENVIRONMENT === 'development'
-    || process.env.FUNCTIONS_EMULATOR === true
-    || process.env.FUNCTIONS_EMULATOR === 'true'
-    || process.env.TERM_PROGRAM === 'Apple_Terminal'
-    || process.env.TERM_PROGRAM === 'vscode'
-  ) {
-    return 'development';
-  } else {
-    return 'production'
-  }
-};
+  return this.Manager.getEnvironment();
+}
 
 BackendAssistant.prototype.isDevelopment = function () {
-  const self = this;
-
-  return self.meta.environment === 'development';
+  return this.Manager.isDevelopment();
 }
 
 BackendAssistant.prototype.isProduction = function () {
-  const self = this;
-
-  return self.meta.environment === 'production';
+  return this.Manager.isProduction();
 }
 
 BackendAssistant.prototype.isTesting = function () {
-  const self = this;
-
-  return process.env.BEM_TESTING === 'true';
+  return this.Manager.isTesting();
 }
 
 BackendAssistant.prototype.logProd = function () {
@@ -330,10 +334,11 @@ BackendAssistant.prototype._log = function () {
   if (LOG_LEVELS[level]) {
     logs.splice(1, 1);
 
-    // Determine how to log
+    // Determine how to log. Console for any non-production environment (development OR
+    // testing); the Firebase Cloud logger only in production.
     if (level in console) {
       console[level].apply(console, logs);
-    } else if (self.isDevelopment()) {
+    } else if (!self.isProduction()) {
       console.log.apply(console, logs);
     } else {
       self.ref.functions.logger.write({

package/src/manager/index.js

@@ -179,6 +179,54 @@ Manager.prototype.init = function (exporter, options) {
     });
   }
 
+  // Environment helpers — the Manager is the SINGLE SOURCE OF TRUTH (mirrors EM/UJM/BXM,
+  // where the Manager owns these). getEnvironment() is the ONLY place that reads the raw
+  // env vars (BEM_TESTING / ENVIRONMENT / FUNCTIONS_EMULATOR / TERM_PROGRAM); the three
+  // is*() checks derive from it live on every call. They return exactly ONE of three
+  // mutually-exclusive values — testing wins, then production, else development.
+  // The assistant exposes the same methods but FORWARDS to these (assistant.isTesting()
+  // → Manager.isTesting()), so request handlers can keep calling `assistant.*`.
+  // Defined BEFORE the assistant is constructed so the assistant's own init() can call back.
+  self.getEnvironment = function() {
+    // Testing takes precedence — set by the test runner / emulator (BEM_TESTING=true).
+    if (process.env.BEM_TESTING === 'true') {
+      return 'testing';
+    }
+    if (process.env.ENVIRONMENT === 'production') {
+      return 'production';
+    } else if (
+      process.env.ENVIRONMENT === 'development'
+      || process.env.FUNCTIONS_EMULATOR === true
+      || process.env.FUNCTIONS_EMULATOR === 'true'
+      || process.env.TERM_PROGRAM === 'Apple_Terminal'
+      || process.env.TERM_PROGRAM === 'vscode'
+    ) {
+      return 'development';
+    } else {
+      // Default: production. BEM's deployed RUNTIME can legitimately lack a dev signal — a
+      // live Cloud Function has no FUNCTIONS_EMULATOR and often no ENVIRONMENT var, so
+      // "no signal" IS the normal production state. Defaulting to development here would make
+      // every deployed function skip real side effects (emails/analytics/webhooks).
+      // (Contrast UJM/BXM, whose deployed artifacts always carry their signal, so they default
+      // to development — a bare context there is just build tooling.)
+      return 'production';
+    }
+  };
+
+  // The three checks are mutually exclusive — each true for ONLY its own environment.
+  // isDevelopment() is NOT true in testing; isProduction() is a real positive check
+  // (never `!isDevelopment()`). Gate "anything non-production" with `!isProduction()`
+  // or `isDevelopment() || isTesting()` intentionally.
+  self.isDevelopment = function() {
+    return self.getEnvironment() === 'development';
+  };
+  self.isProduction = function() {
+    return self.getEnvironment() === 'production';
+  };
+  self.isTesting = function() {
+    return self.getEnvironment() === 'testing';
+  };
+
   // Init assistant
   self.assistant = self.Assistant().init({
     req: null,
@@ -190,21 +238,33 @@ Manager.prototype.init = function (exporter, options) {
 
   // Helper functions for URLs based on environment
   self.getFunctionsUrl = function(env) {
-    const isDev = env === 'development' || (!env && self.assistant.isDevelopment());
+    // Auto-detect (no explicit env): development OR testing → local URLs. Test runs
+    // hit the local emulator, so getApiUrl/getFunctionsUrl/getWebsiteUrl must resolve
+    // to localhost. NOTE: getParentApiUrl/getParentUrl are intentionally NOT changed —
+    // the parent is a real remote server with no localhost equivalent.
+    const isDev = env === 'development' || (!env && (self.isDevelopment() || self.isTesting()));
     return isDev
       ? `http://localhost:5001/${self.project.projectId}/${self.project.resourceZone}`
       : `https://${self.project.resourceZone}-${self.project.projectId}.cloudfunctions.net`;
   };
 
   self.getApiUrl = function(env) {
-    const isDev = env === 'development' || (!env && self.assistant.isDevelopment());
+    // Auto-detect (no explicit env): development OR testing → local URLs. Test runs
+    // hit the local emulator, so getApiUrl/getFunctionsUrl/getWebsiteUrl must resolve
+    // to localhost. NOTE: getParentApiUrl/getParentUrl are intentionally NOT changed —
+    // the parent is a real remote server with no localhost equivalent.
+    const isDev = env === 'development' || (!env && (self.isDevelopment() || self.isTesting()));
     return isDev
       ? 'http://localhost:5002'
       : `https://api.${(self.config.brand?.url || '').replace(/^https?:\/\//, '')}`;
   };
 
   self.getWebsiteUrl = function(env) {
-    const isDev = env === 'development' || (!env && self.assistant.isDevelopment());
+    // Auto-detect (no explicit env): development OR testing → local URLs. Test runs
+    // hit the local emulator, so getApiUrl/getFunctionsUrl/getWebsiteUrl must resolve
+    // to localhost. NOTE: getParentApiUrl/getParentUrl are intentionally NOT changed —
+    // the parent is a real remote server with no localhost equivalent.
+    const isDev = env === 'development' || (!env && (self.isDevelopment() || self.isTesting()));
     return isDev
       ? 'https://localhost:4000'
       : self.config.brand?.url || '';
@@ -254,7 +314,7 @@ Manager.prototype.init = function (exporter, options) {
   self.project.websiteUrl = self.getWebsiteUrl();
 
   // Set environment
-  process.env.ENVIRONMENT = process.env.ENVIRONMENT || self.assistant.meta.environment;
+  process.env.ENVIRONMENT = process.env.ENVIRONMENT || self.getEnvironment();
 
   // Set BEM env variables
   process.env.BEM_FUNCTIONS_URL = self.project.functionsUrl;
@@ -262,9 +322,10 @@ Manager.prototype.init = function (exporter, options) {
   process.env.BEM_WEBSITE_URL = self.project.websiteUrl;
 
   // Use the working Firebase logger that they disabled for whatever reason
+  // Load the Firebase logger compat shim only in production (NOT development or testing).
   if (
     process.env.GCLOUD_PROJECT
-    && self.assistant.meta.environment !== 'development'
+    && self.isProduction()
     && options.useFirebaseLogger
   ) {
     // require('firebase-functions/lib/logger/compat'); // Old way
@@ -272,7 +333,7 @@ Manager.prototype.init = function (exporter, options) {
   }
 
   // Handle test environment
-  if (self.assistant.isTesting()) {
+  if (self.isTesting()) {
     self.assistant.log('⚠️⚠️⚠️ Running in TEST environment, some features may be disabled ⚠️⚠️⚠️');
 
     // Install the test-mode-file watcher exactly once. Lets the test command
@@ -283,7 +344,7 @@ Manager.prototype.init = function (exporter, options) {
   }
 
   // Handle dev environments
-  if (self.assistant.isDevelopment()) {
+  if (self.isDevelopment()) {
     const version = require('wonderful-version');
     const nodeUsing = version.major(process.versions.node);
     const nodeRequired = version.major(self.package?.engines?.node || '0.0.0');
@@ -331,14 +392,17 @@ Manager.prototype.init = function (exporter, options) {
       dsn: sentryDSN,
       release: sentryRelease,
       beforeSend(event, hint) {
-        if (self.assistant.isDevelopment() && !self.options.reportErrorsInDev) {
-          self.assistant.error(new Error('[Sentry] Skipping Sentry because we\'re in development'), hint)
+        // Skip Sentry in any non-production environment (development OR testing) unless
+        // explicitly opted in. Intentional positive check — we never want test-run errors
+        // polluting production Sentry.
+        if (!self.isProduction() && !self.options.reportErrorsInDev) {
+          self.assistant.error(new Error('[Sentry] Skipping Sentry because we\'re not in production'), hint)
           return null;
         }
         event.tags = event.tags || {};
         event.tags['function.name'] = self.assistant.meta.name;
         event.tags['function.type'] = self.assistant.meta.type;
-        event.tags['environment'] = self.assistant.meta.environment;
+        event.tags['environment'] = self.getEnvironment();
         return event;
       },
     });
@@ -381,7 +445,7 @@ Manager.prototype.init = function (exporter, options) {
   }
 
   // Fetch stats
-  if (self.assistant.isDevelopment() && options.fetchStats) {
+  if (self.isDevelopment() && options.fetchStats) {
     setTimeout(function () {
       self.assistant.log('Fetching meta/stats...');
       self.libraries.admin
@@ -677,7 +741,7 @@ Manager.prototype.storage = function (options) {
     // Clear temporary storage
     if (
       options.temporary
-      && self.assistant.isDevelopment()
+      && self.isDevelopment()
       && options.clear
     ) {
       self.assistant.log('Removed temporary file @', location);

package/src/manager/libraries/ai/index.js

@@ -92,6 +92,39 @@ AI.prototype.request = async function (options) {
   return result;
 };
 
+/**
+ * Generate an image. Dispatches to the provider's image() method.
+ *
+ * Currently only OpenAI (gpt-image-2) implements image generation.
+ *
+ *   const ai = Manager.AI(assistant);
+ *   const { buffer } = await ai.image({ prompt: 'a flat vector rocket', size: '1024x1024' });
+ *
+ * @param {object} options
+ * @param {string}  options.prompt        - Image description (required)
+ * @param {'openai'} [options.provider='openai']
+ * @param {string} [options.model]        - default gpt-image-2
+ * @param {string} [options.size]         - 1024x1024 | 1536x1024 | 1024x1536 | auto
+ * @param {string} [options.quality]      - low | medium | high | auto
+ * @param {string} [options.background]   - transparent | opaque | auto
+ * @param {number} [options.n]            - how many images (default 1)
+ * @param {string} [options.apiKey]
+ * @returns {Promise<{buffer, b64, mime, revisedPrompt, model, size, quality, raw}>}
+ */
+AI.prototype.image = async function (options) {
+  const self = this;
+  const opts = options || {};
+  const provider = opts.provider || DEFAULT_PROVIDER;
+
+  const client = self._getProvider(provider, opts.apiKey);
+
+  if (typeof client.image !== 'function') {
+    throw new Error(`AI provider "${provider}" does not support image generation`);
+  }
+
+  return client.image(opts);
+};
+
 AI.prototype._getProvider = function (provider, apiKey) {
   const self = this;
 

package/src/manager/libraries/ai/providers/openai.js

@@ -9,6 +9,7 @@ const mimeTypes = require('mime-types');
 // Constants
 const DEFAULT_MODEL = 'gpt-5.4-mini';
 const MODERATION_MODEL = 'omni-moderation-latest';
+const IMAGE_DEFAULT_MODEL = 'gpt-image-2';
 
 // OpenAI model pricing table (per 1M tokens)
 // https://platform.openai.com/docs/pricing
@@ -395,10 +396,12 @@ OpenAI.prototype.request = function (options) {
     // Reasons
     options.reasoning = options.reasoning || undefined;
 
-    // Tools (e.g. built-in web_search). Opt-in — when omitted, no tools are sent
-    // and behavior is identical to a plain request.
+    // Tools — nested, opt-in. `tools.list` is an array of tool definitions (built-in
+    // hosted tools like `{ type: 'web_search' }`, OR custom function tools like
+    // `{ type: 'function', name, parameters }`); `tools.choice` maps to `tool_choice`
+    // (`auto` | `required` | `none` | a specific tool). When omitted/empty, no tools
+    // are sent and behavior is identical to a plain request.
     options.tools = options.tools || undefined;
-    options.toolChoice = options.toolChoice || undefined;
 
     // Format prompt
     //
@@ -512,6 +515,100 @@ OpenAI.prototype.request = function (options) {
   });
 }
 
+/**
+ * Generate an image via OpenAI's image API (gpt-image-2 by default).
+ *
+ * Returns the raw bytes — caller decides what to do with them (upload to a CDN,
+ * embed as a data URL, write to disk, etc.). gpt-image-* always returns base64,
+ * so there's no URL-fetch round trip.
+ *
+ * @param {object} options
+ * @param {string}  options.prompt           - The image description (required)
+ * @param {string} [options.model]           - Image model (default gpt-image-2)
+ * @param {string} [options.size]            - 1024x1024 | 1536x1024 | 1024x1536 | auto (default 1024x1024)
+ * @param {string} [options.quality]         - low | medium | high | auto (default medium)
+ * @param {string} [options.background]      - transparent | opaque | auto
+ * @param {number} [options.n]               - How many images (default 1)
+ * @param {number} [options.timeout]         - ms (default 300000 — image gen is slow)
+ * @param {boolean}[options.log]
+ * @returns {Promise<{buffer: Buffer, b64: string, mime: string, revisedPrompt: string|null, model: string, size: string, quality: string, raw: object}>}
+ *          (or an array of those when n > 1)
+ */
+OpenAI.prototype.image = function (options) {
+  const self = this;
+  const assistant = self.assistant;
+
+  return new Promise(async function (resolve, reject) {
+    options = _.merge({}, options);
+
+    if (!options.prompt) {
+      return reject(assistant.errorify(`image(): {prompt} is required`, { code: 400 }));
+    }
+
+    options.model = options.model || IMAGE_DEFAULT_MODEL;
+    options.size = options.size || '1024x1024';
+    options.quality = options.quality || 'medium';
+    options.n = options.n || 1;
+    options.timeout = typeof options.timeout === 'undefined' ? 300000 : options.timeout;
+    options.log = typeof options.log === 'undefined' ? false : options.log;
+
+    const body = {
+      model: options.model,
+      prompt: options.prompt,
+      size: options.size,
+      quality: options.quality,
+      n: options.n,
+    };
+
+    // background is opt-in (transparent/opaque/auto)
+    if (options.background) {
+      body.background = options.background;
+    }
+
+    if (options.log) {
+      assistant.log(`OpenAI.image(): model=${options.model} size=${options.size} quality=${options.quality} n=${options.n}`);
+    }
+
+    let data;
+    try {
+      data = await fetch('https://api.openai.com/v1/images/generations', {
+        method: 'post',
+        response: 'json',
+        timeout: options.timeout,
+        tries: options.tries || 1,
+        headers: {
+          'Authorization': `Bearer ${self.key}`,
+          'Content-Type': 'application/json',
+        },
+        body: body,
+      });
+    } catch (e) {
+      return reject(assistant.errorify(`OpenAI.image() request failed: ${e.message}`, { code: e.code || 500 }));
+    }
+
+    if (!data?.data?.length) {
+      return reject(assistant.errorify(`OpenAI.image() returned no image data: ${JSON.stringify(data).slice(0, 300)}`, { code: 500 }));
+    }
+
+    const mapItem = (item) => {
+      const b64 = item.b64_json;
+      return {
+        buffer: b64 ? Buffer.from(b64, 'base64') : null,
+        b64: b64 || null,
+        mime: 'image/png',
+        revisedPrompt: item.revised_prompt || null,
+        model: options.model,
+        size: options.size,
+        quality: options.quality,
+        raw: data,
+      };
+    };
+
+    // Single image (the common case) returns one object; n > 1 returns an array.
+    return resolve(options.n === 1 ? mapItem(data.data[0]) : data.data.map(mapItem));
+  });
+};
+
 function tryParse(content) {
   try {
     return JSON5.parse(content);
@@ -983,15 +1080,15 @@ function makeRequest(mode, options, self, promptSegments, message, user, _log) {
         request.body.reasoning = reasoning;
       }
 
-      // Only include tools (e.g. web_search) if provided. When present, the
+      // Only include tools if `tools.list` is a non-empty array. When present, the
       // response output may contain tool-call items (e.g. web_search_call)
       // alongside the message — the message extractor below already ignores
       // non-message items, so this is purely additive.
-      if (Array.isArray(options.tools) && options.tools.length) {
-        request.body.tools = options.tools;
+      if (Array.isArray(options.tools?.list) && options.tools.list.length) {
+        request.body.tools = options.tools.list;
 
-        if (options.toolChoice) {
-          request.body.tool_choice = options.toolChoice;
+        if (options.tools.choice) {
+          request.body.tool_choice = options.tools.choice;
         }
       }
     }

package/src/manager/libraries/content/ghostii.js

@@ -1,10 +1,17 @@
 /**
  * Ghostii article engine — shared helpers for AI article generation + publishing.
  *
- * Ghostii (api.ghostii.ai) writes a full blog article (title, body, header image,
- * categories, keywords) from a free-form description. We then publish it to the
- * brand's website repo via the internal `admin/post` route (commits markdown +
- * images to GitHub).
+ * Ghostii (api.ghostii.ai) is UNOPINIONATED about BEM. It returns a generic,
+ * structured article: a `json` block array ([{ name, content }]) plus `title`,
+ * `description`, `headerImageUrl`, `categories`, `keywords`. It is NOT shaped to
+ * BEM's post format — BEM is responsible for transforming Ghostii's output into
+ * what its `admin/post` route expects.
+ *
+ * `blocksToPost()` is that transform: it digests the JSON blocks and pulls out
+ * the title (heading-1), the header image (first image block), and the clean
+ * body (every remaining block — sections, paragraphs, section images, quotes —
+ * joined as markdown, with NO title or header image embedded, since admin/post
+ * adds those itself from the separate `title`/`headerImageURL` fields).
  *
  * Two consumers:
  *   - events/cron/daily/ghostii-auto-publisher.js — standalone daily article job
@@ -23,12 +30,15 @@ const powertools = require('node-powertools');
  * @param {object} args.brand - Public brand config ({ brand: { url, ... }, github: { ... } })
  * @param {string} args.description - The article brief / prompt content
  * @param {string[]} [args.links] - Optional links to inject into the article body
- * @returns {Promise<object>} { title, description, body, headerImageUrl, categories, keywords }
+ * @returns {Promise<object>} Ghostii's generic article response:
+ *   { title, description, body, json, headerImageUrl, images, categories, keywords, links, outline }
+ *   where `json` is the structured block array ([{ name, content }]) that
+ *   blocksToPost() consumes to build BEM's post shape.
  */
 function writeArticle({ brand, description, links }) {
   return fetch('https://api.ghostii.ai/write/article', {
     method: 'post',
-    timeout: 90000,
+    timeout: 180000,
     tries: 1,
     response: 'json',
     body: {
@@ -36,6 +46,10 @@ function writeArticle({ brand, description, links }) {
       keywords: [''],
       description: description,
       insertLinks: true,
+      research: true,
+      insertImages: true,
+      length: 'long',
+      maxLinks: 6,
       headerImageUrl: 'unsplash',
       url: brand.brand.url,
       sectionQuantity: powertools.random(3, 6, { mode: 'gaussian' }),
@@ -45,13 +59,51 @@ function writeArticle({ brand, description, links }) {
   });
 }
 
+/**
+ * Transform Ghostii's generic JSON block array into BEM's post shape.
+ *
+ * Ghostii returns `json: [{ name, content }]` where name ∈ heading-1..6, image,
+ * paragraph, blockquote, list. BEM's admin/post wants the title + header image as
+ * SEPARATE fields and a body that is ONLY the content below them. So we extract:
+ *   - title       ← first heading-1 block (markdown `#` stripped)
+ *   - headerImageUrl ← first image block's URL
+ *   - body        ← every remaining block, joined as markdown
+ *
+ * @param {Array} json - Ghostii's block array.
+ * @returns {{ title: string, headerImageUrl: string, body: string }}
+ */
+function blocksToPost(json) {
+  const blocks = Array.isArray(json) ? json : [];
+
+  const titleBlock = blocks.find((b) => b.name === 'heading-1');
+  const imageBlock = blocks.find((b) => b.name === 'image');
+
+  // Title: strip the leading markdown heading marker.
+  const title = (titleBlock?.content || '').replace(/^#+\s*/, '').trim();
+
+  // Header image: pull the URL out of `![alt](url)`.
+  const imageMatch = (imageBlock?.content || '').match(/\((.*?)\)\s*$/);
+  const headerImageUrl = imageMatch ? imageMatch[1] : '';
+
+  // Body: everything except the title block and the header-image block.
+  const body = blocks
+    .filter((b) => b !== titleBlock && b !== imageBlock)
+    .map((b) => b.content)
+    .join('\n\n')
+    .trim();
+
+  return { title, headerImageUrl, body };
+}
+
 /**
  * Publish a Ghostii article to the brand's website repo via the admin/post route.
  *
  * @param {object} assistant - BEM assistant instance
  * @param {object} args
  * @param {object} args.brand - Public brand config ({ brand: { url, ... }, github: { user, repo } })
- * @param {object} args.article - The article from writeArticle()
+ * @param {object} args.article - The article from writeArticle(). When it carries a
+ *   `json` block array, the post is reconstructed via blocksToPost() (title + header
+ *   image extracted, body = content only). Falls back to article.{title,body,headerImageUrl}.
  * @param {number} args.id - Post ID (unix timestamp)
  * @param {string} [args.author] - Author slug (admin/post picks a default if unset)
  * @param {string} [args.postPath='ghostii'] - Sub-folder under _posts/{year}/
@@ -61,18 +113,26 @@ async function publishArticle(assistant, { brand, article, id, author, postPath
   const baseUrl = (brand.brand.url || '').replace(/^https?:\/\//, '').replace(/\/$/, '');
   const apiUrl = `https://api.${baseUrl}`;
 
-  const post = await fetch(`${apiUrl}/backend-manager/admin/post`, {
+  // Transform Ghostii's generic JSON into BEM's post shape (title + header image
+  // as separate fields, body = content only). Fall back to the legacy flat fields
+  // for older Ghostii responses that don't include `json`.
+  const post = blocksToPost(article.json);
+  const title = post.title || article.title;
+  const headerImageUrl = post.headerImageUrl || article.headerImageUrl;
+  const body = article.json ? post.body : article.body;
+
+  const result = await fetch(`${apiUrl}/backend-manager/admin/post`, {
     method: 'POST',
     timeout: 90000,
     tries: 1,
     response: 'json',
     body: {
       backendManagerKey: process.env.BACKEND_MANAGER_KEY,
-      title: article.title,
-      url: article.title, // Slugified on the admin/post endpoint
+      title: title,
+      url: title, // Slugified on the admin/post endpoint
       description: article.description,
-      headerImageURL: article.headerImageUrl,
-      body: article.body,
+      headerImageURL: headerImageUrl,
+      body: body,
       id: id,
       author: author,
       categories: article.categories,
@@ -86,15 +146,15 @@ async function publishArticle(assistant, { brand, article, id, author, postPath
   // admin/post returns the resolved `settings` (incl. the slugified `url` and repo `path`).
   // The post template sets no permalink, so the public URL follows the Jekyll/UJM
   // blog convention: {brand.url}/blog/{slug}.
-  const slug = post?.url || '';
+  const slug = result?.url || '';
   const publicUrl = `${(brand.brand.url || '').replace(/\/$/, '')}/blog/${slug}`;
 
   return {
-    post,
+    post: result,
     url: slug ? publicUrl : null,
     slug,
-    path: post?.path || null,
+    path: result?.path || null,
   };
 }
 
-module.exports = { writeArticle, publishArticle };
+module.exports = { writeArticle, publishArticle, blocksToPost };