backend-manager 5.0.150 → 5.0.151

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backend-manager",
-  "version": "5.0.150",
+  "version": "5.0.151",
   "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/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');
+      },
+    },
+  ],
+};