@omega.js/backend 0.1.0

package/dist/manager/events/auth/on-create.js

@@ -0,0 +1,112 @@
+const { retryWrite, runAuthHook, MAX_RETRIES } = require('./utils.js');
+const { buildUserDoc, isUserDoc, extractProviderName } = require('../../libraries/user-doc.js');
+
+/**
+ * onCreate - Create user doc
+ *
+ * This function fires for ALL user creations (including Admin SDK).
+ * It creates the user doc in Firestore.
+ *
+ * Key behaviors:
+ * - Checks if user doc already exists (auth.uid) → skips if exists (handles test accounts, provider linking)
+ * - Retries up to 3 times with exponential backoff on failure
+ *
+ * If the user signed up via a provider (Google, Facebook, etc.), their display name
+ * is extracted and stored as personal.name.first/last on the user doc.
+ *
+ * Non-critical work (welcome emails, marketing contact) is handled
+ * by the user/signup endpoint, which the frontend calls after account creation.
+ *
+ * Available parameters (1st gen):
+ *
+ * user (UserRecord — firebase-admin):
+ *   uid, email, emailVerified, displayName, photoURL, phoneNumber, disabled,
+ *   metadata: { creationTime, lastSignInTime, lastRefreshTime },
+ *   providerData: [{ uid, displayName, email, photoURL, providerId, phoneNumber }],
+ *   passwordHash, passwordSalt, customClaims, tenantId, tokensValidAfterTime, multiFactor
+ *
+ * context (EventContext — NOT AuthEventContext, no ipAddress/userAgent/locale):
+ *   eventId, eventType, timestamp, resource: { service, name }, params
+ */
+module.exports = async ({ Manager, ctx, user, context, libraries }) => {
+  const startTime = Date.now();
+  const { admin } = libraries;
+
+  // The uid and nothing else — the one spelling the other three auth triggers
+  // carry since the #657 sweep, so the family reads the same way
+  // ([#710](https://github.com/Omega-JS-Stack/omega/issues/710)). The email is
+  // legal on a log line, but it is not what NAMES this invocation, and the
+  // account it belongs to is one debug line away. The full UserRecord
+  // (passwordHash, providerData, metadata) and the event context go with it.
+  ctx.log(`onCreate: ${user.uid}`);
+  ctx.debug(`onCreate: ${user.uid} record`, user, context);
+
+  // Skip anonymous users
+  if (user.providerData?.every(p => p.providerId === 'anonymous')) {
+    ctx.log(`onCreate: Skipping anonymous user ${user.uid} (${Date.now() - startTime}ms)`);
+    return;
+  }
+
+  // Check if user doc already exists (handles test accounts, provider linking)
+  const existingDoc = await admin.firestore().doc(`users/${user.uid}`)
+    .get()
+    .catch(e => {
+      ctx.error(`onCreate: Failed to check existing doc for ${user.uid}:`, e);
+      return null;
+    });
+
+  if (isUserDoc(existingDoc?.exists ? existingDoc.data() : null)) {
+    ctx.log(`onCreate: User doc already exists for ${user.uid}, skipping creation (${Date.now() - startTime}ms)`);
+    return;
+  }
+
+  // Extract name from provider data (e.g., Google, Facebook, GitHub). WHETHER a
+  // name came back, never the name itself: a person's first/last is their PII,
+  // and this line lands in Cloud Logging for the whole retention window
+  // (docs/shared/logging.md § PII — identifier not payload,
+  // [#710](https://github.com/Omega-JS-Stack/omega/issues/710)). The parsed
+  // name stays one debug line down.
+  const providerName = extractProviderName(user);
+
+  ctx.log(`onCreate: Inferred name from provider for ${user.uid}: ${providerName ? 'yes' : 'no'}`);
+  ctx.debug(`onCreate: Inferred name from provider for ${user.uid}:`, providerName);
+
+  // Build the user doc — the same shape the sign-in heal recreates when this doc
+  // goes missing later ([#405](https://github.com/Omega-JS-Stack/omega/issues/405))
+  const userRecord = buildUserDoc({ Manager: Manager, user: user, tag: 'auth:on-create' });
+
+  // The UID and nothing else. The doc carries the email, the name, the signup IP
+  // and the geolocation, and a backend line lands in Cloud Logging for the whole
+  // retention window — so none of it rides this line
+  // ([#641](https://github.com/Omega-JS-Stack/omega/issues/641)).
+  ctx.log(`onCreate: Creating user doc for ${user.uid}`);
+
+  // Write user doc with retry
+  try {
+    await retryWrite(ctx, 'onCreate', async () => {
+      await admin.firestore().doc(`users/${user.uid}`).set(userRecord);
+    });
+
+    ctx.log(`onCreate: Successfully created user doc for ${user.uid} (${Date.now() - startTime}ms)`);
+  } catch (error) {
+    ctx.error(`onCreate: Failed to create user doc after ${MAX_RETRIES} retries:`, error);
+
+    // Don't reject - the user was already created in Auth
+    // The user/signup endpoint will handle creating the doc if it's missing
+  }
+
+  // The SERVER half of `sign_up` does NOT fire here
+  // ([#577](https://github.com/Omega-JS-Stack/omega/issues/577)). A trigger has
+  // no HTTP request behind it, so a registration fired from here reached Meta
+  // and TikTok with no IP, no user agent, no platform cookies and an attribution
+  // the browser had not posted yet — around 4/10 on Meta's match quality. It
+  // fires from `routes/user/signup` instead, the post-auth request that carries
+  // all four (`libraries/analytics/signup.js`). Adding it back here would count
+  // every registration twice.
+
+  // Run consumer hook (non-blocking — errors logged but don't fail)
+  await runAuthHook('on-create', { Manager, ctx, user, context, libraries }).catch(e => {
+    ctx.error('onCreate: Consumer hook error:', e);
+  });
+};
+

