@open-loyalty/mcp-server 1.3.6 → 1.4.1

package/dist/tools/segment.js

@@ -1,333 +0,0 @@
-import { z } from "zod";
-import { apiGet, apiPost, apiPut, apiDelete } from "../client/http.js";
-import { formatApiError } from "../utils/errors.js";
-import { getStoreCode } from "../config.js";
-// Input Schemas
-export const SegmentListInputSchema = {
-    storeCode: z.string().optional().describe("Store code for multi-tenant routing. DO NOT pass this parameter - the configured default will be used automatically. Only provide a value if the user explicitly asks to work with a different store."),
-    page: z.number().optional().describe("Page number (default: 1)."),
-    perPage: z.number().optional().describe("Items per page (default: 10)."),
-    active: z.boolean().optional().describe("Filter by active status."),
-    name: z.string().optional().describe("Filter by segment name."),
-};
-// Criterion input schema - flexible to support all criterion types
-// NOTE: Only certain criterion types are supported by the API.
-// WORKING: transaction_count (requires both min AND max; MCP will auto-fill max if omitted)
-// NOT WORKING: tier, points_balance (rejected by API despite being documented)
-const SegmentCriterionInputSchema = z.object({
-    type: z.string().describe("Criterion type. WORKING: 'transaction_count' (requires both min AND max; MCP auto-fills max if omitted). NOT WORKING: 'tier', 'points_balance' are rejected by the API."),
-    criterionId: z.string().optional().describe("Criterion ID (optional, generated if not provided)."),
-    // Common criterion data fields
-    days: z.number().optional().describe("Days for time-based criteria."),
-    fromDate: z.string().optional().describe("Start date (ISO format)."),
-    toDate: z.string().optional().describe("End date (ISO format)."),
-    min: z.number().optional().describe("Minimum value."),
-    max: z.number().optional().describe("Maximum value."),
-    posIds: z.array(z.string()).optional().describe("POS IDs."),
-    skus: z.array(z.string()).optional().describe("SKU codes."),
-    makers: z.array(z.string()).optional().describe("Maker/brand names."),
-    labels: z.array(z.object({ key: z.string(), value: z.string() })).optional().describe("Label key-value pairs."),
-    tierIds: z.array(z.string()).optional().describe("Tier level IDs."),
-    campaignId: z.string().optional().describe("Campaign ID for campaign_completion criterion."),
-    countries: z.array(z.string()).optional().describe("Country codes."),
-    anniversaryType: z.string().optional().describe("Anniversary type."),
-    customAttributeKey: z.string().optional().describe("Custom attribute key."),
-    customAttributeValue: z.string().optional().describe("Custom attribute value."),
-}).passthrough();
-// Part input schema
-const SegmentPartInputSchema = z.object({
-    segmentPartId: z.string().optional().describe("Part ID (optional)."),
-    criteria: z.array(SegmentCriterionInputSchema).describe("Criteria for this part (AND logic)."),
-});
-export const SegmentCreateInputSchema = {
-    storeCode: z.string().optional().describe("Store code for multi-tenant routing. DO NOT pass this parameter - the configured default will be used automatically. Only provide a value if the user explicitly asks to work with a different store."),
-    name: z.string().describe("Segment name (required)."),
-    description: z.string().optional().describe("Segment description."),
-    active: z.boolean().optional().describe("Whether segment is active (default: false)."),
-    parts: z.array(SegmentPartInputSchema).describe("Segment parts. Parts use OR logic (ANY part matches), criteria within parts use AND logic (ALL criteria must match)."),
-};
-export const SegmentGetInputSchema = {
-    storeCode: z.string().optional().describe("Store code for multi-tenant routing. DO NOT pass this parameter - the configured default will be used automatically. Only provide a value if the user explicitly asks to work with a different store."),
-    segmentId: z.string().describe("The segment ID (UUID) to retrieve."),
-};
-export const SegmentUpdateInputSchema = {
-    storeCode: z.string().optional().describe("Store code for multi-tenant routing. DO NOT pass this parameter - the configured default will be used automatically. Only provide a value if the user explicitly asks to work with a different store."),
-    segmentId: z.string().describe("The segment ID (UUID) to update."),
-    name: z.string().describe("Segment name."),
-    description: z.string().optional().describe("Segment description."),
-    active: z.boolean().optional().describe("Whether segment is active."),
-    parts: z.array(SegmentPartInputSchema).describe("Segment parts."),
-};
-export const SegmentDeleteInputSchema = {
-    storeCode: z.string().optional().describe("Store code for multi-tenant routing. DO NOT pass this parameter - the configured default will be used automatically. Only provide a value if the user explicitly asks to work with a different store."),
-    segmentId: z.string().describe("The segment ID (UUID) to delete."),
-};
-export const SegmentGetMembersInputSchema = {
-    storeCode: z.string().optional().describe("Store code for multi-tenant routing. DO NOT pass this parameter - the configured default will be used automatically. Only provide a value if the user explicitly asks to work with a different store."),
-    segmentId: z.string().describe("The segment ID (UUID) to get members for."),
-    page: z.number().optional().describe("Page number (default: 1)."),
-    perPage: z.number().optional().describe("Items per page (default: 25)."),
-};
-export const SegmentActivateInputSchema = {
-    storeCode: z.string().optional().describe("Store code for multi-tenant routing. DO NOT pass this parameter - the configured default will be used automatically. Only provide a value if the user explicitly asks to work with a different store."),
-    segmentId: z.string().describe("The segment ID (UUID) to activate."),
-};
-export const SegmentDeactivateInputSchema = {
-    storeCode: z.string().optional().describe("Store code for multi-tenant routing. DO NOT pass this parameter - the configured default will be used automatically. Only provide a value if the user explicitly asks to work with a different store."),
-    segmentId: z.string().describe("The segment ID (UUID) to deactivate."),
-};
-export const SegmentGetResourcesInputSchema = {
-    storeCode: z.string().optional().describe("Store code for multi-tenant routing. DO NOT pass this parameter - the configured default will be used automatically. Only provide a value if the user explicitly asks to work with a different store."),
-    segmentId: z.string().describe("The segment ID (UUID) to get associated resources for."),
-};
-// Handler functions
-export async function segmentList(input) {
-    const storeCode = getStoreCode(input.storeCode);
-    const params = new URLSearchParams();
-    if (input.page)
-        params.append("_page", String(input.page));
-    if (input.perPage)
-        params.append("_itemsOnPage", String(input.perPage));
-    if (input.active !== undefined)
-        params.append("active", String(input.active));
-    if (input.name)
-        params.append("name", input.name);
-    const queryString = params.toString();
-    const url = `/${storeCode}/segment${queryString ? `?${queryString}` : ""}`;
-    try {
-        const response = await apiGet(url);
-        const segments = (response.items || []).map((item) => ({
-            segmentId: item.segmentId,
-            name: item.name,
-            description: item.description,
-            active: item.active,
-            customersCount: item.customersCount,
-            createdAt: item.createdAt,
-        }));
-        const total = response.total || {};
-        return {
-            segments,
-            total: {
-                all: typeof total.all === "number" ? total.all : undefined,
-                filtered: typeof total.filtered === "number" ? total.filtered : undefined,
-            },
-        };
-    }
-    catch (error) {
-        throw formatApiError(error, "ol_segment_list");
-    }
-}
-const DEFAULT_TRANSACTION_COUNT_MAX = 999999;
-function normalizeSegmentParts(parts) {
-    return parts.map((part) => ({
-        ...part,
-        criteria: part.criteria.map((criterion) => {
-            if (!criterion || typeof criterion !== "object") {
-                return criterion;
-            }
-            const normalized = { ...criterion };
-            if (normalized.type === "transaction_count" &&
-                normalized.min !== undefined &&
-                normalized.max === undefined) {
-                normalized.max = DEFAULT_TRANSACTION_COUNT_MAX;
-            }
-            return normalized;
-        }),
-    }));
-}
-export async function segmentCreate(input) {
-    const storeCode = getStoreCode(input.storeCode);
-    const segmentPayload = {
-        name: input.name,
-        parts: normalizeSegmentParts(input.parts),
-    };
-    if (input.description)
-        segmentPayload.description = input.description;
-    if (input.active !== undefined)
-        segmentPayload.active = input.active;
-    try {
-        // CRITICAL: Wrap body as { segment: {...} }
-        const response = await apiPost(`/${storeCode}/segment`, { segment: segmentPayload });
-        return { segmentId: response.segmentId };
-    }
-    catch (error) {
-        throw formatApiError(error, "ol_segment_create");
-    }
-}
-export async function segmentGet(input) {
-    const storeCode = getStoreCode(input.storeCode);
-    try {
-        const response = await apiGet(`/${storeCode}/segment/${input.segmentId}`);
-        return response;
-    }
-    catch (error) {
-        throw formatApiError(error, "ol_segment_get");
-    }
-}
-export async function segmentUpdate(input) {
-    const storeCode = getStoreCode(input.storeCode);
-    const segmentPayload = {
-        name: input.name,
-        parts: normalizeSegmentParts(input.parts),
-    };
-    if (input.description !== undefined)
-        segmentPayload.description = input.description;
-    if (input.active !== undefined)
-        segmentPayload.active = input.active;
-    try {
-        // CRITICAL: Wrap body as { segment: {...} }
-        await apiPut(`/${storeCode}/segment/${input.segmentId}`, { segment: segmentPayload });
-    }
-    catch (error) {
-        throw formatApiError(error, "ol_segment_update");
-    }
-}
-export async function segmentDelete(input) {
-    const storeCode = getStoreCode(input.storeCode);
-    try {
-        await apiDelete(`/${storeCode}/segment/${input.segmentId}`);
-    }
-    catch (error) {
-        throw formatApiError(error, "ol_segment_delete");
-    }
-}
-export async function segmentGetMembers(input) {
-    const storeCode = getStoreCode(input.storeCode);
-    const params = new URLSearchParams();
-    if (input.page)
-        params.append("_page", String(input.page));
-    if (input.perPage)
-        params.append("_itemsOnPage", String(input.perPage));
-    const queryString = params.toString();
-    const url = `/${storeCode}/segment/${input.segmentId}/members${queryString ? `?${queryString}` : ""}`;
-    try {
-        const response = await apiGet(url);
-        const members = (response.items || []).map((item) => ({
-            customerId: item.customerId,
-            firstName: item.firstName,
-            lastName: item.lastName,
-            email: item.email,
-            loyaltyCardNumber: item.loyaltyCardNumber,
-            active: item.active,
-        }));
-        const total = response.total || {};
-        return {
-            members,
-            total: {
-                all: typeof total.all === "number" ? total.all : undefined,
-                filtered: typeof total.filtered === "number" ? total.filtered : undefined,
-            },
-        };
-    }
-    catch (error) {
-        throw formatApiError(error, "ol_segment_get_members");
-    }
-}
-export async function segmentActivate(input) {
-    const storeCode = getStoreCode(input.storeCode);
-    try {
-        await apiPost(`/${storeCode}/segment/${input.segmentId}/activate`, {});
-    }
-    catch (error) {
-        throw formatApiError(error, "ol_segment_activate");
-    }
-}
-export async function segmentDeactivate(input) {
-    const storeCode = getStoreCode(input.storeCode);
-    try {
-        await apiPost(`/${storeCode}/segment/${input.segmentId}/deactivate`, {});
-    }
-    catch (error) {
-        throw formatApiError(error, "ol_segment_deactivate");
-    }
-}
-export async function segmentGetResources(input) {
-    const storeCode = getStoreCode(input.storeCode);
-    try {
-        const response = await apiGet(`/${storeCode}/segment/${input.segmentId}/resources`);
-        const resources = response.items || response.resources || [];
-        return { resources };
-    }
-    catch (error) {
-        throw formatApiError(error, "ol_segment_get_resources");
-    }
-}
-// Tool definitions
-export const segmentToolDefinitions = [
-    {
-        name: "ol_segment_list",
-        title: "List Segments",
-        description: "List customer segments. Segments group members by criteria (purchase behavior, tier, location, etc). Use for campaign targeting and analytics.",
-        readOnly: true,
-        inputSchema: SegmentListInputSchema,
-        handler: segmentList,
-    },
-    {
-        name: "ol_segment_create",
-        title: "Create Segment",
-        description: "Create segment to group members. Parts use OR logic (member matches if ANY part matches). Criteria within parts use AND logic (must match ALL criteria in that part). " +
-            "WORKING criterion types: 'transaction_count' (requires BOTH min AND max). " +
-            "NOT WORKING: 'tier', 'points_balance' are rejected by the API. " +
-            "Example - High activity segment: parts: [{ criteria: [{ type: 'transaction_count', min: 5, max: 999999 }] }]",
-        readOnly: false,
-        inputSchema: SegmentCreateInputSchema,
-        handler: segmentCreate,
-    },
-    {
-        name: "ol_segment_get",
-        title: "Get Segment Details",
-        description: "Get full segment details including all parts and criteria configurations.",
-        readOnly: true,
-        inputSchema: SegmentGetInputSchema,
-        handler: segmentGet,
-    },
-    {
-        name: "ol_segment_update",
-        title: "Update Segment",
-        description: "Update segment configuration. Requires full segment definition (name, parts with criteria). Use segment_get first to retrieve current configuration.",
-        readOnly: false,
-        inputSchema: SegmentUpdateInputSchema,
-        handler: segmentUpdate,
-    },
-    {
-        name: "ol_segment_delete",
-        title: "Delete Segment (Permanent)",
-        description: "Permanently delete a segment. Cannot be undone. Check segment_get_resources first to see what uses this segment.",
-        readOnly: false,
-        destructive: true,
-        inputSchema: SegmentDeleteInputSchema,
-        handler: segmentDelete,
-    },
-    {
-        name: "ol_segment_get_members",
-        title: "Get Segment Members",
-        description: "Get members belonging to a segment. Returns paginated list of member details. Use for verifying segment criteria or exporting member lists.",
-        readOnly: true,
-        inputSchema: SegmentGetMembersInputSchema,
-        handler: segmentGetMembers,
-    },
-    {
-        name: "ol_segment_activate",
-        title: "Activate Segment",
-        description: "Activate a segment. Active segments are used for campaign targeting and can be queried for members.",
-        readOnly: false,
-        inputSchema: SegmentActivateInputSchema,
-        handler: segmentActivate,
-    },
-    {
-        name: "ol_segment_deactivate",
-        title: "Deactivate Segment",
-        description: "Deactivate a segment. Deactivated segments are not used for campaign targeting but retain their configuration.",
-        readOnly: false,
-        inputSchema: SegmentDeactivateInputSchema,
-        handler: segmentDeactivate,
-    },
-    {
-        name: "ol_segment_get_resources",
-        title: "Get Segment Resources",
-        description: "Get resources (campaigns, rewards, etc.) that use this segment for targeting. Check before deleting a segment.",
-        readOnly: true,
-        inputSchema: SegmentGetResourcesInputSchema,
-        handler: segmentGetResources,
-    },
-];

