backend-manager 5.0.150 → 5.0.152

package/CHANGELOG.md

@@ -14,6 +14,27 @@ 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.0.152] - 2026-03-16
+### Fixed
+- Email queue documents all stored at `emails-queue/NaN` — `powertools.random()` doesn't support string generation, replaced with `pushid()`
+
+# [5.0.151] - 2026-03-16
+### Fixed
+- AI contact inference was silently broken — `ai.request()` returns `{content, tokens, ...}` but code read `result.firstName` instead of `result.content.firstName`, so AI was never used
+- OpenAI API key not passed to AI library — now explicitly passes `BACKEND_MANAGER_OPENAI_API_KEY`
+
+### Added
+- `POST /admin/infer-contact` route for testing/debugging contact inference (admin-only, supports batch)
+- `user_personal_company` custom field in FIELDS constant for marketing provider sync
+- Company passthrough in `Marketing.add()` → SendGrid and Beehiiv providers
+- Test suite for admin/infer-contact route
+- Standalone test script (`scripts/test-infer-contact.js`)
+
+### Changed
+- Improved AI prompt: rejects placeholders/gibberish, always infers company from domain, preserves hyphenated name capitalization
+- Disabled regex fallback — returns empty when AI can't infer a real name
+- All 3 inferContact callsites (marketing/contact, user/signup, legacy add-marketing-contact) now extract and pass company
+
 # [5.0.150] - 2026-03-16
 ### Added
 - `marketing` config section in `backend-manager-config.json` — per-brand control over SendGrid and Beehiiv provider availability

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backend-manager",
-  "version": "5.0.150",
+  "version": "5.0.152",
   "description": "Quick tools for developing Firebase functions",
   "main": "src/manager/index.js",
   "bin": {

package/src/manager/functions/core/actions/api/general/add-marketing-contact.js

@@ -95,10 +95,12 @@ Module.prototype.main = function () {
 
     // Infer name if not provided
     let nameInferred = null;
+    let company = '';
     if (!firstName && !lastName) {
       nameInferred = await inferContact(email, assistant);
       firstName = nameInferred.firstName;
       lastName = nameInferred.lastName;
+      company = nameInferred.company;
     }
 
     // Add to providers
@@ -112,6 +114,7 @@ Module.prototype.main = function () {
         email,
         firstName,
         lastName,
+        company,
         source,
       });
     }

package/src/manager/libraries/email/constants.js

@@ -144,6 +144,7 @@ const FIELDS = {
 
   // User identity
   user_auth_uid:                         { source: 'user', path: 'auth.uid', type: 'text' },
+  user_personal_company:                 { source: 'user', path: 'personal.company.name', type: 'text' },
   user_personal_country:                 { source: 'user', path: 'personal.location.country', type: 'text' },
   user_metadata_signup_date:             { source: 'user', path: 'metadata.created.timestamp', type: 'date' },
   user_metadata_last_activity:           { source: 'user', path: 'metadata.updated.timestamp', type: 'date' },

package/src/manager/libraries/email/marketing/index.js

@@ -62,7 +62,7 @@ function Marketing(assistant) {
 Marketing.prototype.add = async function (options) {
   const self = this;
   const assistant = self.assistant;
-  const { email, firstName, lastName, source, customFields } = options;
+  const { email, firstName, lastName, company, source, customFields } = options;
 
   if (!email) {
     assistant.warn('Marketing.add(): No email provided, skipping');
@@ -85,6 +85,7 @@ Marketing.prototype.add = async function (options) {
         email,
         firstName,
         lastName,
+        company,
         customFields,
       }).then((r) => { results.sendgrid = r; })
     );
@@ -96,6 +97,7 @@ Marketing.prototype.add = async function (options) {
         email,
         firstName,
         lastName,
+        company,
         source,
       }).then((r) => { results.beehiiv = r; })
     );

package/src/manager/libraries/email/providers/beehiiv.js