package/dist/manager/events/auth/on-delete.js

@@ -0,0 +1,141 @@
+const { retryWrite, runAuthHook, MAX_RETRIES } = require('./utils.js');
+const { deliverConversion } = require('../../libraries/analytics/conversions.js');
+const { buildAttributionContext, buildIdentity } = require('../../libraries/analytics/match-data.js');
+
+/**
+ * onDelete - Delete user doc
+ *
+ * This function fires when a user is deleted from Firebase Auth.
+ * It deletes the user doc from Firestore.
+ *
+ * Key behaviors:
+ * - Checks if user doc exists before attempting delete
+ * - Retries up to 3 times with exponential backoff on failure
+ * - Logs timing for performance monitoring
+ *
+ * Available parameters (1st gen):
+ *
+ * user (UserRecord — firebase-admin):
+ *   uid, email, emailVerified, displayName, photoURL, phoneNumber, disabled,
+ *   metadata: { creationTime, lastSignInTime, lastRefreshTime },
+ *   providerData: [{ uid, displayName, email, photoURL, providerId, phoneNumber }],
+ *   passwordHash, passwordSalt, customClaims, tenantId, tokensValidAfterTime, multiFactor
+ *
+ * context (EventContext — NOT AuthEventContext, no ipAddress/userAgent/locale):
+ *   eventId, eventType, timestamp, resource: { service, name }, params
+ */
+module.exports = async ({ Manager, ctx, user, context, libraries }) => {
+  const startTime = Date.now();
+  const { admin } = libraries;
+
+  // The UID and nothing else. The UserRecord carries the email, the display name,
+  // the provider data and the password hash, and a backend line lands in Cloud
+  // Logging for the whole retention window — so none of it rides this line
+  // ([#657](https://github.com/Omega-JS-Stack/omega/issues/657)). The record and
+  // the event context stay reachable one level down, at debug.
+  ctx.log(`onDelete: ${user.uid}`);
+  ctx.debug(`onDelete: ${user.uid} record`, user, context);
+
+  // Check if user doc exists before attempting delete
+  const existingDoc = await admin.firestore().doc(`users/${user.uid}`)
+    .get()
+    .catch(e => {
+      ctx.error(`onDelete: Failed to check existing doc for ${user.uid}:`, e);
+      return null;
+    });
+
+  if (!existingDoc || !existingDoc.exists) {
+    ctx.log(`onDelete: User doc does not exist for ${user.uid}, skipping (${Date.now() - startTime}ms)`);
+    return;
+  }
+
+  // Read the doc BEFORE it goes: the consent snapshot and the campaign that won
+  // this account are the only record of either, and the delete below is the
+  // moment they stop existing.
+  const userDoc = existingDoc.data();
+
+  // Delete user doc with retry
+  try {
+    await retryWrite(ctx, 'onDelete', async () => {
+      await admin.firestore().doc(`users/${user.uid}`).delete();
+    });
+
+    ctx.log(`onDelete: Successfully deleted user doc for ${user.uid}`);
+  } catch (error) {
+    ctx.error(`onDelete: Failed to delete user doc after ${MAX_RETRIES} retries:`, error);
+
+    // Don't reject - the user was already deleted from Auth
+    // Just log the error and continue
+    return;
+  }
+
+  // Remove marketing contact from all providers (non-blocking)
+  if (user.email) {
+    const email = Manager.Email(ctx);
+    email.remove(user.email)
+      .then((r) => {
+        // The uid and how many providers answered. The results object carries
+        // each provider's own payload — a contact record, a subscriber — and
+        // every one of them carries the deleted user's address back, into the
+        // Cloud Logging retention window the headline above stopped writing to
+        // ([#710](https://github.com/Omega-JS-Stack/omega/issues/710)).
+        ctx.log(`onDelete: Marketing remove for ${user.uid}: ${Object.keys(r).length} provider(s)`);
+        ctx.debug('onDelete: Marketing remove:', r);
+      })
+      .catch((e) => ctx.error('onDelete: Marketing remove failed:', e));
+  }
+
+  // Send delete analytics (server-side only event)
+  trackDelete({ Manager, ctx, user, userDoc });
+
+  // Run consumer hook (non-blocking — errors logged but don't fail)
+  await runAuthHook('on-delete', { Manager, ctx, user, context, libraries }).catch(e => {
+    ctx.error('onDelete: Consumer hook error:', e);
+  });
+
+  ctx.log(`onDelete: Completed for ${user.uid} (${Date.now() - startTime}ms)`);
+};
+
+/**
+ * Fire the canonical `user_delete` conversion (non-blocking).
+ *
+ * The same treatment `notification_subscribe` gets, and for the same reason: a
+ * raw `Manager.Analytics(...).event()` reaches GA4 without ever asking the
+ * consent gate, and names an event no catalog knows. `user_delete` is a
+ * `placement: 'server'`, GA4-only entry — nothing else can observe an account
+ * ending, and no ad platform has anything to do with it.
+ *
+ * THE DEDUPE ID IS `user_delete.<uid>` — an account is deleted once, and the
+ * uid is what the deletion is about, so a redelivered trigger reports the same
+ * event rather than a second one.
+ *
+ * The consent snapshot and the attribution come off the doc read BEFORE the
+ * delete — the last moment either exists. An ABSENT snapshot grants: a legacy
+ * account predating the consent system still gets counted, which is the
+ * standing rule for every server conversion (conversions.js).
+ *
+ * @param {object} options
+ * @param {object} options.Manager - The backend Manager.
+ * @param {object} options.ctx - The event context.
+ * @param {object} options.user - The deleted Auth UserRecord.
+ * @param {object} [options.userDoc] - The user doc as it stood before deletion.
+ * @returns {void}
+ */
+function trackDelete({ Manager, ctx, user, userDoc }) {
+  try {
+    deliverConversion({
+      event: 'user_delete',
+      attribution: buildAttributionContext(userDoc?.attribution),
+      // The doc as it stood, through the ONE match reader: a deletion is an
+      // exclusion audience, and an exclusion nobody can be matched to excludes
+      // nobody ([#577](https://github.com/Omega-JS-Stack/omega/issues/577)).
+      identity: buildIdentity({ uid: user.uid, user: userDoc, email: user.email, telephone: user.phoneNumber }),
+      trackingConsent: userDoc?.trackingConsent,
+      eventId: `user_delete.${user.uid}`,
+      ctx: ctx,
+      Manager: Manager,
+    });
+  } catch (e) {
+    ctx.error(`onDelete: user_delete tracking failed for ${user.uid}:`, e);
+  }
+}