package/dist/workflows/app-login-streak.d.ts

@@ -1,39 +0,0 @@
-/**
- * App Login Streak Workflow
- *
- * Creates a campaign to reward fans for daily app logins,
- * with achievements for consecutive login streaks.
- */
-export interface AppLoginStreakConfig {
-    /** Coins awarded per daily login */
-    coinsPerLogin: number;
-    /** Whether to create streak bonus achievement */
-    createStreakBonus: boolean;
-    /** Number of consecutive days for streak achievement */
-    streakDays: number;
-    /** Bonus coins for completing the streak */
-    streakBonus: number;
-    /** Badge name for streak achievement (optional) */
-    badgeName?: string;
-    /** Season start date (ISO format) */
-    seasonStart: string;
-    /** Season end date (ISO format) */
-    seasonEnd: string;
-}
-export interface AppLoginStreakResult {
-    success: boolean;
-    loginCampaignId?: string;
-    streakAchievementId?: string;
-    streakBonusCampaignId?: string;
-    errors: string[];
-    summary: string;
-}
-/**
- * Execute the app login streak workflow
- */
-export declare function executeAppLoginStreakWorkflow(config?: Partial<AppLoginStreakConfig>): Promise<AppLoginStreakResult>;
-export declare const appLoginStreakWorkflow: {
-    id: string;
-    name: string;
-    execute: typeof executeAppLoginStreakWorkflow;
-};