@@ -215,20 +215,25 @@ async function getPublicationId() {
  * @param {Array<{name: string, value: string}>} [options.customFields] - Pre-built custom fields
  * @returns {{ success: boolean, id?: string, error?: string }}
  */
-async function addContact({ email, firstName, lastName, source, customFields }) {
+async function addContact({ email, firstName, lastName, company, source, customFields }) {
   const publicationId = await getPublicationId();
 
   if (!publicationId) {
     return { success: false, error: 'Publication not found' };
   }
 
+  const fields = [...(customFields || [])];
+  if (company) {
+    fields.push({ name: 'company', value: company });
+  }
+
   return addSubscriber({
     email,
     firstName,
     lastName,
     source,
     publicationId,
-    customFields: customFields || [],
+    customFields: fields,
   });
 }
 

package/src/manager/libraries/email/providers/sendgrid.js

@@ -370,7 +370,7 @@ async function listSingleSends(options) {
  * @param {object} [options.customFields] - Pre-built custom_fields object (keyed by SendGrid field IDs)
  * @returns {{ success: boolean, jobId?: string, listId?: string, error?: string }}
  */
-async function addContact({ email, firstName, lastName, customFields }) {
+async function addContact({ email, firstName, lastName, company, customFields }) {
   const contact = {
     email: email.toLowerCase(),
     first_name: firstName || undefined,
@@ -378,6 +378,15 @@ async function addContact({ email, firstName, lastName, customFields }) {
     custom_fields: customFields || {},
   };
 
+  // Add company to custom fields if provided (requires field provisioned via OMEGA)
+  if (company) {
+    const idMap = await resolveFieldIds();
+    const companyFieldId = idMap['user_personal_company'];
+    if (companyFieldId) {
+      contact.custom_fields[companyFieldId] = company;
+    }
+  }
+
   const listId = await getListId();
   const result = await upsertContacts({
     contacts: [contact],

package/src/manager/libraries/email/transactional/index.js

@@ -13,6 +13,7 @@
  */
 const _ = require('lodash');
 const moment = require('moment');
+const pushid = require('pushid');
 const MarkdownIt = require('markdown-it');
 const md = new MarkdownIt({
   html: true,
@@ -482,8 +483,7 @@ function normalizeSendAt(sendAt) {
  * build pipeline when the cron picks it up.
  */
 async function saveToEmailQueue(settings, sendAt, admin, assistant) {
-  const powertools = require('node-powertools');
-  const emailId = powertools.random(32, { type: 'alphanumeric' });
+  const emailId = pushid();
 
   // Clone and clean undefined values for Firestore
   const settingsCloned = _.cloneDeepWith(settings, (value) => {

package/src/manager/libraries/infer-contact.js

@@ -31,12 +31,14 @@ const GENERIC_DOMAINS = new Set([
 async function inferContact(email, assistant) {
   if (process.env.BACKEND_MANAGER_OPENAI_API_KEY) {
     const aiResult = await inferContactWithAI(email, assistant);
-    if (aiResult && (aiResult.firstName || aiResult.lastName)) {
+    if (aiResult) {
       return aiResult;
     }
   }
 
-  return inferContactFromEmail(email);
+  // TODO: Re-enable regex fallback if needed
+  // return inferContactFromEmail(email);
+  return { firstName: '', lastName: '', company: '', confidence: 0, method: 'none' };
 }
 
 /**
@@ -48,7 +50,7 @@ async function inferContact(email, assistant) {
  */
 async function inferContactWithAI(email, assistant) {
   try {
-    const ai = assistant.Manager.AI(assistant);
+    const ai = assistant.Manager.AI(assistant, process.env.BACKEND_MANAGER_OPENAI_API_KEY);
     const result = await ai.request({
       model: 'gpt-5-mini',
       timeout: 30000,
@@ -63,12 +65,13 @@ async function inferContactWithAI(email, assistant) {
       },
     });
 
-    if (result?.firstName !== undefined) {
+    const parsed = result?.content;
+    if (parsed?.firstName !== undefined) {
       return {
-        firstName: capitalize(result.firstName || ''),
-        lastName: capitalize(result.lastName || ''),
-        company: capitalize(result.company || ''),
-        confidence: typeof result.confidence === 'number' ? result.confidence : 0.5,
+        firstName: capitalize(parsed.firstName || ''),
+        lastName: capitalize(parsed.lastName || ''),
+        company: capitalize(parsed.company || ''),
+        confidence: typeof parsed.confidence === 'number' ? parsed.confidence : 0.5,
         method: 'ai',
       };
     }

package/src/manager/libraries/prompts/infer-contact.md

@@ -1,9 +1,19 @@
 <identity>
-You extract names and company from email addresses.
+You extract real human names and company from email addresses.
 </identity>
 
+<rules>
+- Only return a name if it is a REAL human name. If the local part contains placeholder text, gibberish, generic words, or fictional/brand names, return empty strings for firstName and lastName.
+- Placeholder/test examples that are NOT real names: firstname.lastname, first.last, asdf.qwerty, test.user, mixed.case, bobs.burgers, john.doe (this is a well-known placeholder)
+- Generic role words are NOT names: admin, info, support, hello, contact, sales, billing, noreply, webmaster, postmaster, dev, ceo
+- Single letters or initials ARE acceptable (e.g., "j" from j@company.com → firstName: "J")
+- ALWAYS infer company from the domain, even when there is no name. Generic email providers (gmail.com, yahoo.com, hotmail.com, outlook.com, aol.com, icloud.com, mail.com, protonmail.com, proton.me, zoho.com, yandex.com, gmx.com, live.com, msn.com, me.com) should return empty company.
+- Hyphenated names should preserve capitalization on both parts (e.g., jean-pierre → Jean-Pierre)
+- confidence should reflect how certain you are that the name is a REAL person's name. Placeholders and gibberish should never have confidence above 0.
+</rules>
+
 <format>
-Return ONLY valid JSON like so:
+Return ONLY valid JSON:
 {
   "firstName": "...",
   "lastName": "...",
@@ -11,12 +21,12 @@ Return ONLY valid JSON like so:
   "confidence": "..."
 }
 
-- firstName: First name (string), capitalized
-- lastName: Last name (string), capitalized
-- company: Company name (string), capitalized
-- confidence: Confidence level (number), 0-1 scale
+- firstName: First name (string), properly capitalized
+- lastName: Last name (string), properly capitalized
+- company: Company name (string), capitalized. Infer from domain (not generic providers).
+- confidence: Confidence level (number), 0-1 scale. How sure you are the name is real.
 
-If you cannot determine a name, use empty strings.
+If you cannot determine a real name, use empty strings for firstName and lastName.
 </format>
 
 <examples>
@@ -30,7 +40,7 @@ If you cannot determine a name, use empty strings.
 </example>
 <example>
 <input>support@bigcorp.io</input>
-<output>{"firstName": "", "lastName": "", "company": "Bigcorp", "confidence": 0.7}</output>
+<output>{"firstName": "", "lastName": "", "company": "Bigcorp", "confidence": 0}</output>
 </example>
 <example>
 <input>mary_jane_watson@stark-industries.com</input>
@@ -38,6 +48,26 @@ If you cannot determine a name, use empty strings.
 </example>
 <example>
 <input>info@company.org</input>
-<output>{"firstName": "", "lastName": "", "company": "Company", "confidence": 0.6}</output>
+<output>{"firstName": "", "lastName": "", "company": "Company", "confidence": 0}</output>
+</example>
+<example>
+<input>firstname.lastname@company.com</input>
+<output>{"firstName": "", "lastName": "", "company": "Company", "confidence": 0}</output>
+</example>
+<example>
+<input>asdf.qwerty@outlook.com</input>
+<output>{"firstName": "", "lastName": "", "company": "", "confidence": 0}</output>
+</example>
+<example>
+<input>jean-pierre.dupont@orange.fr</input>
+<output>{"firstName": "Jean-Pierre", "lastName": "Dupont", "company": "Orange", "confidence": 0.95}</output>
+</example>
+<example>
+<input>bobs.burgers@example.com</input>
+<output>{"firstName": "", "lastName": "", "company": "Example", "confidence": 0}</output>
+</example>
+<example>
+<input>j@company.com</input>
+<output>{"firstName": "J", "lastName": "", "company": "Company", "confidence": 0.3}</output>
 </example>
 </examples>

package/src/manager/routes/admin/infer-contact/post.js

@@ -0,0 +1,34 @@
+/**
+ * POST /admin/infer-contact - Infer contact info from email addresses
+ * Admin-only endpoint for testing/debugging the inferContact pipeline
+ */
+const { inferContact } = require('../../../libraries/infer-contact.js');
+
+module.exports = async ({ assistant, user, settings }) => {
+
+  // Require authentication
+  if (!user.authenticated) {
+    return assistant.respond('Authentication required', { code: 401 });
+  }
+
+  // Require admin
+  if (!user.roles.admin) {
+    return assistant.respond('Admin required.', { code: 403 });
+  }
+
+  // Accept single email or array of emails
+  const emails = Array.isArray(settings.emails)
+    ? settings.emails
+    : [settings.email];
+
+  const results = await Promise.all(
+    emails
+      .filter(Boolean)
+      .map(async (email) => {
+        const result = await inferContact(email, assistant);
+        return { email, ...result };
+      })
+  );
+
+  return assistant.respond({ results });
+};

package/src/manager/routes/marketing/contact/post.js

@@ -83,12 +83,14 @@ module.exports = async ({ assistant, Manager, settings, analytics }) => {
     }
   }
 
-  // Infer name if not provided
+  // Infer contact info if name not provided
   let nameInferred = null;
+  let company = '';
   if (!firstName && !lastName) {
     nameInferred = await inferContact(email, assistant);
     firstName = nameInferred.firstName;
     lastName = nameInferred.lastName;
+    company = nameInferred.company;
   }
 
   // Add to providers
@@ -102,6 +104,7 @@ module.exports = async ({ assistant, Manager, settings, analytics }) => {
       email,
       firstName,
       lastName,
+      company,
       source,
     });
   }

package/src/manager/schemas/admin/infer-contact/post.js

@@ -0,0 +1,12 @@
+module.exports = () => ({
+  email: {
+    types: ['string'],
+    default: '',
+    required: false,
+  },
+  emails: {
+    types: ['array'],
+    default: [],
+    required: false,
+  },
+});

package/test/routes/admin/infer-contact.js

@@ -0,0 +1,195 @@
+/**
+ * Test: POST /admin/infer-contact
+ * Tests the admin infer-contact endpoint for inferring names from email addresses
+ *
+ * AI inference tests only run when TEST_EXTENDED_MODE is set (requires BACKEND_MANAGER_OPENAI_API_KEY)
+ */
+module.exports = {
+  description: 'Admin infer contact',
+  type: 'group',
+  tests: [
+    // ─── Auth rejection ───
+
+    {
+      name: 'unauthenticated-rejected',
+      auth: 'none',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const response = await http.post('admin/infer-contact', {
+          email: 'john.smith@gmail.com',
+        });
+
+        assert.isError(response, 401, 'Should reject unauthenticated requests');
+      },
+    },
+
+    {
+      name: 'non-admin-rejected',
+      auth: 'user',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const response = await http.post('admin/infer-contact', {
+          email: 'john.smith@gmail.com',
+        });
+
+        assert.isError(response, 403, 'Should reject non-admin users');
+      },
+    },
+
+    // ─── Single email ───
+
+    {
+      name: 'single-email-returns-result',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert }) {
+        const response = await http.post('admin/infer-contact', {
+          email: 'john.smith@gmail.com',
+        });
+
+        assert.isSuccess(response, 'Should succeed for admin');
+        assert.hasProperty(response, 'data.results', 'Should have results array');
+        assert.equal(response.data.results.length, 1, 'Should have 1 result');
+
+        const result = response.data.results[0];
+        assert.equal(result.email, 'john.smith@gmail.com', 'Should include email');
+        assert.ok(result.firstName, 'Should infer a first name');
+        assert.ok(result.lastName, 'Should infer a last name');
+        assert.hasProperty(result, 'method', 'Should include method');
+        assert.hasProperty(result, 'confidence', 'Should include confidence');
+      },
+    },
+
+    // ─── Batch emails ───
+
+    {
+      name: 'batch-emails-returns-all-results',
+      auth: 'admin',
+      timeout: 60000,
+
+      async run({ http, assert }) {
+        const emails = [
+          'sarah.connor@skynet.io',
+          'bob-jones@hotmail.com',
+          'admin@acme.com',
+        ];
+
+        const response = await http.post('admin/infer-contact', { emails });
+
+        assert.isSuccess(response, 'Should succeed for batch');
+        assert.equal(response.data.results.length, 3, 'Should have 3 results');
+
+        // Verify each email is in results
+        for (let i = 0; i < emails.length; i++) {
+          assert.equal(response.data.results[i].email, emails[i], `Result ${i} should match input email`);
+        }
+      },
+    },
+
+    // ─── Name parsing (regex) ───
+
+    {
+      name: 'regex-parses-dot-separated-names',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert }) {
+        const response = await http.post('admin/infer-contact', {
+          email: 'alice.wonderland@example.com',
+        });
+
+        assert.isSuccess(response);
+        const result = response.data.results[0];
+
+        // AI or regex — either way should get the name right
+        assert.equal(result.firstName, 'Alice', 'Should parse first name');
+        assert.equal(result.lastName, 'Wonderland', 'Should parse last name');
+      },
+    },
+
+    {
+      name: 'infers-company-from-custom-domain',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert }) {
+        const response = await http.post('admin/infer-contact', {
+          email: 'ceo@my-startup.com',
+        });
+
+        assert.isSuccess(response);
+        const result = response.data.results[0];
+        assert.ok(result.company, 'Should infer company from custom domain');
+      },
+    },
+
+    {
+      name: 'no-company-from-generic-domain',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert }) {
+        const response = await http.post('admin/infer-contact', {
+          email: 'someone@gmail.com',
+        });
+
+        assert.isSuccess(response);
+        const result = response.data.results[0];
+        assert.equal(result.company, '', 'Should not infer company from gmail');
+      },
+    },
+
+    // ─── AI inference (requires TEST_EXTENDED_MODE) ───
+
+    {
+      name: 'ai-inference',
+      auth: 'admin',
+      timeout: 60000,
+      skip: !process.env.TEST_EXTENDED_MODE
+        ? 'TEST_EXTENDED_MODE not set (skipping AI inference test)'
+        : false,
+
+      async run({ http, assert }) {
+        const response = await http.post('admin/infer-contact', {
+          emails: [
+            'john.smith@microsoft.com',
+            'xkcd42@gmail.com',
+            'bobs.burgers@example.com',
+          ],
+        });
+
+        assert.isSuccess(response, 'AI inference should succeed');
+
+        const results = response.data.results;
+        const aiResults = results.filter(r => r.method === 'ai');
+
+        assert.ok(aiResults.length > 0, 'At least one result should use AI method');
+
+        // john.smith should be parsed correctly regardless of method
+        const john = results.find(r => r.email === 'john.smith@microsoft.com');
+        assert.equal(john.firstName, 'John', 'Should infer John');
+        assert.equal(john.lastName, 'Smith', 'Should infer Smith');
+      },
+    },
+
+    // ─── Edge cases ───
+
+    {
+      name: 'empty-emails-array-returns-empty',
+      auth: 'admin',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const response = await http.post('admin/infer-contact', {
+          emails: [],
+        });
+
+        assert.isSuccess(response);
+        assert.equal(response.data.results.length, 0, 'Empty input should return empty results');
+      },
+    },
+  ],
+};