package/dist/manager/events/auth/utils.js

@@ -0,0 +1,93 @@
+const jetpack = require('fs-jetpack');
+
+const MAX_RETRIES = 3;
+const RETRY_DELAY_MS = 1000;
+const DEFAULT_MAX_SIGNUPS_PER_DAY = 2;
+
+/**
+ * Resolve the per-IP daily signup cap the beforeUserCreated guard enforces.
+ *
+ * Config home: targets.backend.auth.signup.maxPerIpPerDay, which the config
+ * loader overlays at the top level like every other target key. The value is a
+ * positive integer (@omega.js/config hard-fails anything else), so a value that
+ * still arrives broken keeps the framework default instead of leaving the guard
+ * running unprotected.
+ *
+ * @param {object} config - The resolved config (Manager.config).
+ * @returns {number} Signups allowed per client IP per day.
+ */
+function resolveSignupLimit(config) {
+  const limit = config?.auth?.signup?.maxPerIpPerDay;
+
+  return Number.isInteger(limit) && limit > 0 ? limit : DEFAULT_MAX_SIGNUPS_PER_DAY;
+}
+
+/**
+ * Retry a function up to maxRetries times with exponential backoff
+ */
+async function retryWrite(ctx, tag, fn) {
+  let lastError;
+
+  for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      await fn();
+      return; // Success
+    } catch (error) {
+      lastError = error;
+      ctx.error(`${tag}: Write attempt ${attempt}/${MAX_RETRIES} failed:`, error);
+
+      if (attempt < MAX_RETRIES) {
+        const delay = RETRY_DELAY_MS * Math.pow(2, attempt - 1); // Exponential backoff: 1s, 2s, 4s
+        ctx.log(`${tag}: Retrying in ${delay}ms...`);
+        await new Promise(resolve => setTimeout(resolve, delay));
+      }
+    }
+  }
+
+  throw lastError; // All retries failed
+}
+
+/**
+ * Run consumer auth hooks from hooks/auth/{eventName}.js
+ *
+ * Similar to how cron discovers hooks at hooks/cron/{schedule}/*.js,
+ * auth hooks are discovered at hooks/auth/{eventName}.js in the consumer project.
+ *
+ * For blocking functions (before-create, before-signin):
+ *   - Hook can throw HttpsError to block the operation
+ *   - Hook runs AFTER @omega.js/backend's core checks (disposable email, rate limiting, etc.)
+ *
+ * For trigger functions (on-create, on-delete):
+ *   - Hook errors are logged but don't block the operation
+ *
+ * Hook signature:
+ *   module.exports = async ({ Manager, ctx, user, context, libraries }) => { ... }
+ *
+ * Consumer project structure:
+ *   functions/
+ *     hooks/
+ *       auth/
+ *         before-create.js   — runs after @omega.js/backend checks, can block signup
+ *         before-signin.js   — runs after @omega.js/backend signin logic, can block signin
+ *         on-create.js       — runs after @omega.js/backend creates user doc
+ *         on-delete.js       — runs after @omega.js/backend deletes user doc
+ */
+async function runAuthHook(eventName, args) {
+  const { Manager, ctx } = args;
+  const hookPath = `${Manager.cwd}/hooks/auth/${eventName}.js`;
+
+  // Check if hook file exists
+  if (!jetpack.exists(hookPath)) {
+    return;
+  }
+
+  ctx.log(`${eventName}: Running consumer hook @ ${hookPath}`);
+
+  // Load and execute — passes the same args object the @omega.js/backend handler received
+  const hook = require(hookPath);
+  await hook(args);
+
+  ctx.log(`${eventName}: Consumer hook completed`);
+}
+
+module.exports = { retryWrite, runAuthHook, resolveSignupLimit, MAX_RETRIES, DEFAULT_MAX_SIGNUPS_PER_DAY };

