backend-manager 5.0.122 → 5.0.124

package/CHANGELOG.md

@@ -14,6 +14,54 @@ 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.123] - 2026-03-10
+### Added
+- Dispute alert system: `POST /payments/dispute-alert` endpoint with Chargeblast processor for ingesting payment dispute webhooks
+- Firestore trigger (`payments-disputes/{alertId}`) that matches disputes to Stripe invoices by date/amount/card, auto-refunds, and cancels subscriptions
+- Discount code system: `GET /payments/discount` validation endpoint and `discount-codes.js` library (FLASH20, SAVE10, WELCOME15)
+- Discount code integration in payment intent flow — auto-creates/reuses Stripe and Chargebee coupons with deterministic IDs
+- Meta Conversions API and TikTok Events API tracking alongside existing GA4 in payment analytics
+- Subscription renewal tracking as payment events (fires on `invoice.payment_succeeded` / `PAYMENT.SALE.COMPLETED` even without a state transition)
+- `attribution`, `discount`, and `supplemental` fields on payment intent schema for checkout context tracking
+- Intent data (attribution, discount, supplemental) propagated to order objects during webhook on-write
+- `meta.pixelId` and `tiktok.pixelCode` fields in config template
+- Journey test accounts for discount and attribution flows
+- Tests for discount validation and dispute alert endpoints
+
+### Changed
+- Renamed config key `google_analytics` → `googleAnalytics`
+- Payment analytics rewritten with independent per-platform fire functions (`fireGA4`, `fireMeta`, `fireTikTok`)
+- Test runner module resolution now tries normal resolution first before falling back to search paths
+- reCAPTCHA marketing contact test skipped when `TEST_EXTENDED_MODE` is not set
+
+# [5.0.122] - 2026-03-09
+### Added
+- Abandoned cart reminder system: sends escalating emails at 15min, 3h, 24h, 48h, 72h to users who visit checkout but don't complete payment
+- `payments-carts/{uid}` Firestore collection with security rules (client-side write, server-side completion)
+- `bm_cronFrequent` Cloud Function running every 10 minutes for sub-daily cron jobs
+- Shared cron runner (`cron/runner.js`) consolidating daily and frequent cron orchestrators
+- `main/order/refunded` and `main/order/abandoned-cart` email templates
+- Firestore rules test for `payments-carts` (12 test cases)
+
+### Changed
+- Migrated v1 email templates to v2 SendGrid template IDs
+- `cron/daily.js` and `cron/frequent.js` now delegate to shared `cron/runner.js`
+- Payment analytics tracking now fires independently of transitions
+
+# [5.0.120] - 2026-03-09
+### Added
+- reCAPTCHA verification on `POST /payments/intent` route (reads `verification.g-recaptcha-response` from request body)
+- Shared `libraries/recaptcha.js` module for reCAPTCHA token verification (replaces duplicate helpers)
+- `verification` field in `payments/intent` schema to accept the reCAPTCHA token object
+
+### Security
+- reCAPTCHA failure responses now return generic "Request could not be verified" (403) instead of revealing the verification mechanism
+- reCAPTCHA verification runs in all environments except automated tests (`isTesting()`)
+
+### Changed
+- Marketing contact routes (`POST /marketing/contact`, `bm_api add-marketing-contact`) now use shared `recaptcha.verify()` instead of inline helpers
+- Marketing reCAPTCHA checks skip during automated tests (consistent with payment intent)
+
 # [5.0.119] - 2026-03-07
 ### Added
 - `POST /marketing/email-preferences` route for unsubscribe/resubscribe via SendGrid ASM suppression groups

package/CLAUDE.md

@@ -646,44 +646,43 @@ npx bm firestore:delete users/test123 --emulator
 
 ### Overview
 
-Usage is tracked per-metric (e.g., `requests`, `marketing-subscribe`) with two counters:
-- `period`: Current month's count, reset on the 1st of each month
+Usage is tracked per-metric (e.g., `requests`, `sponsorships`) with four fields:
+- `monthly`: Current month's count, reset on the 1st of each month by cron
+- `daily`: Current day's count, reset every day by cron
 - `total`: All-time count, never resets
+- `last`: Object with `id`, `timestamp`, `timestampUNIX` of the last usage event
 
