@open-loyalty/mcp-server 1.3.6 → 1.4.1

package/dist/workflows/match-attendance.js

@@ -1,308 +0,0 @@
-/**
- * Match Attendance Workflow
- *
- * Creates a complete match attendance reward program including:
- * - Base campaign for per-match coin rewards
- * - Achievements for attendance milestones (6, 12 matches, etc.)
- * - Bonus campaigns triggered by achievement completion
- */
-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 match attendance workflow
- */
-export async function executeMatchAttendanceWorkflow(config = {}) {
-    const result = {
-        success: false,
-        achievements: [],
-        errors: [],
-        summary: "",
-    };
-    // Merge with defaults
-    const cfg = {
-        coinsPerMatch: config.coinsPerMatch ?? DEFAULTS.matchAttendance.coinsPerMatch,
-        milestones: config.milestones ?? DEFAULTS.matchAttendance.milestones,
-        badgeNames: config.badgeNames ?? Object.values(DEFAULTS.matchAttendance.badges),
-        milestoneBonuses: config.milestoneBonuses ?? Object.values(DEFAULTS.matchAttendance.milestoneBonuses),
-        limitPerDay: config.limitPerDay ?? DEFAULTS.matchAttendance.limitPerDay,
-        seasonStart: config.seasonStart ?? DEFAULTS.seasonDates.start,
-        seasonEnd: config.seasonEnd ?? DEFAULTS.seasonDates.end,
-    };
-    try {
-        // Step 1: Create base match attendance campaign
-        const baseCampaignResult = await createBaseCampaign(cfg);
-        if (baseCampaignResult.error) {
-            result.errors.push(baseCampaignResult.error);
-        }
-        else {
-            result.baseCampaignId = baseCampaignResult.campaignId;
-        }
-        // Step 2: Get available badges for achievements
-        const badges = await getAvailableBadges();
-        // Step 3: Create achievements and bonus campaigns for each milestone
-        for (let i = 0; i < cfg.milestones.length; i++) {
-            const milestone = cfg.milestones[i];
-            const badgeName = cfg.badgeNames[i] || `Milestone ${milestone}`;
-            const bonus = cfg.milestoneBonuses[i] || 500;
-            const achievementResult = await createMilestoneAchievement(milestone, badgeName, badges, cfg.seasonStart, cfg.seasonEnd);
-            if (achievementResult.error) {
-                result.errors.push(achievementResult.error);
-                continue;
-            }
-            const achievementEntry = {
-                achievementId: achievementResult.achievementId,
-                milestone,
-                badgeName,
-            };
-            // Create bonus campaign for this achievement
-            if (achievementResult.achievementId) {
-                const bonusCampaignResult = await createAchievementBonusCampaign(achievementResult.achievementId, milestone, bonus, cfg.seasonStart, cfg.seasonEnd);
-                if (bonusCampaignResult.error) {
-                    result.errors.push(bonusCampaignResult.error);
-                }
-                else {
-                    achievementEntry.bonusCampaignId = bonusCampaignResult.campaignId;
-                }
-            }
-            result.achievements.push(achievementEntry);
-        }
-        // Step 4: Verify setup
-        const verification = await verifySetup(result);
-        if (verification.warnings.length > 0) {
-            result.errors.push(...verification.warnings);
-        }
-        // Build summary
-        result.success = result.baseCampaignId !== undefined && result.errors.length === 0;
-        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 createBaseCampaign(cfg) {
-    try {
-        const response = await campaignCreate({
-            type: "direct",
-            trigger: "custom_event",
-            event: "match_attendance",
-            translations: {
-                en: {
-                    name: "Match Attendance Reward",
-                    description: `Earn ${cfg.coinsPerMatch} coins for each match you attend`,
-                },
-            },
-            activity: {
-                startsAt: formatOLDate(cfg.seasonStart),
-                endsAt: formatOLDate(cfg.seasonEnd),
-            },
-            rules: [
-                {
-                    name: "Award coins for match attendance",
-                    effects: [
-                        {
-                            effect: "give_points",
-                            pointsRule: { fixedValue: cfg.coinsPerMatch },
-                        },
-                    ],
-                },
-            ],
-            limits: {
-                executionsPerMember: {
-                    value: cfg.limitPerDay,
-                    interval: { type: "days", value: 1 },
-                },
-            },
-            active: true,
-        });
-        return { campaignId: response.campaignId };
-    }
-    catch (error) {
-        return {
-            error: `Failed to create base 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 empty map if badges can't be fetched - achievements will be created without badges
-        return new Map();
-    }
-}
-async function createMilestoneAchievement(milestone, badgeName, badges, seasonStart, seasonEnd) {
-    try {
-        // Find badge ID by name (case-insensitive)
-        const badgeTypeId = badges.get(badgeName.toLowerCase());
-        // Determine the goal value (for percentage, calculate based on assumed total matches)
-        let periodGoal;
-        let achievementName;
-        let achievementDescription;
-        if (typeof milestone === "string" && milestone.includes("%")) {
-            // Percentage milestone (e.g., "80%")
-            const percentage = parseInt(milestone.replace("%", ""), 10);
-            // Assume ~19 home matches per season (typical for major football leagues)
-            periodGoal = Math.ceil(19 * (percentage / 100));
-            achievementName = `${milestone} Match Attendance`;
-            achievementDescription = `Attend ${milestone} of all home matches this season`;
-        }
-        else {
-            periodGoal = typeof milestone === "number" ? milestone : parseInt(milestone, 10);
-            achievementName = `Attend ${periodGoal} Matches`;
-            achievementDescription = `Be at ${periodGoal} home games this season`;
-        }
-        const achievementPayload = {
-            translations: {
-                en: {
-                    name: achievementName,
-                    description: achievementDescription,
-                },
-            },
-            active: true,
-            activity: {
-                startsAt: formatOLDate(seasonStart),
-                endsAt: formatOLDate(seasonEnd),
-            },
-            rules: [
-                {
-                    trigger: "custom_event",
-                    event: "match_attendance",
-                    completeRule: {
-                        periodGoal,
-                    },
-                },
-            ],
-        };
-        // Add badge if found
-        if (badgeTypeId) {
-            achievementPayload.badgeTypeId = badgeTypeId;
-        }
-        const response = await achievementCreate(achievementPayload);
-        return { achievementId: response.achievementId };
-    }
-    catch (error) {
-        return {
-            error: `Failed to create achievement for ${milestone}: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-}
-async function createAchievementBonusCampaign(achievementId, milestone, bonusCoins, seasonStart, seasonEnd) {
-    try {
-        const milestoneLabel = typeof milestone === "string" ? milestone : `${milestone} Matches`;
-        const response = await campaignCreate({
-            type: "direct",
-            trigger: "achievement",
-            translations: {
-                en: {
-                    name: `${milestoneLabel} Achievement Bonus`,
-                    description: `Bonus ${bonusCoins} coins for completing the ${milestoneLabel} achievement`,
-                },
-            },
-            activity: {
-                startsAt: formatOLDate(seasonStart),
-                endsAt: formatOLDate(seasonEnd),
-            },
-            rules: [
-                {
-                    name: `Bonus for completing ${milestoneLabel}`,
-                    effects: [
-                        {
-                            effect: "give_points",
-                            pointsRule: { fixedValue: bonusCoins },
-                        },
-                    ],
-                    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 for ${milestone}: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-}
-async function verifySetup(result) {
-    const warnings = [];
-    try {
-        // Verify campaigns exist
-        if (result.baseCampaignId) {
-            const campaigns = await campaignList({ active: true });
-            const found = campaigns.campaigns.some((c) => c.campaignId === result.baseCampaignId);
-            if (!found) {
-                warnings.push("Base campaign created but not found in active campaigns list");
-            }
-        }
-        // Verify achievements exist
-        if (result.achievements.length > 0) {
-            const achievements = await achievementList({ active: true });
-            for (const ach of result.achievements) {
-                const found = achievements.achievements.some((a) => a.achievementId === ach.achievementId);
-                if (!found) {
-                    warnings.push(`Achievement ${ach.milestone} 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 = [];
-    if (result.baseCampaignId) {
-        lines.push(`Fans will earn ${cfg.coinsPerMatch} coins per match attended`);
-    }
-    if (result.achievements.length > 0) {
-        lines.push(`\nMilestone achievements created:`);
-        for (const ach of result.achievements) {
-            const bonusText = ach.bonusCampaignId
-                ? ` (+ ${cfg.milestoneBonuses[result.achievements.indexOf(ach)] || 500} coin bonus)`
-                : "";
-            lines.push(`- ${ach.milestone} matches: ${ach.badgeName} badge${bonusText}`);
-        }
-    }
-    lines.push(`\nSeason: ${cfg.seasonStart} to ${cfg.seasonEnd}`);
-    lines.push(`Anti-fraud: Max ${cfg.limitPerDay} attendance${cfg.limitPerDay > 1 ? "s" : ""} per day`);
-    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 matchAttendanceWorkflow = {
-    id: "match-attendance",
-    name: "Match Attendance Campaign",
-    execute: executeMatchAttendanceWorkflow,
-};

package/dist/workflows/sportsbar-visit.d.ts

@@ -1,41 +0,0 @@
-/**
- * Sports Bar Visit Workflow
- *
- * Creates a campaign to reward fans for visiting the sports bar,
- * with optional achievement for visiting multiple times.
- */
-export interface SportsbarVisitConfig {
-    /** Coins awarded per visit */
-    coinsPerVisit: number;
-    /** Whether to create achievement for multiple visits */
-    createAchievement: boolean;
-    /** Number of visits for achievement milestone */
-    visitMilestone: number;
-    /** Bonus coins for completing the achievement */
-    milestoneBonus: number;
-    /** Maximum visits counted per day (anti-abuse) */
-    limitPerDay: number;
-    /** Badge name for achievement (optional) */
-    badgeName?: string;
-    /** Season start date (ISO format) */
-    seasonStart: string;
-    /** Season end date (ISO format) */
-    seasonEnd: string;
-}
-export interface SportsbarVisitResult {
-    success: boolean;
-    visitCampaignId?: string;
-    achievementId?: string;
-    bonusCampaignId?: string;
-    errors: string[];
-    summary: string;
-}
-/**
- * Execute the sports bar visit workflow
- */
-export declare function executeSportsbarVisitWorkflow(config?: Partial<SportsbarVisitConfig>): Promise<SportsbarVisitResult>;
-export declare const sportsbarVisitWorkflow: {
-    id: string;
-    name: string;
-    execute: typeof executeSportsbarVisitWorkflow;
-};

package/dist/workflows/sportsbar-visit.js

@@ -1,284 +0,0 @@
-/**
- * Sports Bar Visit Workflow
- *
- * Creates a campaign to reward fans for visiting the sports bar,
- * with optional achievement for visiting multiple times.
- */
-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 sports bar visit workflow
- */
-export async function executeSportsbarVisitWorkflow(config = {}) {
-    const result = {
-        success: false,
-        errors: [],
-        summary: "",
-    };
-    // Merge with defaults
-    const cfg = {
-        coinsPerVisit: config.coinsPerVisit ?? DEFAULTS.sportsbarVisit.coinsPerVisit,
-        createAchievement: config.createAchievement ?? true,
-        visitMilestone: config.visitMilestone ?? DEFAULTS.sportsbarVisit.visitMilestone,
-        milestoneBonus: config.milestoneBonus ?? DEFAULTS.sportsbarVisit.milestoneBonus,
-        limitPerDay: config.limitPerDay ?? DEFAULTS.sportsbarVisit.limitPerDay,
-        badgeName: config.badgeName ?? "Sports Bar Regular",
-        seasonStart: config.seasonStart ?? DEFAULTS.seasonDates.start,
-        seasonEnd: config.seasonEnd ?? DEFAULTS.seasonDates.end,
-    };
-    try {
-        // Step 1: Create base visit campaign
-        const visitCampaignResult = await createVisitCampaign(cfg);
-        if (visitCampaignResult.error) {
-            result.errors.push(visitCampaignResult.error);
-        }
-        else {
-            result.visitCampaignId = visitCampaignResult.campaignId;
-        }
-        // Step 2: Create achievement and bonus campaign if enabled
-        if (cfg.createAchievement) {
-            // Get available badges
-            const badges = await getAvailableBadges();
-            const achievementResult = await createVisitAchievement(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.visitCampaignId !== 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 createVisitCampaign(cfg) {
-    try {
-        const response = await campaignCreate({
-            type: "direct",
-            trigger: "custom_event",
-            event: "sportsbar_visit",
-            translations: {
-                en: {
-                    name: "Sports Bar Visit Reward",
-                    description: `Earn ${cfg.coinsPerVisit} coins for each visit to the sports bar`,
-                },
-            },
-            activity: {
-                startsAt: formatOLDate(cfg.seasonStart),
-                endsAt: formatOLDate(cfg.seasonEnd),
-            },
-            rules: [
-                {
-                    name: "Award coins for sports bar visit",
-                    effects: [
-                        {
-                            effect: "give_points",
-                            pointsRule: { fixedValue: cfg.coinsPerVisit },
-                        },
-                    ],
-                },
-            ],
-            limits: {
-                executionsPerMember: {
-                    value: cfg.limitPerDay,
-                    interval: { type: "days", value: 1 },
-                },
-            },
-            active: true,
-        });
-        return { campaignId: response.campaignId };
-    }
-    catch (error) {
-        return {
-            error: `Failed to create visit 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 createVisitAchievement(cfg, badges) {
-    try {
-        const badgeTypeId = cfg.badgeName
-            ? badges.get(cfg.badgeName.toLowerCase())
-            : undefined;
-        const achievementPayload = {
-            translations: {
-                en: {
-                    name: `${cfg.visitMilestone} Sports Bar Visits`,
-                    description: `Visit the sports bar ${cfg.visitMilestone} times this season`,
-                },
-            },
-            active: true,
-            activity: {
-                startsAt: formatOLDate(cfg.seasonStart),
-                endsAt: formatOLDate(cfg.seasonEnd),
-            },
-            rules: [
-                {
-                    trigger: "custom_event",
-                    event: "sportsbar_visit",
-                    completeRule: {
-                        periodGoal: cfg.visitMilestone,
-                    },
-                },
-            ],
-        };
-        if (badgeTypeId) {
-            achievementPayload.badgeTypeId = badgeTypeId;
-        }
-        const response = await achievementCreate(achievementPayload);
-        return { achievementId: response.achievementId };
-    }
-    catch (error) {
-        return {
-            error: `Failed to create visit achievement: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-}
-async function createAchievementBonusCampaign(achievementId, cfg) {
-    try {
-        const response = await campaignCreate({
-            type: "direct",
-            trigger: "achievement",
-            translations: {
-                en: {
-                    name: `Sports Bar ${cfg.visitMilestone} Visits Bonus`,
-                    description: `Bonus ${cfg.milestoneBonus} coins for visiting the sports bar ${cfg.visitMilestone} times`,
-                },
-            },
-            activity: {
-                startsAt: formatOLDate(cfg.seasonStart),
-                endsAt: formatOLDate(cfg.seasonEnd),
-            },
-            rules: [
-                {
-                    name: `Bonus for ${cfg.visitMilestone} visits`,
-                    effects: [
-                        {
-                            effect: "give_points",
-                            pointsRule: { fixedValue: cfg.milestoneBonus },
-                        },
-                    ],
-                    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.visitCampaignId) {
-            const campaigns = await campaignList({ active: true });
-            const found = campaigns.campaigns.some((c) => c.campaignId === result.visitCampaignId);
-            if (!found) {
-                warnings.push("Visit 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 = [];
-    if (result.visitCampaignId) {
-        lines.push(`Sports bar visit campaign created!`);
-        lines.push(`\nPer-visit reward: ${cfg.coinsPerVisit} coins`);
-        lines.push(`Daily limit: ${cfg.limitPerDay} visit${cfg.limitPerDay > 1 ? "s" : ""}`);
-    }
-    if (result.achievementId) {
-        lines.push(`\nAchievement: Visit ${cfg.visitMilestone} times`);
-        if (cfg.badgeName) {
-            lines.push(`Badge: ${cfg.badgeName}`);
-        }
-        if (result.bonusCampaignId) {
-            lines.push(`Completion bonus: ${cfg.milestoneBonus} coins`);
-        }
-    }
-    lines.push(`\nSeason: ${cfg.seasonStart} to ${cfg.seasonEnd}`);
-    lines.push(`\nCustom event to trigger reward:`);
-    lines.push(`  Event: sportsbar_visit`);
-    lines.push(`\nExample event payload:`);
-    lines.push(`{`);
-    lines.push(`  "event": "sportsbar_visit"`);
-    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 sportsbarVisitWorkflow = {
-    id: "sportsbar-visit",
-    name: "Sports Bar Visit Campaign",
-    execute: executeSportsbarVisitWorkflow,
-};

package/dist/workflows/vod-watching.d.ts

@@ -1,43 +0,0 @@
-/**
- * VOD Watching Workflow
- *
- * Creates a campaign to reward fans for watching video content,
- * with achievements for total watch time using attribute aggregation.
- */
-export interface VodWatchingConfig {
-    /** Track by "views" or "minutes" */
-    trackBy: "views" | "minutes";
-    /** Coins awarded per unit (view or unitSize minutes) */
-    coinsPerUnit: number;
-    /** For minutes tracking: how many minutes per reward unit */
-    unitSize: number;
-    /** Whether to create achievement for total watching */
-    createAchievement: boolean;
-    /** Target for achievement (minutes or views) */
-    achievementTarget: number;
-    /** Bonus coins for completing the achievement */
-    achievementBonus: number;
-    /** Badge name for achievement (optional) */
-    badgeName?: string;
-    /** Season start date (ISO format) */
-    seasonStart: string;
-    /** Season end date (ISO format) */
-    seasonEnd: string;
-}
-export interface VodWatchingResult {
-    success: boolean;
-    watchCampaignId?: string;
-    achievementId?: string;
-    bonusCampaignId?: string;
-    errors: string[];
-    summary: string;
-}
-/**
- * Execute the VOD watching workflow
- */
-export declare function executeVodWatchingWorkflow(config?: Partial<VodWatchingConfig>): Promise<VodWatchingResult>;
-export declare const vodWatchingWorkflow: {
-    id: string;
-    name: string;
-    execute: typeof executeVodWatchingWorkflow;
-};