package/dist/manager/events/cron/daily/blog-auto-publisher.js

@@ -0,0 +1,287 @@
+/**
+ * Blog Auto Publisher — daily cron job.
+ *
+ * Generates and publishes blog posts using a provider-based article engine
+ * (default: Ghostii). Iterates `config.blog.content[]` entries, each defining
+ * a source pool (generic topics, URLs, text prompts, RSS/Atom feeds, or parent
+ * server sources) and per-entry overrides for the provider API params.
+ *
+ * Source types:
+ *   '$brand'            — generic brand-topic generation
+ *   '$feed:<url>'       — RSS/Atom/JSON feed: pick one unprocessed article per run
+ *   '$parent'           — fetch sources from parent server's source pool (without claiming)
+ *   'https://...'       — fetch URL content as prompt seed
+ *   '<text>'            — use directly as prompt seed
+ *
+ * Source picking, fallback hierarchy, Firestore dedup, and tracking live in
+ * the shared source-resolver library — the SAME resolution the newsletter
+ * generator uses. Per article, ONE random source is picked from the pool;
+ * failures follow the type hierarchy ($feed → other feeds → $parent; $parent
+ * → other parent items; NOTHING falls back to $brand).
+ */
+const powertools = require('node-powertools');
+const moment = require('moment');
+
+const {
+  PROMPT_SOURCE,
+  PROMPT,
+  resolveSources,
+  trackContentSource,
+  getRecentTitles,
+} = require('../../../libraries/content/source-resolver.js');
+
+let postId;
+
+module.exports = async ({ Manager, ctx, context, libraries }) => {
+  // External boundary (live feed fetches + AI generation + publishing) — the
+  // cron entry gates itself like every other external call. Ungated, a normal
+  // test run harvests real feeds from the consumer's blog config, delaying the
+  // serial omega_cronDaily sequence past the usage suite's reset-usage deadline.
+  if (ctx.isTesting() && !process.env.TEST_EXTENDED_MODE) {
+    ctx.log('Blog auto-publisher skipped (test mode without TEST_EXTENDED_MODE)');
+    return;
+  }
+
+  if (!Manager.config.blog?.enabled) {
+    ctx.log('Blog auto-publisher disabled in config');
+    return;
+  }
+
+  ctx.log('Starting...');
+
+  postId = moment().unix();
+
+  const brandConfig = buildBrandConfig(Manager.config);
+  ctx.log('Brand config', brandConfig);
+
+  const blog = Manager.config.blog;
+  const contentArray = powertools.arrayify(blog.content);
+  const { admin } = libraries;
+
+  const providerName = Object.keys(blog.providers || {}).find((key) => blog.providers[key]) || 'ghostii';
+  const provider = require(`../../../libraries/content/${providerName}.js`);
+
+  for (const entry of contentArray) {
+    entry.quantity = entry.quantity || 0;
+    entry.sources = entry.sources || [];
+    entry.links = randomize(entry.links || []);
+    entry.instructions = entry.instructions || '';
+    entry.tone = entry.tone || 'professional';
+    entry.categories = entry.categories || [];
+    entry.keywords = entry.keywords || [];
+    entry.chance = entry.chance || 1.0;
+    entry.author = entry.author || undefined;
+    entry.postPath = entry.postPath || providerName;
+    entry.overrides = entry.overrides || {};
+
+    if (entry.brand && entry.brandUrl) {
+      entry.brand = await fetchRemoteBrand(entry.brandUrl).catch((e) => e);
+      if (entry.brand instanceof Error) {
+        ctx.error('Error fetching remote brand data', entry.brand);
+        continue;
+      }
+    } else {
+      entry.brand = brandConfig;
+    }
+
+    ctx.log(`Entry (brand=${entry.brand.brand.id})`, entry);
+
+    if (!entry.quantity || !entry.sources.length) {
+      ctx.log('Quitting because quantity is 0 or no sources');
+      continue;
+    }
+
+    const chance = Math.random();
+    if (chance > entry.chance) {
+      ctx.log(`Quitting because the chance is not met (${chance} <= ${entry.chance})`);
+      continue;
+    }
+
+    const result = await harvest(ctx, entry, admin, provider, Manager).catch((e) => e);
+    if (result instanceof Error) {
+      throw result;
+    }
+
+    ctx.log('Finished!', result);
+  }
+};
+
+function buildBrandConfig(config) {
+  const { buildPublicConfig } = require(require('path').join(__dirname, '..', '..', '..', 'routes', 'brand', 'get.js'));
+  return buildPublicConfig(config);
+}
+
+function fetchRemoteBrand(brandUrl) {
+  const fetch = require('wonderful-fetch');
+  return fetch(`${brandUrl}/omega/brand`, {
+    timeout: 120000,
+    tries: 3,
+    response: 'json',
+  });
+}
+
+async function harvest(ctx, entry, admin, provider, Manager) {
+  ctx.log(`harvest(): Starting ${entry.brand.brand.id}...`);
+
+  const recentTitles = admin
+    ? await getRecentTitles(admin, entry.brand.brand.id).catch((e) => {
+        ctx.error('harvest(): Error fetching recent titles (continuing)', e);
+        return [];
+      })
+    : [];
+  const runTitles = [];
+
+  if (recentTitles.length) {
+    ctx.log(`harvest(): ${recentTitles.length} recent titles loaded for topic dedup`);
+  }
+
+  for (let index = 0; index < entry.quantity; index++) {
+    ctx.log(`harvest(): Processing ${index + 1}/${entry.quantity}`);
+
+    const allKnownTitles = [...recentTitles, ...runTitles];
+
+    // ONE random source per article — fallback hierarchy handled by the resolver.
+    // Tracking between iterations means the next resolve sees this run's usage.
+    const [source] = await resolveSources({
+      sources: entry.sources,
+      count: 1,
+      categories: entry.categories,
+      admin,
+      Manager,
+      ctx,
+    });
+
+    if (!source) {
+      ctx.log('harvest(): No source could be resolved for this article, skipping');
+      continue;
+    }
+
+    const resolved = buildPromptFromSource(source, entry);
+
+    if (allKnownTitles.length) {
+      resolved.description += `\n\nTOPIC DEDUPLICATION (STRICT):\n`
+        + `These articles were RECENTLY published on our blog. You MUST NOT write about the same topic, theme, or subject area as ANY of them.\n`
+        + `Do NOT cover the same story from a different angle, do NOT write about the same theme with different examples, `
+        + `and do NOT reuse the same primary keyword/category combination. `
+        + `If a recent article covers "lifestyle tech + habits", do NOT write about "lifestyle tech + policy" — that is the SAME theme. `
+        + `Pick an entirely different domain.\n`
+        + `Recent articles:\n${allKnownTitles.slice(0, 25).map((t) => `- ${t}`).join('\n')}`;
+    }
+
+    ctx.log('harvest(): Resolved source', { type: source.type, title: source.title, url: source.url });
+
+    const overrides = { ...entry.overrides };
+    if (!overrides.keywords && entry.keywords.length) {
+      overrides.keywords = entry.keywords;
+    }
+
+    const article = await provider.writeArticle({
+      brand: entry.brand,
+      description: resolved.description,
+      links: entry.links,
+      sourceContent: resolved.sourceContent || '',
+      overrides: overrides,
+    }).catch((e) => e);
+    if (article instanceof Error) {
+      ctx.error('harvest(): Error requesting article from provider', article);
+      break;
+    }
+
+    ctx.log('harvest(): Article', article);
+
+    const post = provider.blocksToPost?.(article.json);
+    const generatedTitle = post?.title || article.title || '';
+
+    const publishArgs = {
+      brand: entry.brand,
+      article,
+      id: postId++,
+      author: entry.author,
+      postPath: entry.postPath,
+      source: source.trackingData?.url || null,
+    };
+    ctx.log('harvest(): publishArgs', publishArgs);
+
+    const uploadedPost = await provider.publishArticle(ctx, publishArgs).catch((e) => e);
+    if (uploadedPost instanceof Error) {
+      ctx.error('harvest(): Error uploading post to blog', uploadedPost);
+      break;
+    }
+
+    ctx.log('harvest(): Uploaded post', uploadedPost);
+
+    if (generatedTitle) {
+      runTitles.push(generatedTitle);
+    }
+    if (source.trackingData?.itemTitle) {
+      runTitles.push(source.trackingData.itemTitle);
+    }
+
+    // Mark the source used ONLY now that the article actually published.
+    // $brand/url/text picks have no trackingData — synthesize one for $brand
+    // so recent-title dedup still sees the post.
+    const trackingData = source.trackingData || {
+      url: uploadedPost.slug || `brand-${postId}`,
+      origin: '$brand',
+    };
+
+    if (admin) {
+      await trackContentSource(admin, {
+        ...trackingData,
+        usedBy: 'blog',
+        brandId: entry.brand.brand.id,
+        postUrl: uploadedPost.url,
+        postSlug: uploadedPost.slug,
+        postTitle: generatedTitle || null,
+      }).catch((e) => {
+        ctx.error('harvest(): Error tracking content source (non-fatal)', e);
+      });
+    }
+  }
+}
+
+/**
+ * Map a resolved source to the provider prompt shape.
+ * feed/parent sources rewrite an existing article (PROMPT_SOURCE);
+ * brand/url/text sources seed a fresh topic (PROMPT).
+ *
+ * @param {object} source - resolved source from resolveSources()
+ * @param {object} entry - the blog content entry
+ * @returns {{ description: string, sourceContent: string }}
+ */
+function buildPromptFromSource(source, entry) {
+  const templateVars = {
+    ...entry,
+    instructions: entry.instructions,
+    date: moment().format('MMMM YYYY'),
+    tone: entry.tone || '',
+    categories: (entry.categories || []).join(', '),
+    keywords: (entry.keywords || []).join(', '),
+  };
+
+  if (source.type === 'feed' || source.type === 'parent') {
+    return {
+      description: powertools.template(PROMPT_SOURCE, {
+        ...templateVars,
+        sourceTitle: source.title,
+      }),
+      sourceContent: source.content || '',
+    };
+  }
+
+  const suggestion = source.type === 'brand'
+    ? 'Write an article about any topic that would be relevant to our website and business (it does not have to be about our company, but it can be)'
+    : source.content;
+
+  return {
+    description: powertools.template(PROMPT, {
+      ...templateVars,
+      suggestion: suggestion,
+    }),
+    sourceContent: '',
+  };
+}
+
+function randomize(array) {
+  return array.sort(() => Math.random() - 0.5);
+}