package/dist/workflows/app-login-streak.js

@@ -1,298 +0,0 @@
-/**
- * App Login Streak Workflow
- *
- * Creates a campaign to reward fans for daily app logins,
- * with achievements for consecutive login streaks.
- */
-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 app login streak workflow
- */
-export async function executeAppLoginStreakWorkflow(config = {}) {
-    const result = {
-        success: false,
-        errors: [],
-        summary: "",
-    };
-    // Merge with defaults
-    const cfg = {
-        coinsPerLogin: config.coinsPerLogin ?? DEFAULTS.appLoginStreak.coinsPerLogin,
-        createStreakBonus: config.createStreakBonus ?? true,
-        streakDays: config.streakDays ?? DEFAULTS.appLoginStreak.streakDays,
-        streakBonus: config.streakBonus ?? DEFAULTS.appLoginStreak.streakBonus,
-        badgeName: config.badgeName ?? "Dedicated Fan",
-        seasonStart: config.seasonStart ?? DEFAULTS.seasonDates.start,
-        seasonEnd: config.seasonEnd ?? DEFAULTS.seasonDates.end,
-    };
-    try {
-        // Step 1: Create daily login campaign (limited to 1 per day)
-        const loginCampaignResult = await createLoginCampaign(cfg);
-        if (loginCampaignResult.error) {
-            result.errors.push(loginCampaignResult.error);
-        }
-        else {
-            result.loginCampaignId = loginCampaignResult.campaignId;
-        }
-        // Step 2: Create streak achievement and bonus campaign if enabled
-        if (cfg.createStreakBonus) {
-            const badges = await getAvailableBadges();
-            const achievementResult = await createStreakAchievement(cfg, badges);
-            if (achievementResult.error) {
-                result.errors.push(achievementResult.error);
-            }
-            else {
-                result.streakAchievementId = achievementResult.achievementId;
-                // Create bonus campaign for streak achievement
-                if (achievementResult.achievementId) {
-                    const bonusCampaignResult = await createStreakBonusCampaign(achievementResult.achievementId, cfg);
-                    if (bonusCampaignResult.error) {
-                        result.errors.push(bonusCampaignResult.error);
-                    }
-                    else {
-                        result.streakBonusCampaignId = 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.loginCampaignId !== 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 createLoginCampaign(cfg) {
-    try {
-        const response = await campaignCreate({
-            type: "direct",
-            trigger: "custom_event",
-            event: "app_login",
-            translations: {
-                en: {
-                    name: "Daily App Login Reward",
-                    description: `Earn ${cfg.coinsPerLogin} coins for logging into the app daily`,
-                },
-            },
-            activity: {
-                startsAt: formatOLDate(cfg.seasonStart),
-                endsAt: formatOLDate(cfg.seasonEnd),
-            },
-            rules: [
-                {
-                    name: "Award coins for daily login",
-                    effects: [
-                        {
-                            effect: "give_points",
-                            pointsRule: { fixedValue: cfg.coinsPerLogin },
-                        },
-                    ],
-                },
-            ],
-            limits: {
-                // Strictly one login reward per day
-                executionsPerMember: {
-                    value: 1,
-                    interval: { type: "days", value: 1 },
-                },
-            },
-            active: true,
-        });
-        return { campaignId: response.campaignId };
-    }
-    catch (error) {
-        return {
-            error: `Failed to create login 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 createStreakAchievement(cfg, badges) {
-    try {
-        const badgeTypeId = cfg.badgeName
-            ? badges.get(cfg.badgeName.toLowerCase())
-            : undefined;
-        /**
-         * Streak achievements in Open Loyalty use:
-         * - periodGoal: 1 (one login per period)
-         * - period: { consecutive: X, value: 1 } where X is streak days
-         *
-         * This tracks consecutive periods (days) where the goal is met.
-         */
-        const achievementPayload = {
-            translations: {
-                en: {
-                    name: `${cfg.streakDays}-Day Login Streak`,
-                    description: `Log in ${cfg.streakDays} consecutive days to complete this achievement`,
-                },
-            },
-            active: true,
-            activity: {
-                startsAt: formatOLDate(cfg.seasonStart),
-                endsAt: formatOLDate(cfg.seasonEnd),
-            },
-            rules: [
-                {
-                    trigger: "custom_event",
-                    event: "app_login",
-                    completeRule: {
-                        periodGoal: 1,
-                        period: {
-                            consecutive: cfg.streakDays,
-                            value: 1, // 1 day period
-                        },
-                    },
-                },
-            ],
-        };
-        if (badgeTypeId) {
-            achievementPayload.badgeTypeId = badgeTypeId;
-        }
-        const response = await achievementCreate(achievementPayload);
-        return { achievementId: response.achievementId };
-    }
-    catch (error) {
-        return {
-            error: `Failed to create streak achievement: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-}
-async function createStreakBonusCampaign(achievementId, cfg) {
-    try {
-        const response = await campaignCreate({
-            type: "direct",
-            trigger: "achievement",
-            translations: {
-                en: {
-                    name: `${cfg.streakDays}-Day Login Streak Bonus`,
-                    description: `Bonus ${cfg.streakBonus} coins for maintaining a ${cfg.streakDays}-day login streak`,
-                },
-            },
-            activity: {
-                startsAt: formatOLDate(cfg.seasonStart),
-                endsAt: formatOLDate(cfg.seasonEnd),
-            },
-            rules: [
-                {
-                    name: `Bonus for ${cfg.streakDays}-day streak`,
-                    effects: [
-                        {
-                            effect: "give_points",
-                            pointsRule: { fixedValue: cfg.streakBonus },
-                        },
-                    ],
-                    conditions: [
-                        {
-                            operator: "is_equal",
-                            attribute: "achievement.achievementId",
-                            data: { value: achievementId },
-                        },
-                    ],
-                },
-            ],
-            active: true,
-        });
-        return { campaignId: response.campaignId };
-    }
-    catch (error) {
-        return {
-            error: `Failed to create streak bonus campaign: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-}
-async function verifySetup(result) {
-    const warnings = [];
-    try {
-        if (result.loginCampaignId) {
-            const campaigns = await campaignList({ active: true });
-            const found = campaigns.campaigns.some((c) => c.campaignId === result.loginCampaignId);
-            if (!found) {
-                warnings.push("Login campaign created but not found in active campaigns list");
-            }
-        }
-        if (result.streakAchievementId) {
-            const achievements = await achievementList({ active: true });
-            const found = achievements.achievements.some((a) => a.achievementId === result.streakAchievementId);
-            if (!found) {
-                warnings.push("Streak 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.loginCampaignId) {
-        lines.push(`Daily login campaign created!`);
-        lines.push(`\nDaily reward: ${cfg.coinsPerLogin} coins`);
-        lines.push(`Limit: 1 reward per day (prevents multiple login scans)`);
-    }
-    if (result.streakAchievementId) {
-        lines.push(`\nStreak Achievement: ${cfg.streakDays} consecutive days`);
-        if (cfg.badgeName) {
-            lines.push(`Badge: ${cfg.badgeName}`);
-        }
-        if (result.streakBonusCampaignId) {
-            lines.push(`Streak bonus: ${cfg.streakBonus} coins`);
-        }
-    }
-    lines.push(`\nSeason: ${cfg.seasonStart} to ${cfg.seasonEnd}`);
-    lines.push(`\nCustom event to trigger reward:`);
-    lines.push(`  Event: app_login`);
-    lines.push(`\nExample event payload:`);
-    lines.push(`{`);
-    lines.push(`  "event": "app_login"`);
-    lines.push(`}`);
-    lines.push(`\nStreak mechanics:`);
-    lines.push(`- Fan must log in at least once each day`);
-    lines.push(`- Missing a day resets the streak counter`);
-    lines.push(`- Achievement completes when ${cfg.streakDays} consecutive days are reached`);
-    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 appLoginStreakWorkflow = {
-    id: "app-login-streak",
-    name: "App Login Streak Campaign",
-    execute: executeAppLoginStreakWorkflow,
-};