-### Product Rate Limit Modes
+### Limits & Daily Caps
 
-Products can set a `rateLimit` field to control how limits are enforced:
+Limits are always specified as **monthly** values in product config (e.g., `limits.requests = 100` means 100/month).
 
-| Value | Behavior | Default |
-|-------|----------|---------|
-| `'monthly'` | Full monthly limit available at any time | Yes |
-| `'daily'` | Proportional daily cap: `ceil(limit * dayOfMonth / daysInMonth)` | No |
+By default, limits are enforced with **daily caps** to prevent users from burning their entire monthly quota in a single day. Two checks are applied:
 
-Example config (not in the template — add per-product as needed):
+1. **Flat daily cap**: `ceil(monthlyLimit / daysInMonth)` — max uses per day
+   - e.g., 100/month in a 31-day month = `ceil(100/31)` = 4/day
+2. **Proportional monthly cap**: `ceil(monthlyLimit * dayOfMonth / daysInMonth)` — running total
+   - Prevents accumulating too much too fast even within daily limits
+   - e.g., Day 15 of a 30-day month with 100/month limit = max 50 used so far
+
+Products can opt out of daily caps by setting `rateLimit: 'monthly'` (default is `'daily'`):
 ```json
 {
   "id": "basic",
   "limits": { "requests": 100 },
-  "rateLimit": "daily"
+  "rateLimit": "monthly"
 }
 ```
 
-With `rateLimit: 'daily'` and 100 requests/month in a 30-day month:
-- Day 1: max 4 requests used so far
-- Day 15: max 50 requests used so far
-- Day 30: max 100 requests (full allocation)
-
-Unused days roll forward — a user who doesn't use the product for 2 weeks can use a burst later.
-
 ### Reset Schedule
 
 | Target | Frequency | What happens |
 |--------|-----------|-------------|
 | Local storage | Daily | Cleared entirely |
 | `usage` collection (unauthenticated) | Daily | Deleted entirely |
-| User doc `usage.*.period` (authenticated) | Monthly (1st) | Reset to 0 |
+| User doc `usage.*.daily` (authenticated) | Daily | Reset to 0 |
+| User doc `usage.*.monthly` (authenticated) | Monthly (1st) | Reset to 0 |
 
-The daily cron runs at midnight UTC (`0 0 * * *`). Authenticated user period resets only execute on the 1st of the month.
+The daily cron (`reset-usage.js`) runs at midnight UTC. It collects all users with non-zero counters across all metrics, then performs a single write per user to reset daily (and monthly on the 1st).
 
 ## Subscription System
 

package/README.md

@@ -139,7 +139,7 @@ Create `backend-manager-config.json` in your functions directory:
   sentry: {
     dsn: 'https://xxx@xxx.ingest.sentry.io/xxx',
   },
-  google_analytics: {
+  googleAnalytics: {
     id: 'G-XXXXXXXXXX',
     secret: 'your-ga4-secret',
   },
@@ -473,7 +473,7 @@ const userProps = Manager.User(existingData, { defaults: true }).properties;
   affiliate: { code, referrals, referrer },
   activity: { lastActivity, created, geolocation, client },
   api: { clientId, privateKey },
-  usage: { requests: { period, total, last } },
+  usage: { requests: { monthly, daily, total, last } },
   personal: { birthday, gender, location, name, company, telephone },
   oauth2: {}
 }
@@ -519,13 +519,13 @@ const usage = await Manager.Usage().init(assistant, {
 });
 
 // Check and validate limits
-const currentUsage = usage.getUsage('requests');  // Get current period usage
-const limit = usage.getLimit('requests');         // Get plan limit
-await usage.validate('requests');                 // Throws if over limit
+const currentUsage = usage.getUsage('requests');  // Get current monthly usage
+const limit = usage.getLimit('requests');         // Get plan limit (monthly)
+await usage.validate('requests');                 // Throws if over daily or monthly limit
 
-// Increment usage
+// Increment usage (increments monthly, daily, and total counters)
 usage.increment('requests', 1);
-usage.set('requests', 0);  // Reset to specific value
+usage.set('requests', 0);  // Reset monthly to specific value
 
 // Save to Firestore
 await usage.update();

package/package.json

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

package/src/manager/cron/daily/reset-usage.js