package/dist/manager/events/cron/daily/data-requests.js

@@ -0,0 +1,57 @@
+/**
+ * Data requests cron job
+ *
+ * Processes data request status transitions:
+ * - pending → completed: 14 days after creation
+ * - completed → expired: 30 days after becoming completed (44 days after creation)
+ *
+ * Scans the entire collection (no index required) since data-requests is small.
+ */
+module.exports = async ({ Manager, ctx, context, libraries }) => {
+  const { admin } = libraries;
+  const nowUNIX = Math.round(Date.now() / 1000);
+
+  const FOURTEEN_DAYS = 14 * 24 * 60 * 60;
+  const FORTY_FOUR_DAYS = 44 * 24 * 60 * 60;
+
+  ctx.log('Starting...');
+
+  // Only fetch requests created within the last 45 days (single-field filter, no composite index needed)
+  const snapshot = await admin.firestore()
+    .collection('data-requests')
+    .where('metadata.created.timestampUNIX', '>', nowUNIX - FORTY_FOUR_DAYS - 86400)
+    .get();
+
+  ctx.log(`Found ${snapshot.size} total data requests`);
+
+  let completed = 0;
+  let expired = 0;
+
+  for (const doc of snapshot.docs) {
+    const data = doc.data();
+    const createdUNIX = data.metadata?.created?.timestampUNIX || 0;
+    const age = nowUNIX - createdUNIX;
+
+    if (data.status === 'pending' && age >= FOURTEEN_DAYS) {
+      await doc.ref.update({ status: 'completed' })
+        .then(() => {
+          completed++;
+          ctx.log(`Completed request ${doc.id} (age: ${Math.round(age / 86400)}d)`);
+        })
+        .catch((e) => {
+          ctx.error(`Failed to complete request ${doc.id}: ${e.message}`);
+        });
+    } else if (data.status === 'completed' && age >= FORTY_FOUR_DAYS) {
+      await doc.ref.update({ status: 'expired' })
+        .then(() => {
+          expired++;
+          ctx.log(`Expired request ${doc.id} (age: ${Math.round(age / 86400)}d)`);
+        })
+        .catch((e) => {
+          ctx.error(`Failed to expire request ${doc.id}: ${e.message}`);
+        });
+    }
+  }
+
+  ctx.log(`Completed! (${completed} completed, ${expired} expired)`);
+};