@connect-xlab/mcp-server 0.1.1 → 0.2.0

package/dist/tools/setFunnelItem.js

@@ -0,0 +1,94 @@
+/**
+ * Tool `set_funnel_item` — cree / remplace un item de tunnel (order bump,
+ * upsell ou downsell). 1 seul item par kind : re-appeler remplace l'existant.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+const SELLABLE_TYPES = ['agent_ai', 'group_shop', 'course', 'newsletter', 'podcast_show', 'lab_channel'];
+export const setFunnelItemTool = {
+    name: 'set_funnel_item',
+    description: "Cree ou remplace un item de tunnel : order_bump (case a cocher au checkout), upsell (offre apres achat) ou downsell (offre de repli si upsell refuse). 1 seul item par kind. offer_type + offer_id = le produit propose (list_funnel_offers). Pour un order_bump, l'offre doit avoir le meme type de paiement (one-shot / abonnement) que le produit principal. price_cents override le prix (sinon prix courant du produit). Les champs riches (kicker, subtitle, video_url, original_price_cents (prix barre), timer_minutes, bullets, faq, testimonial) servent surtout aux pages upsell/downsell.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            funnel_id: { type: 'number' },
+            kind: { type: 'string', enum: ['order_bump', 'upsell', 'downsell'] },
+            offer_type: { type: 'string', enum: [...SELLABLE_TYPES], description: 'Type du produit propose (list_funnel_offers)' },
+            offer_id: { type: 'number', description: 'Id du produit propose' },
+            title: { type: 'string', maxLength: 200 },
+            description: { type: 'string', maxLength: 2000 },
+            image_url: { type: 'string', maxLength: 500 },
+            accept_cta: { type: 'string', maxLength: 100, description: "Libelle du bouton d'acceptation" },
+            decline_cta: { type: 'string', maxLength: 100, description: 'Libelle du bouton de refus' },
+            design_variant: { type: 'string', maxLength: 40, description: 'Variante visuelle (order bump) : simple / bordered / card / highlighted' },
+            accent_color: { type: 'string', maxLength: 20, description: 'Couleur hex' },
+            price_cents: { type: 'number', minimum: 0, description: 'Prix override en centimes (sinon prix courant du produit propose)' },
+            currency: { type: 'string', description: 'Code devise 3 lettres (defaut eur)' },
+            // Pages upsell / downsell riches.
+            kicker: { type: 'string', maxLength: 120 },
+            subtitle: { type: 'string', maxLength: 2000 },
+            confirmation_message: { type: 'string', maxLength: 500 },
+            video_url: { type: 'string', maxLength: 500 },
+            original_price_cents: { type: 'number', minimum: 0, description: 'Prix barre (marketing) en centimes' },
+            timer_minutes: { type: 'number', minimum: 0, maximum: 1440, description: 'Compte a rebours en minutes' },
+            bullets: {
+                type: 'array', maxItems: 6,
+                items: { type: 'object', properties: { title: { type: 'string' }, description: { type: 'string' } }, additionalProperties: false },
+            },
+            bullets_title: { type: 'string', maxLength: 200 },
+            faq: {
+                type: 'array', maxItems: 6,
+                items: { type: 'object', properties: { question: { type: 'string' }, answer: { type: 'string' } }, additionalProperties: false },
+            },
+            testimonial_quote: { type: 'string', maxLength: 1000 },
+            testimonial_author: { type: 'string', maxLength: 200 },
+        },
+        required: ['lab', 'funnel_id', 'kind', 'offer_type', 'offer_id'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        funnel_id: z.number().int().positive(),
+        kind: z.enum(['order_bump', 'upsell', 'downsell']),
+        offer_type: z.enum(SELLABLE_TYPES),
+        offer_id: z.number().int().positive(),
+        title: z.string().max(200).nullable().optional(),
+        description: z.string().max(2000).nullable().optional(),
+        image_url: z.string().max(500).nullable().optional(),
+        accept_cta: z.string().max(100).nullable().optional(),
+        decline_cta: z.string().max(100).nullable().optional(),
+        design_variant: z.string().max(40).nullable().optional(),
+        accent_color: z.string().max(20).nullable().optional(),
+        price_cents: z.number().int().min(0).nullable().optional(),
+        currency: z.string().length(3).nullable().optional(),
+        kicker: z.string().max(120).nullable().optional(),
+        subtitle: z.string().max(2000).nullable().optional(),
+        confirmation_message: z.string().max(500).nullable().optional(),
+        video_url: z.string().max(500).nullable().optional(),
+        original_price_cents: z.number().int().min(0).nullable().optional(),
+        timer_minutes: z.number().int().min(0).max(1440).nullable().optional(),
+        bullets: z.array(z.object({
+            title: z.string().max(200).nullable().optional(),
+            description: z.string().max(600).nullable().optional(),
+        })).max(6).nullable().optional(),
+        bullets_title: z.string().max(200).nullable().optional(),
+        faq: z.array(z.object({
+            question: z.string().max(200).nullable().optional(),
+            answer: z.string().max(800).nullable().optional(),
+        })).max(6).nullable().optional(),
+        testimonial_quote: z.string().max(1000).nullable().optional(),
+        testimonial_author: z.string().max(200).nullable().optional(),
+    }),
+    async handler(args) {
+        const p = this.zodSchema.parse(args);
+        const { lab, funnel_id, ...body } = p;
+        try {
+            const { data } = await http.post(`/mcp/labs/${encodeURIComponent(lab)}/funnels/${funnel_id}/items`, body);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/stopNewsletter.js

@@ -0,0 +1,28 @@
+/**
+ * Tool `stop_newsletter` — arrête la newsletter (annule les abos premium).
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const stopNewsletterTool = {
+    name: 'stop_newsletter',
+    description: "Arrete la newsletter du Lab : les abonnements premium sont annules en fin de cycle. Reversible via reactivate_newsletter. IMPORTANT : action sensible, demander confirmation.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+        },
+        required: ['lab'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({ lab: z.string() }),
+    async handler(args) {
+        const p = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.post(`/mcp/labs/${encodeURIComponent(p.lab)}/newsletter/stop`, {});
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/toggleLinkInBioPublish.js

@@ -0,0 +1,29 @@
+/**
+ * Tool `toggle_link_in_bio_publish` — publie / depublie la page. Une page
+ * depubliee reste editable mais n'est plus accessible via son slug public.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const toggleLinkInBioPublishTool = {
+    name: 'toggle_link_in_bio_publish',
+    description: "Publie ou depublie la page Link in Bio. Le back bascule automatiquement l'etat (pas besoin de passer publish=true/false). Retourne l'etat resultant.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+        },
+        required: ['lab'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({ lab: z.string() }),
+    async handler(args) {
+        const parsed = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.post(`/mcp/labs/${encodeURIComponent(parsed.lab)}/link-in-bio/publish`, {});
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/updateCalendar.js

@@ -0,0 +1,70 @@
+/**
+ * Tool `update_calendar` — met à jour la config du Calendrier IA (sous-ensemble
+ * curé ; les fenêtres horaires hot/warm par jour restent gérées via le front).
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const updateCalendarTool = {
+    name: 'update_calendar',
+    description: "Met a jour la config du Calendrier IA. N'envoie que ce que tu veux changer. Les fenetres horaires hot/warm par jour (scoring) restent gerees via le front.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            name: { type: 'string', maxLength: 200 },
+            location_type: { type: 'string', enum: ['google_meet', 'zoom', 'phone', 'in_person'] },
+            description: { type: 'string' },
+            internal_note: { type: 'string' },
+            notify_email: { type: 'string', format: 'email' },
+            event_type: { type: 'string', enum: ['free', 'paid'] },
+            price_cents: { type: 'number', minimum: 0 },
+            duration_minutes: { type: 'number', enum: [30, 60] },
+            date_range_days: { type: 'number', minimum: 1, maximum: 365 },
+            date_range_enabled: { type: 'boolean' },
+            auto_extend: { type: 'boolean' },
+            timezone: { type: 'string', maxLength: 50 },
+            ai_scoring_enabled: { type: 'boolean' },
+            ideal_client_description: { type: 'string' },
+            offer_name: { type: 'string', maxLength: 200 },
+            offer_price_cents: { type: 'number', minimum: 0 },
+            cold_offer_label: { type: 'string', maxLength: 200 },
+            cold_offer_url: { type: 'string', maxLength: 500 },
+            cold_offer_description: { type: 'string', maxLength: 500 },
+        },
+        required: ['lab'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        name: z.string().max(200).optional(),
+        location_type: z.enum(['google_meet', 'zoom', 'phone', 'in_person']).optional(),
+        description: z.string().nullable().optional(),
+        internal_note: z.string().nullable().optional(),
+        notify_email: z.string().email().nullable().optional(),
+        event_type: z.enum(['free', 'paid']).optional(),
+        price_cents: z.number().int().min(0).nullable().optional(),
+        duration_minutes: z.union([z.literal(30), z.literal(60)]).optional(),
+        date_range_days: z.number().int().min(1).max(365).optional(),
+        date_range_enabled: z.boolean().optional(),
+        auto_extend: z.boolean().optional(),
+        timezone: z.string().max(50).optional(),
+        ai_scoring_enabled: z.boolean().optional(),
+        ideal_client_description: z.string().nullable().optional(),
+        offer_name: z.string().max(200).nullable().optional(),
+        offer_price_cents: z.number().int().min(0).nullable().optional(),
+        cold_offer_label: z.string().max(200).nullable().optional(),
+        cold_offer_url: z.string().max(500).nullable().optional(),
+        cold_offer_description: z.string().max(500).nullable().optional(),
+    }),
+    async handler(args) {
+        const p = this.zodSchema.parse(args);
+        const { lab, ...body } = p;
+        try {
+            const { data } = await http.put(`/mcp/labs/${encodeURIComponent(lab)}/calendar`, body);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/updateCalendarAvailability.js

@@ -0,0 +1,51 @@
+/**
+ * Tool `update_calendar_availability` — disponibilités hebdomadaires du calendrier.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const updateCalendarAvailabilityTool = {
+    name: 'update_calendar_availability',
+    description: "Definit les disponibilites hebdomadaires du Calendrier IA. days est un tableau (max 7) d'un objet par jour : day_of_week (0=dimanche..6=samedi), is_available, start_time et end_time au format HH:MM (end > start).",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            days: {
+                type: 'array',
+                maxItems: 7,
+                items: {
+                    type: 'object',
+                    properties: {
+                        day_of_week: { type: 'number', minimum: 0, maximum: 6 },
+                        is_available: { type: 'boolean' },
+                        start_time: { type: 'string', description: 'HH:MM' },
+                        end_time: { type: 'string', description: 'HH:MM' },
+                    },
+                    required: ['day_of_week', 'is_available', 'start_time', 'end_time'],
+                    additionalProperties: false,
+                },
+            },
+        },
+        required: ['lab', 'days'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        days: z.array(z.object({
+            day_of_week: z.number().int().min(0).max(6),
+            is_available: z.boolean(),
+            start_time: z.string(),
+            end_time: z.string(),
+        })).max(7),
+    }),
+    async handler(args) {
+        const p = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.put(`/mcp/labs/${encodeURIComponent(p.lab)}/calendar/availability`, { days: p.days });
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/updateCalendarDisqualifRules.js

@@ -0,0 +1,48 @@
+/**
+ * Tool `update_calendar_disqualif_rules` — règles de disqualification des leads.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const updateCalendarDisqualifRulesTool = {
+    name: 'update_calendar_disqualif_rules',
+    description: "Remplace les regles de disqualification automatique des leads du Calendrier IA. rules est le jeu complet de regles : condition_type = phone_country (indicatif telephonique) ou question_answer (reponse a une question, question_id requis), disqualifying_values = valeurs qui disqualifient. Envoyer un tableau vide efface toutes les regles.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            rules: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    properties: {
+                        condition_type: { type: 'string', enum: ['phone_country', 'question_answer'] },
+                        question_id: { type: ['number', 'null'], description: 'Requis si condition_type=question_answer' },
+                        disqualifying_values: { type: 'array', items: { type: 'string' } },
+                    },
+                    required: ['condition_type'],
+                    additionalProperties: false,
+                },
+            },
+        },
+        required: ['lab', 'rules'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        rules: z.array(z.object({
+            condition_type: z.enum(['phone_country', 'question_answer']),
+            question_id: z.number().int().positive().nullable().optional(),
+            disqualifying_values: z.array(z.string()).optional(),
+        })),
+    }),
+    async handler(args) {
+        const p = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.put(`/mcp/labs/${encodeURIComponent(p.lab)}/calendar/disqualif-rules`, { rules: p.rules });
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/updateCalendarFollowupConfig.js

@@ -0,0 +1,51 @@
+/**
+ * Tool `update_calendar_followup_config` — relances automatiques des prospects.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const updateCalendarFollowupConfigTool = {
+    name: 'update_calendar_followup_config',
+    description: "Configure les relances automatiques des prospects du Calendrier IA (max 2). trigger_type = abandon_step1 (a quitte au formulaire) ou no_booking (n'a pas reserve). Pour chaque : enabled, delay_hours (1..720), message_template optionnel.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            configs: {
+                type: 'array',
+                maxItems: 2,
+                items: {
+                    type: 'object',
+                    properties: {
+                        trigger_type: { type: 'string', enum: ['abandon_step1', 'no_booking'] },
+                        enabled: { type: 'boolean' },
+                        delay_hours: { type: 'number', minimum: 1, maximum: 720 },
+                        message_template: { type: 'string' },
+                    },
+                    required: ['trigger_type', 'enabled', 'delay_hours'],
+                    additionalProperties: false,
+                },
+            },
+        },
+        required: ['lab', 'configs'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        configs: z.array(z.object({
+            trigger_type: z.enum(['abandon_step1', 'no_booking']),
+            enabled: z.boolean(),
+            delay_hours: z.number().int().min(1).max(720),
+            message_template: z.string().nullable().optional(),
+        })).max(2),
+    }),
+    async handler(args) {
+        const p = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.put(`/mcp/labs/${encodeURIComponent(p.lab)}/calendar/followup-config`, { configs: p.configs });
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/updateCalendarQuestion.js

@@ -0,0 +1,43 @@
+/**
+ * Tool `update_calendar_question` — modifie une question du calendrier.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const updateCalendarQuestionTool = {
+    name: 'update_calendar_question',
+    description: "Modifie une question de qualification du Calendrier IA. question_id vient de get_calendar. question_type = text ou qcm (options requises si qcm).",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            question_id: { type: 'number' },
+            label: { type: 'string', maxLength: 500 },
+            question_type: { type: 'string', enum: ['text', 'qcm'] },
+            icon: { type: 'string', maxLength: 40 },
+            required: { type: 'boolean' },
+            options: { type: 'array', items: { type: 'string', maxLength: 200 } },
+        },
+        required: ['lab', 'question_id', 'label', 'question_type'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        question_id: z.number().int().positive(),
+        label: z.string().min(1).max(500),
+        question_type: z.enum(['text', 'qcm']),
+        icon: z.string().max(40).nullable().optional(),
+        required: z.boolean().optional(),
+        options: z.array(z.string().max(200)).optional(),
+    }),
+    async handler(args) {
+        const p = this.zodSchema.parse(args);
+        const { lab, question_id, ...body } = p;
+        try {
+            const { data } = await http.put(`/mcp/labs/${encodeURIComponent(lab)}/calendar/questions/${question_id}`, body);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/updateCompany.js

@@ -0,0 +1,49 @@
+/**
+ * Tool `update_company` — modifie une societe du Marketplace (par uuid).
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const updateCompanyTool = {
+    name: 'update_company',
+    description: "Modifie une societe du Marketplace (identifiee par son uuid, cf list_companies). Champs optionnels : n'envoie que ce qui change. IMPORTANT : action ecriture, demander confirmation.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            uuid: { type: 'string', description: 'uuid de la societe (list_companies)' },
+            name: { type: 'string', maxLength: 255 },
+            website: { type: 'string' },
+            description: { type: 'string' },
+            short_description: { type: 'string' },
+            cta_link: { type: 'string' },
+            text_cta: { type: 'string', maxLength: 255 },
+            color: { type: 'string' },
+            company_category_id: { type: 'number', description: 'Nouvelle categorie (list_company_categories)' },
+        },
+        required: ['lab', 'uuid'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        uuid: z.string(),
+        name: z.string().max(255).optional(),
+        website: z.string().url().optional(),
+        description: z.string().optional(),
+        short_description: z.string().optional(),
+        cta_link: z.string().url().optional(),
+        text_cta: z.string().max(255).nullable().optional(),
+        color: z.string().max(20).optional(),
+        company_category_id: z.number().int().positive().optional(),
+    }),
+    async handler(args) {
+        const parsed = this.zodSchema.parse(args);
+        const { lab, uuid, ...body } = parsed;
+        try {
+            const { data } = await http.put(`/mcp/labs/${encodeURIComponent(lab)}/companies/${encodeURIComponent(uuid)}`, body);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/updateCompanyCategory.js

@@ -0,0 +1,34 @@
+/**
+ * Tool `update_company_category` — renomme une categorie Marketplace.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const updateCompanyCategoryTool = {
+    name: 'update_company_category',
+    description: "Renomme une categorie du Marketplace (identifiee par son id, cf list_company_categories).",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            category_id: { type: 'number', description: 'Id de la categorie (list_company_categories)' },
+            name: { type: 'string', maxLength: 255 },
+        },
+        required: ['lab', 'category_id', 'name'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        category_id: z.number().int().positive(),
+        name: z.string().min(1).max(255),
+    }),
+    async handler(args) {
+        const parsed = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.put(`/mcp/labs/${encodeURIComponent(parsed.lab)}/company-categories/${parsed.category_id}`, { name: parsed.name });
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/updateFunnel.js

@@ -0,0 +1,37 @@
+/**
+ * Tool `update_funnel` — modifie le nom / l'activation d'un tunnel de vente.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const updateFunnelTool = {
+    name: 'update_funnel',
+    description: "Modifie un tunnel de vente (nom, activation). funnel_id vient de get_funnel / create_funnel. Passe is_active=false pour desactiver le tunnel sans le supprimer.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            funnel_id: { type: 'number' },
+            name: { type: 'string', maxLength: 120 },
+            is_active: { type: 'boolean' },
+        },
+        required: ['lab', 'funnel_id'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        funnel_id: z.number().int().positive(),
+        name: z.string().max(120).nullable().optional(),
+        is_active: z.boolean().optional(),
+    }),
+    async handler(args) {
+        const p = this.zodSchema.parse(args);
+        const { lab, funnel_id, ...body } = p;
+        try {
+            const { data } = await http.put(`/mcp/labs/${encodeURIComponent(lab)}/funnels/${funnel_id}`, body);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/updateLabAffiliationConfig.js

@@ -0,0 +1,44 @@
+/**
+ * Tool `update_lab_affiliation_config` — configure le programme d'affiliation
+ * au niveau du Lab entier.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const updateLabAffiliationConfigTool = {
+    name: 'update_lab_affiliation_config',
+    description: "Configure le programme d'affiliation du Lab entier. affiliation_status = '1' actif / '0' inactif. affiliation_percent = commission %. Les 3 scopes activent l'affiliation sur : paiements one-shot, abonnement au Lab, abonnements internes. affiliation_badge_status = affiche le badge affilie.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            affiliation_status: { type: 'string', enum: ['0', '1'] },
+            affiliation_percent: { type: 'number', minimum: 0, maximum: 100 },
+            affiliation_scope_paid_one_shot: { type: 'boolean' },
+            affiliation_scope_lab_subscription: { type: 'boolean' },
+            affiliation_scope_internal_subscription: { type: 'boolean' },
+            affiliation_badge_status: { type: 'string', enum: ['0', '1'] },
+        },
+        required: ['lab'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        affiliation_status: z.enum(['0', '1']).optional(),
+        affiliation_percent: z.number().min(0).max(100).optional(),
+        affiliation_scope_paid_one_shot: z.boolean().optional(),
+        affiliation_scope_lab_subscription: z.boolean().optional(),
+        affiliation_scope_internal_subscription: z.boolean().optional(),
+        affiliation_badge_status: z.enum(['0', '1']).optional(),
+    }),
+    async handler(args) {
+        const p = this.zodSchema.parse(args);
+        const { lab, ...body } = p;
+        try {
+            const { data } = await http.put(`/mcp/labs/${encodeURIComponent(lab)}/affiliation/lab/config`, body);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/updateLinkInBio.js

@@ -0,0 +1,61 @@
+/**
+ * Tool `update_link_in_bio` — upsert des meta de la page (slug, display_name,
+ * bio, theme, layout, socials, URLs de photos). Si la page n'existe pas
+ * encore, elle est creee. Tous les champs sont optionnels : on ne modifie
+ * que ce qui est fourni.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+const SOCIAL_KEYS = ['instagram', 'tiktok', 'youtube', 'x', 'linkedin', 'facebook', 'whatsapp', 'telegram'];
+export const updateLinkInBioTool = {
+    name: 'update_link_in_bio',
+    description: "Upsert (remplacement) de la page Link in Bio. Cree la page si absente. C'est un upsert COMPLET : tu dois TOUJOURS fournir slug, display_name, photo_layout et theme (fais get_link_in_bio d'abord pour recuperer les valeurs actuelles, puis renvoie-les avec tes modifs). Autres champs : bio, accent_color (#RRGGBB), desktop_layout (split/centered), avatar_url, banner_url, portrait_url, socials{instagram, tiktok, youtube, x, linkedin, facebook, whatsapp, telegram}. theme = light | dark | violet | yellow. photo_layout = avatar | banner | portrait. Les uploads d'images (avatar/banniere) se font via le front — ici on passe des URLs. Attention : changer le slug a un cooldown de 30 jours.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            slug: { type: 'string', minLength: 3, maxLength: 60, description: 'minuscule, ^[a-z][a-z0-9_-]{2,59}$' },
+            display_name: { type: 'string', maxLength: 100 },
+            bio: { type: 'string', maxLength: 500 },
+            theme: { type: 'string', enum: ['light', 'dark', 'violet', 'yellow'] },
+            accent_color: { type: 'string', pattern: '^#[0-9A-Fa-f]{6}$' },
+            photo_layout: { type: 'string', enum: ['avatar', 'banner', 'portrait'] },
+            desktop_layout: { type: 'string', enum: ['split', 'centered'] },
+            avatar_url: { type: 'string' },
+            banner_url: { type: 'string' },
+            portrait_url: { type: 'string' },
+            socials: {
+                type: 'object',
+                properties: Object.fromEntries(SOCIAL_KEYS.map((k) => [k, { type: 'string', maxLength: 200 }])),
+                additionalProperties: false,
+            },
+        },
+        required: ['lab', 'slug', 'display_name', 'photo_layout', 'theme'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        slug: z.string().min(3).max(60),
+        display_name: z.string().max(100),
+        bio: z.string().max(500).optional(),
+        theme: z.enum(['light', 'dark', 'violet', 'yellow']),
+        accent_color: z.string().regex(/^#[0-9A-Fa-f]{6}$/).optional(),
+        photo_layout: z.enum(['avatar', 'banner', 'portrait']),
+        desktop_layout: z.enum(['split', 'centered']).optional(),
+        avatar_url: z.string().optional(),
+        banner_url: z.string().optional(),
+        portrait_url: z.string().optional(),
+        socials: z.record(z.string().max(200)).optional(),
+    }),
+    async handler(args) {
+        const parsed = this.zodSchema.parse(args);
+        const { lab, ...body } = parsed;
+        try {
+            const { data } = await http.post(`/mcp/labs/${encodeURIComponent(lab)}/link-in-bio`, body);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};