@@ -4,7 +4,8 @@
  * Runs daily at midnight UTC and handles different reset schedules:
  * - Local storage: cleared every day
  * - Unauthenticated usage collection: deleted every day
- * - Authenticated user period counters: reset on the 1st (or 2nd as grace window) of each month
+ * - Authenticated user daily counters: reset every day
+ * - Authenticated user monthly counters: reset on the 1st of each month
  */
 module.exports = async ({ Manager, assistant, context, libraries }) => {
   const storage = Manager.storage({ name: 'usage', temporary: true, clear: false, log: false });
@@ -12,24 +13,18 @@ module.exports = async ({ Manager, assistant, context, libraries }) => {
   assistant.log('Starting...');
 
   // Clear local storage (daily)
-  await clearLocal(assistant, storage);
+  clearLocal(assistant, storage);
 
   // Clear unauthenticated usage collection (daily)
   await clearUnauthenticatedUsage(assistant, libraries);
 
-  // Reset authenticated user periods (monthly - 1st or 2nd of month)
-  await resetAuthenticatedUsage(Manager, assistant, libraries);
+  // Reset authenticated user counters (daily + monthly on 1st)
+  await resetAuthenticated(Manager, assistant);
 };
 
-async function clearLocal(assistant, storage) {
-  assistant.log('[local]: Starting...');
-
-  assistant.log('[local]: storage(apps)', storage.get('apps', {}).value());
-  assistant.log('[local]: storage(users)', storage.get('users', {}).value());
-
-  // Clear storage
+function clearLocal(assistant, storage) {
+  assistant.log('[local]: Clearing...');
   storage.setState({}).write();
-
   assistant.log('[local]: Completed!');
 }
 
@@ -40,96 +35,107 @@ async function clearUnauthenticatedUsage(assistant, libraries) {
 
   await admin.firestore().recursiveDelete(admin.firestore().collection('usage'))
   .then(() => {
-    assistant.log('[unauthenticated]: Deleted usage collection');
+    assistant.log('[unauthenticated]: Completed!');
   })
   .catch((e) => {
     assistant.errorify(`Error deleting usage collection: ${e}`, { code: 500, log: true });
   });
 }
 
-async function resetAuthenticatedUsage(Manager, assistant, libraries) {
-  const { admin } = libraries;
-  const dayOfMonth = new Date().getDate();
-
-  // Only reset on the 1st of the month
-  if (dayOfMonth !== 1) {
-    assistant.log('[authenticated]: Skipping period reset (not the 1st of the month)');
-    return;
-  }
-
-  assistant.log('[authenticated]: Monthly reset starting...');
-
-  // Gather all unique metric names from ALL products
+async function resetAuthenticated(Manager, assistant) {
+  const isFirstOfMonth = new Date().getDate() === 1;
   const products = Manager.config.payment?.products || [];
-  const metrics = {};
 
+  // Gather all metric names from all products
+  const metricSet = { requests: true };
   for (const product of products) {
-    const limits = product.limits || {};
-
-    for (const key of Object.keys(limits)) {
-      metrics[key] = true;
+    for (const key of Object.keys(product.limits || {})) {
+      metricSet[key] = true;
     }
   }
+  const metricNames = Object.keys(metricSet);
 
-  // Ensure requests is always included
-  metrics.requests = true;
+  assistant.log(`[authenticated]: Resetting ${isFirstOfMonth ? 'daily + monthly' : 'daily'} for metrics`, metricNames);
 
-  const metricNames = Object.keys(metrics);
+  // Collect all user IDs that need resetting (deduplicated across metrics)
+  // Each entry maps uid -> { ref, usage } so we only write once per user
+  const usersToReset = {};
 
-  assistant.log('[authenticated]: Resetting metrics', metricNames);
-
-  // Reset each metric for users who have usage > 0
   for (const metric of metricNames) {
-    assistant.log(`[authenticated]: Resetting ${metric} for all users`);
-
-    await Manager.Utilities().iterateCollection((batch, index) => {
-      return new Promise(async (resolve, reject) => {
+    // Query users with daily > 0 for this metric
+    await Manager.Utilities().iterateCollection((batch) => {
+      return new Promise(async (resolve) => {
         for (const doc of batch.docs) {
-          const data = doc.data();
-
-          // Normalize the metric
-          data.usage = data.usage || {};
-          data.usage[metric] = data.usage[metric] || {};
-          data.usage[metric].period = data.usage[metric].period || 0;
-          data.usage[metric].total = data.usage[metric].total || 0;
-          data.usage[metric].last = data.usage[metric].last || {};
-
-          // Skip if already 0
-          if (data.usage[metric].period <= 0) {
-            continue;
+          if (!usersToReset[doc.id]) {
+            usersToReset[doc.id] = { ref: doc.ref, usage: doc.data().usage || {} };
           }
-
-          // Reset the metric
-          const original = data.usage[metric].period;
-          data.usage[metric].period = 0;
-
-          // Update the doc
-          await doc.ref.update({ usage: data.usage })
-          .then(r => {
-            assistant.log(`[authenticated]: Reset ${metric} for ${doc.id} (${original} -> 0)`);
-          })
-          .catch(e => {
-            assistant.errorify(`Error resetting ${metric} for ${doc.id}: ${e}`, { code: 500, log: true });
-          });
         }
-
         return resolve();
       });
     }, {
       collection: 'users',
       where: [
-        { field: `usage.${metric}.period`, operator: '>', value: 0 },
+        { field: `usage.${metric}.daily`, operator: '>', value: 0 },
       ],
       batchSize: 5000,
-      log: true,
+      log: false,
     })
-    .then((r) => {
-      assistant.log(`[authenticated]: Reset ${metric} for all users complete!`);
+    .catch(e => {
+      assistant.errorify(`Error querying ${metric}.daily: ${e}`, { code: 500, log: true });
+    });
+
+    // On the 1st, also query users with monthly > 0
+    if (isFirstOfMonth) {
+      await Manager.Utilities().iterateCollection((batch) => {
+        return new Promise(async (resolve) => {
+          for (const doc of batch.docs) {
+            if (!usersToReset[doc.id]) {
+              usersToReset[doc.id] = { ref: doc.ref, usage: doc.data().usage || {} };
+            }
+          }
+          return resolve();
+        });
+      }, {
+        collection: 'users',
+        where: [
+          { field: `usage.${metric}.monthly`, operator: '>', value: 0 },
+        ],
+        batchSize: 5000,
+        log: false,
+      })
+      .catch(e => {
+        assistant.errorify(`Error querying ${metric}.monthly: ${e}`, { code: 500, log: true });
+      });
+    }
+  }
+
+  const userIds = Object.keys(usersToReset);
+  assistant.log(`[authenticated]: Found ${userIds.length} users to reset`);
+
+  // Single write per user: reset daily (always) + monthly (on 1st) for all metrics
+  for (const uid of userIds) {
+    const { ref, usage } = usersToReset[uid];
+
+    for (const metric of metricNames) {
+      if (!usage[metric]) {
+        continue;
+      }
+
+      usage[metric].daily = 0;
+
+      if (isFirstOfMonth) {
+        usage[metric].monthly = 0;
+      }
+    }
+
+    await ref.update({ usage })
+    .then(() => {
+      assistant.log(`[authenticated]: Reset ${uid}`);
     })
     .catch(e => {
-      assistant.errorify(`Error resetting ${metric} for all users: ${e}`, { code: 500, log: true });
+      assistant.errorify(`Error resetting ${uid}: ${e}`, { code: 500, log: true });
     });
   }
 
-  assistant.log('[authenticated]: Monthly reset completed!');
+  assistant.log(`[authenticated]: Completed!`);
 }

package/src/manager/cron/daily.js

@@ -1,54 +1,3 @@
-const jetpack = require('fs-jetpack');
+const run = require('./runner.js');
 
-/**
- * Daily cron job runner
- *
- * Executes all daily jobs from:
- * 1. BEM core jobs (src/manager/cron/daily/)
- * 2. Custom project jobs (functions/hooks/cron/daily/)
- */
-module.exports = async ({ Manager, assistant, context, libraries }) => {
-  // Set log prefix
-  assistant.setLogPrefix('cron/daily()');
-
-  // Log
-  assistant.log('Starting...');
-
-  // Load BEM jobs
-  await loadAndExecuteJobs(`${__dirname}/daily`, Manager, context);
-
-  // Load custom jobs
-  await loadAndExecuteJobs(`${Manager.cwd}/hooks/cron/daily`, Manager, context);
-};
-
-async function loadAndExecuteJobs(jobsPath, Manager, context) {
-  const jobs = jetpack.list(jobsPath) || [];
-
-  // Log
-  Manager.assistant.log(`Located ${jobs.length} jobs @ ${jobsPath}...`);
-
-  for (const job of jobs) {
-    // Create new assistant for each job
-    const assistant = Manager.Assistant();
-
-    // Load job
-    const jobName = job.replace('.js', '');
-
-    // Set log prefix
-    assistant.setLogPrefix(`cron/daily/${jobName}()`);
-
-    // Log
-    assistant.log('Starting...');
-
-    try {
-      // Load and execute job
-      const handler = require(`${jobsPath}/${job}`);
-      await handler({ Manager, assistant, context, libraries: Manager.libraries });
-
-      assistant.log('Completed!');
-    } catch (e) {
-      assistant.errorify(`Error executing: ${e}`, { code: 500, sentry: true });
-      throw e;
-    }
-  }
-}
+module.exports = async (options) => run('daily', options);

package/src/manager/cron/frequent/abandoned-carts.js

@@ -0,0 +1,148 @@
+const powertools = require('node-powertools');
+const { REMINDER_DELAYS, COLLECTION } = require('../../libraries/abandoned-cart-config.js');
+const { sendOrderEmail } = require('../../events/firestore/payments-webhooks/transitions/send-email.js');
+
+/**
+ * Abandoned cart reminder cron job
+ *
+ * Queries payments-carts where status is pending and nextReminderAt has passed,
+ * sends escalating email reminders, and advances or completes the tracker.
+ */
+module.exports = async ({ Manager, assistant, context, libraries }) => {
+  const { admin } = libraries;
+  const nowUNIX = Math.floor(Date.now() / 1000);
+
+  // Query all pending carts that are due for a reminder
+  const snapshot = await admin.firestore()
+    .collection(COLLECTION)
+    .where('status', '==', 'pending')
+    .where('nextReminderAt', '<=', nowUNIX)
+    .get();
+
+  if (snapshot.empty) {
+    assistant.log('No abandoned carts due for reminders');
+    return;
+  }
+
+  assistant.log(`Processing ${snapshot.size} abandoned cart reminder(s)...`);
+
+  let sent = 0;
+  let completed = 0;
+  let skipped = 0;
+
+  for (const doc of snapshot.docs) {
+    const data = doc.data();
+    const uid = data.owner;
+    const reminderIndex = data.reminderIndex || 0;
+
+    try {
+      // Fetch user doc for email sending
+      const userSnap = await admin.firestore().doc(`users/${uid}`).get();
+
+      if (!userSnap.exists) {
+        assistant.log(`User ${uid} not found, marking cart completed`);
+        await markCompleted(doc, admin, nowUNIX);
+        skipped++;
+        continue;
+      }
+
+      const userDoc = userSnap.data();
+
+      // Belt-and-suspenders: skip if user already has active paid subscription
+      if (userDoc.subscription?.status === 'active'
+        && userDoc.subscription?.product?.id !== 'basic') {
+        assistant.log(`User ${uid} now has active subscription, marking cart completed`);
+        await markCompleted(doc, admin, nowUNIX);
+        skipped++;
+        continue;
+      }
+
+      // Build checkout URL from cart data
+      const checkoutUrl = buildCheckoutUrl(Manager.project.websiteUrl, data);
+
+      // Send reminder email
+      assistant.log(`Sending abandoned cart reminder #${reminderIndex + 1} to uid=${uid}, product=${data.productId}`);
+
+      sendOrderEmail({
+        template: 'main/order/abandoned-cart',
+        subject: `Complete your ${data.productId} checkout`,
+        categories: ['order/abandoned-cart', `order/abandoned-cart/reminder-${reminderIndex + 1}`],
+        userDoc,
+        assistant,
+        data: {
+          abandonedCart: {
+            productId: data.productId,
+            type: data.type,
+            frequency: data.frequency,
+            reminderNumber: reminderIndex + 1,
+            totalReminders: REMINDER_DELAYS.length,
+            checkoutUrl: checkoutUrl,
+          },
+        },
+      });
+
+      sent++;
+
+      // Advance to next reminder or mark completed if this was the last one
+      const nextIndex = reminderIndex + 1;
+
+      if (nextIndex >= REMINDER_DELAYS.length) {
+        assistant.log(`Last reminder sent for uid=${uid}, marking cart completed`);
+        await markCompleted(doc, admin, nowUNIX);
+        completed++;
+      } else {
+        const now = powertools.timestamp(new Date(), { output: 'string' });
+        const updatedNowUNIX = powertools.timestamp(now, { output: 'unix' });
+
+        await doc.ref.set({
+          reminderIndex: nextIndex,
+          nextReminderAt: updatedNowUNIX + REMINDER_DELAYS[nextIndex],
+          metadata: {
+            updated: {
+              timestamp: now,
+              timestampUNIX: updatedNowUNIX,
+            },
+          },
+        }, { merge: true });
+
+        assistant.log(`Advanced uid=${uid} to reminder index ${nextIndex}, next at ${updatedNowUNIX + REMINDER_DELAYS[nextIndex]}`);
+      }
+    } catch (e) {
+      assistant.error(`Error processing abandoned cart for uid=${uid}: ${e.message}`, e);
+      // Continue to next document
+    }
+  }
+
+  assistant.log(`Completed! (${sent} sent, ${completed} completed, ${skipped} skipped)`);
+};
+
+/**
+ * Mark a cart document as completed
+ */
+async function markCompleted(doc, admin, nowUNIX) {
+  const now = powertools.timestamp(new Date(), { output: 'string' });
+
+  await doc.ref.set({
+    status: 'completed',
+    metadata: {
+      updated: {
+        timestamp: now,
+        timestampUNIX: nowUNIX,
+      },
+    },
+  }, { merge: true });
+}
+
+/**
+ * Build checkout URL from cart data
+ */
+function buildCheckoutUrl(baseUrl, data) {
+  const url = new URL('/payment/checkout', baseUrl);
+  url.searchParams.set('product', data.productId);
+
+  if (data.frequency) {
+    url.searchParams.set('frequency', data.frequency);
+  }
+
+  return url.toString();
+}

package/src/manager/cron/frequent.js

@@ -0,0 +1,3 @@
+const run = require('./runner.js');
+
+module.exports = async (options) => run('frequent', options);

package/src/manager/cron/runner.js

@@ -0,0 +1,60 @@
+const jetpack = require('fs-jetpack');
+
+/**
+ * Shared cron job runner
+ *
+ * Discovers and executes all .js job files from:
+ * 1. BEM core jobs directory
+ * 2. Custom project hooks directory
+ *
+ * @param {string} name - Cron schedule name (e.g., 'daily', 'frequent')
+ * @param {object} options
+ * @param {object} options.Manager - Manager instance
+ * @param {object} options.assistant - Assistant instance
+ * @param {object} options.context - Cloud Function context
+ */
+module.exports = async function run(name, { Manager, assistant, context }) {
+  // Set log prefix
+  assistant.setLogPrefix(`cron/${name}()`);
+
+  // Log
+  assistant.log('Starting...');
+
+  // Load BEM jobs
+  await loadAndExecuteJobs(name, `${__dirname}/${name}`, Manager, context);
+
+  // Load custom jobs
+  await loadAndExecuteJobs(name, `${Manager.cwd}/hooks/cron/${name}`, Manager, context);
+};
+
+async function loadAndExecuteJobs(name, jobsPath, Manager, context) {
+  const jobs = jetpack.list(jobsPath) || [];
+
+  // Log
+  Manager.assistant.log(`Located ${jobs.length} jobs @ ${jobsPath}...`);
+
+  for (const job of jobs) {
+    // Create new assistant for each job
+    const assistant = Manager.Assistant();
+
+    // Load job
+    const jobName = job.replace('.js', '');
+
+    // Set log prefix
+    assistant.setLogPrefix(`cron/${name}/${jobName}()`);
+
+    // Log
+    assistant.log('Starting...');
+
+    try {
+      // Load and execute job
+      const handler = require(`${jobsPath}/${job}`);
+      await handler({ Manager, assistant, context, libraries: Manager.libraries });
+
+      assistant.log('Completed!');
+    } catch (e) {
+      assistant.errorify(`Error executing: ${e}`, { code: 500, sentry: true });
+      throw e;
+    }
+  }
+}