@open-loyalty/mcp-server 1.0.3 → 1.3.1

package/dist/workflows/vod-watching.js

@@ -0,0 +1,326 @@
+/**
+ * VOD Watching Workflow
+ *
+ * Creates a campaign to reward fans for watching video content,
+ * with achievements for total watch time using attribute aggregation.
+ */
+import { campaignCreate, campaignList } from "../tools/campaign/handlers.js";
+import { achievementCreate, achievementList } from "../tools/achievement.js";
+import { badgeList } from "../tools/badge.js";
+import { formatOLDate, DEFAULTS } from "../prompts/fan-engagement-setup.js";
+// ============================================================================
+// Workflow Implementation
+// ============================================================================
+/**
+ * Execute the VOD watching workflow
+ */
+export async function executeVodWatchingWorkflow(config = {}) {
+    const result = {
+        success: false,
+        errors: [],
+        summary: "",
+    };
+    // Merge with defaults
+    const cfg = {
+        trackBy: config.trackBy ?? DEFAULTS.vodWatching.trackBy,
+        coinsPerUnit: config.coinsPerUnit ?? DEFAULTS.vodWatching.coinsPerUnit,
+        unitSize: config.unitSize ?? DEFAULTS.vodWatching.unitSize,
+        createAchievement: config.createAchievement ?? true,
+        achievementTarget: config.achievementTarget ?? DEFAULTS.vodWatching.achievementMinutes,
+        achievementBonus: config.achievementBonus ?? DEFAULTS.vodWatching.achievementBonus,
+        badgeName: config.badgeName ?? "Content Enthusiast",
+        seasonStart: config.seasonStart ?? DEFAULTS.seasonDates.start,
+        seasonEnd: config.seasonEnd ?? DEFAULTS.seasonDates.end,
+    };
+    try {
+        // Step 1: Create base VOD watching campaign
+        const watchCampaignResult = await createWatchCampaign(cfg);
+        if (watchCampaignResult.error) {
+            result.errors.push(watchCampaignResult.error);
+        }
+        else {
+            result.watchCampaignId = watchCampaignResult.campaignId;
+        }
+        // Step 2: Create achievement and bonus campaign if enabled
+        if (cfg.createAchievement) {
+            const badges = await getAvailableBadges();
+            const achievementResult = await createWatchAchievement(cfg, badges);
+            if (achievementResult.error) {
+                result.errors.push(achievementResult.error);
+            }
+            else {
+                result.achievementId = achievementResult.achievementId;
+                // Create bonus campaign for achievement
+                if (achievementResult.achievementId) {
+                    const bonusCampaignResult = await createAchievementBonusCampaign(achievementResult.achievementId, cfg);
+                    if (bonusCampaignResult.error) {
+                        result.errors.push(bonusCampaignResult.error);
+                    }
+                    else {
+                        result.bonusCampaignId = bonusCampaignResult.campaignId;
+                    }
+                }
+            }
+        }
+        // Step 3: Verify setup
+        const verification = await verifySetup(result);
+        if (verification.warnings.length > 0) {
+            result.errors.push(...verification.warnings);
+        }
+        // Determine success
+        result.success = result.watchCampaignId !== undefined && result.errors.length === 0;
+        // Build summary
+        result.summary = buildSummary(cfg, result);
+    }
+    catch (error) {
+        result.errors.push(`Workflow error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return result;
+}
+// ============================================================================
+// Helper Functions
+// ============================================================================
+async function createWatchCampaign(cfg) {
+    try {
+        const isMinutesBased = cfg.trackBy === "minutes";
+        // For minutes-based tracking, we use an expression to calculate points
+        // based on the minutes_watched attribute divided by unitSize
+        const pointsRule = isMinutesBased
+            ? {
+                expression: `Math.floor(event.minutes_watched / ${cfg.unitSize}) * ${cfg.coinsPerUnit}`,
+            }
+            : {
+                fixedValue: cfg.coinsPerUnit,
+            };
+        const description = isMinutesBased
+            ? `Earn ${cfg.coinsPerUnit} coins for every ${cfg.unitSize} minutes of video watched`
+            : `Earn ${cfg.coinsPerUnit} coins for each video viewed`;
+        const response = await campaignCreate({
+            type: "direct",
+            trigger: "custom_event",
+            event: "vod_watch",
+            translations: {
+                en: {
+                    name: "Video Content Reward",
+                    description,
+                },
+            },
+            activity: {
+                startsAt: formatOLDate(cfg.seasonStart),
+                endsAt: formatOLDate(cfg.seasonEnd),
+            },
+            rules: [
+                {
+                    name: "Award coins for watching content",
+                    effects: [
+                        {
+                            effect: "give_points",
+                            pointsRule,
+                        },
+                    ],
+                },
+            ],
+            active: true,
+        });
+        return { campaignId: response.campaignId };
+    }
+    catch (error) {
+        return {
+            error: `Failed to create VOD watch campaign: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+async function getAvailableBadges() {
+    try {
+        const response = await badgeList({});
+        const badgeMap = new Map();
+        for (const badge of response.badges) {
+            if (badge.name && badge.badgeTypeId) {
+                badgeMap.set(badge.name.toLowerCase(), badge.badgeTypeId);
+            }
+        }
+        return badgeMap;
+    }
+    catch {
+        return new Map();
+    }
+}
+async function createWatchAchievement(cfg, badges) {
+    try {
+        const badgeTypeId = cfg.badgeName
+            ? badges.get(cfg.badgeName.toLowerCase())
+            : undefined;
+        const isMinutesBased = cfg.trackBy === "minutes";
+        const targetLabel = isMinutesBased ? "minutes" : "videos";
+        /**
+         * For attribute-sum achievements, we use aggregation rule "sum" with
+         * the attribute to aggregate (e.g., "minutes_watched").
+         * The periodGoal is the total to reach.
+         */
+        const achievementPayload = {
+            translations: {
+                en: {
+                    name: `Watch ${cfg.achievementTarget} ${targetLabel}`,
+                    description: isMinutesBased
+                        ? `Watch ${cfg.achievementTarget} total minutes of video content`
+                        : `Watch ${cfg.achievementTarget} videos`,
+                },
+            },
+            active: true,
+            activity: {
+                startsAt: formatOLDate(cfg.seasonStart),
+                endsAt: formatOLDate(cfg.seasonEnd),
+            },
+            rules: [
+                {
+                    trigger: "custom_event",
+                    event: "vod_watch",
+                    completeRule: {
+                        periodGoal: cfg.achievementTarget,
+                    },
+                    // For minutes tracking, aggregate the minutes_watched attribute
+                    ...(isMinutesBased && {
+                        aggregation: {
+                            rule: "sum",
+                        },
+                    }),
+                },
+            ],
+        };
+        if (badgeTypeId) {
+            achievementPayload.badgeTypeId = badgeTypeId;
+        }
+        const response = await achievementCreate(achievementPayload);
+        return { achievementId: response.achievementId };
+    }
+    catch (error) {
+        return {
+            error: `Failed to create watch achievement: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+async function createAchievementBonusCampaign(achievementId, cfg) {
+    try {
+        const targetLabel = cfg.trackBy === "minutes" ? "minutes" : "videos";
+        const response = await campaignCreate({
+            type: "direct",
+            trigger: "achievement",
+            translations: {
+                en: {
+                    name: `Watch ${cfg.achievementTarget} ${targetLabel} Bonus`,
+                    description: `Bonus ${cfg.achievementBonus} coins for watching ${cfg.achievementTarget} ${targetLabel}`,
+                },
+            },
+            activity: {
+                startsAt: formatOLDate(cfg.seasonStart),
+                endsAt: formatOLDate(cfg.seasonEnd),
+            },
+            rules: [
+                {
+                    name: `Bonus for watching ${cfg.achievementTarget} ${targetLabel}`,
+                    effects: [
+                        {
+                            effect: "give_points",
+                            pointsRule: { fixedValue: cfg.achievementBonus },
+                        },
+                    ],
+                    conditions: [
+                        {
+                            operator: "is_equal",
+                            attribute: "achievement.achievementId",
+                            data: { value: achievementId },
+                        },
+                    ],
+                },
+            ],
+            active: true,
+        });
+        return { campaignId: response.campaignId };
+    }
+    catch (error) {
+        return {
+            error: `Failed to create bonus campaign: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+async function verifySetup(result) {
+    const warnings = [];
+    try {
+        if (result.watchCampaignId) {
+            const campaigns = await campaignList({ active: true });
+            const found = campaigns.campaigns.some((c) => c.campaignId === result.watchCampaignId);
+            if (!found) {
+                warnings.push("Watch campaign created but not found in active campaigns list");
+            }
+        }
+        if (result.achievementId) {
+            const achievements = await achievementList({ active: true });
+            const found = achievements.achievements.some((a) => a.achievementId === result.achievementId);
+            if (!found) {
+                warnings.push("Achievement created but not found in active achievements list");
+            }
+        }
+    }
+    catch (error) {
+        warnings.push(`Verification error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return { warnings };
+}
+function buildSummary(cfg, result) {
+    const lines = [];
+    const isMinutesBased = cfg.trackBy === "minutes";
+    const targetLabel = isMinutesBased ? "minutes" : "videos";
+    if (result.watchCampaignId) {
+        lines.push(`VOD watching campaign created!`);
+        lines.push(`\nTracking by: ${cfg.trackBy}`);
+        if (isMinutesBased) {
+            lines.push(`Reward: ${cfg.coinsPerUnit} coins per ${cfg.unitSize} minutes watched`);
+        }
+        else {
+            lines.push(`Reward: ${cfg.coinsPerUnit} coins per video viewed`);
+        }
+    }
+    if (result.achievementId) {
+        lines.push(`\nAchievement: Watch ${cfg.achievementTarget} ${targetLabel}`);
+        if (cfg.badgeName) {
+            lines.push(`Badge: ${cfg.badgeName}`);
+        }
+        if (result.bonusCampaignId) {
+            lines.push(`Completion bonus: ${cfg.achievementBonus} coins`);
+        }
+    }
+    lines.push(`\nSeason: ${cfg.seasonStart} to ${cfg.seasonEnd}`);
+    lines.push(`\nCustom event to trigger reward:`);
+    lines.push(`  Event: vod_watch`);
+    if (isMinutesBased) {
+        lines.push(`  Required attribute: minutes_watched (number)`);
+        lines.push(`\nExample event payload:`);
+        lines.push(`{`);
+        lines.push(`  "event": "vod_watch",`);
+        lines.push(`  "attributes": {`);
+        lines.push(`    "minutes_watched": 15`);
+        lines.push(`  }`);
+        lines.push(`}`);
+    }
+    else {
+        lines.push(`\nExample event payload:`);
+        lines.push(`{`);
+        lines.push(`  "event": "vod_watch"`);
+        lines.push(`}`);
+    }
+    if (result.errors.length > 0) {
+        lines.push(`\nWarnings/Errors:`);
+        for (const error of result.errors) {
+            lines.push(`- ${error}`);
+        }
+    }
+    return lines.join("\n");
+}
+// ============================================================================
+// Exports
+// ============================================================================
+export const vodWatchingWorkflow = {
+    id: "vod-watching",
+    name: "VOD Watching Campaign",
+    execute: executeVodWatchingWorkflow,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-loyalty/mcp-server",
-  "version": "1.0.3",
+  "version": "1.3.1",
   "type": "module",
   "description": "MCP server for Open Loyalty API - enables AI agents to manage loyalty programs, members, points, rewards, and transactions",
   "author": "Marcin Dyguda <md@openloyalty.io>",
@@ -36,7 +36,9 @@
     "test": "vitest",
     "test:run": "vitest run",
     "test:coverage": "vitest run --coverage",
-    "test:watch": "vitest --watch"
+    "test:watch": "vitest --watch",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
@@ -44,17 +46,23 @@
     "cors": "^2.8.5",
     "dotenv": "^17.2.3",
     "express": "^5.2.1",
+    "express-rate-limit": "^8.2.1",
+    "form-data": "^4.0.0",
+    "helmet": "^8.1.0",
     "ioredis": "^5.9.2",
     "zod": "^3.22.0"
   },
   "devDependencies": {
+    "@eslint/js": "^9.39.2",
     "@types/cors": "^2.8.19",
     "@types/express": "^5.0.6",
     "@types/node": "^20.10.0",
     "@vitest/coverage-v8": "^4.0.17",
     "axios-mock-adapter": "^2.1.0",
+    "eslint": "^9.39.2",
     "tsx": "^4.7.0",
     "typescript": "^5.3.0",
+    "typescript-eslint": "^8.53.1",
     "vitest": "^4.0.17"
   },
   "engines": {