@connect-xlab/mcp-server 0.1.2 → 0.2.0

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

@@ -9,15 +9,15 @@ 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 de la page Link in Bio (meta). Cree la page si absente. Champs optionnels : slug, display_name, bio, theme (violet/blue/black/pastel), accent_color (#RRGGBB), photo_layout (avatar/banner/portrait), desktop_layout (split/centered), avatar_url, banner_url, portrait_url, socials{instagram, tiktok, youtube, x, linkedin, facebook, whatsapp, telegram}. Attention : changer le slug a un cooldown de 30 jours.",
+    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', maxLength: 40 },
-            display_name: { type: 'string', maxLength: 60 },
-            bio: { type: 'string', maxLength: 300 },
-            theme: { type: 'string', enum: ['violet', 'blue', 'black', 'pastel'] },
+            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'] },
@@ -26,26 +26,26 @@ export const updateLinkInBioTool = {
             portrait_url: { type: 'string' },
             socials: {
                 type: 'object',
-                properties: Object.fromEntries(SOCIAL_KEYS.map((k) => [k, { type: 'string' }])),
+                properties: Object.fromEntries(SOCIAL_KEYS.map((k) => [k, { type: 'string', maxLength: 200 }])),
                 additionalProperties: false,
             },
         },
-        required: ['lab'],
+        required: ['lab', 'slug', 'display_name', 'photo_layout', 'theme'],
         additionalProperties: false,
     },
     zodSchema: z.object({
         lab: z.string(),
-        slug: z.string().max(40).optional(),
-        display_name: z.string().max(60).optional(),
-        bio: z.string().max(300).optional(),
-        theme: z.enum(['violet', 'blue', 'black', 'pastel']).optional(),
+        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']).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()).optional(),
+        socials: z.record(z.string().max(200)).optional(),
     }),
     async handler(args) {
         const parsed = this.zodSchema.parse(args);

package/dist/tools/updateNewsletterEdition.js

@@ -0,0 +1,43 @@
+/**
+ * Tool `update_newsletter_edition` — édite un draft de newsletter.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const updateNewsletterEditionTool = {
+    name: 'update_newsletter_edition',
+    description: "Modifie une edition de newsletter (title, subject, body_html, access, audience). Une edition deja envoyee ne peut plus etre modifiee. edition_id vient de list_newsletter_editions. IMPORTANT : action ecriture.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            edition_id: { type: 'number' },
+            title: { type: 'string', maxLength: 255 },
+            subject: { type: 'string', maxLength: 255 },
+            body_html: { type: 'string', description: 'Contenu HTML de l\'edition' },
+            access: { type: 'string', enum: ['free', 'premium'] },
+            audience: { type: 'string', enum: ['all', 'premium', 'free', 'lab_members'] },
+        },
+        required: ['lab', 'edition_id'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        edition_id: z.number().int().positive(),
+        title: z.string().max(255).optional(),
+        subject: z.string().max(255).optional(),
+        body_html: z.string().nullable().optional(),
+        access: z.enum(['free', 'premium']).optional(),
+        audience: z.enum(['all', 'premium', 'free', 'lab_members']).optional(),
+    }),
+    async handler(args) {
+        const p = this.zodSchema.parse(args);
+        const { lab, edition_id, ...body } = p;
+        try {
+            const { data } = await http.put(`/mcp/labs/${encodeURIComponent(lab)}/newsletter/editions/${edition_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/updateNewsletterSettings.js

@@ -0,0 +1,63 @@
+/**
+ * Tool `update_newsletter_settings` — met à jour les réglages clés de la
+ * newsletter (sous-ensemble curé ; l'éditeur de landing page complet reste
+ * sur le front).
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const updateNewsletterSettingsTool = {
+    name: 'update_newsletter_settings',
+    description: "Met a jour les reglages cles de la newsletter (titre, tagline, auteur, apparence, CTA, email de bienvenue, mode d'envoi). N'envoie que ce que tu veux changer. L'editeur de landing page complet (perks / temoignages / FAQ / sections) reste sur le front.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            title: { type: 'string', maxLength: 191 },
+            tagline: { type: 'string', maxLength: 2000 },
+            author_name: { type: 'string', maxLength: 191 },
+            author_bio: { type: 'string', maxLength: 2000 },
+            accent_color: { type: 'string', maxLength: 16 },
+            background: { type: 'string', enum: ['white', 'cream', 'dark'] },
+            cta_primary_text: { type: 'string', maxLength: 191 },
+            cta_secondary_text: { type: 'string', maxLength: 191 },
+            show_secondary_cta: { type: 'boolean' },
+            footer_text: { type: 'string', maxLength: 2000 },
+            unsubscribe_label: { type: 'string', maxLength: 100 },
+            welcome_email_subject: { type: 'string', maxLength: 255 },
+            welcome_email_html: { type: 'string', maxLength: 50000 },
+            welcome_email_enabled: { type: 'boolean' },
+            send_mode: { type: 'string', enum: ['standard', 'custom_domain'] },
+        },
+        required: ['lab'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        title: z.string().max(191).optional(),
+        tagline: z.string().max(2000).nullable().optional(),
+        author_name: z.string().max(191).nullable().optional(),
+        author_bio: z.string().max(2000).nullable().optional(),
+        accent_color: z.string().max(16).optional(),
+        background: z.enum(['white', 'cream', 'dark']).optional(),
+        cta_primary_text: z.string().max(191).optional(),
+        cta_secondary_text: z.string().max(191).optional(),
+        show_secondary_cta: z.boolean().optional(),
+        footer_text: z.string().max(2000).nullable().optional(),
+        unsubscribe_label: z.string().max(100).nullable().optional(),
+        welcome_email_subject: z.string().max(255).nullable().optional(),
+        welcome_email_html: z.string().max(50000).nullable().optional(),
+        welcome_email_enabled: z.boolean().optional(),
+        send_mode: z.enum(['standard', 'custom_domain']).optional(),
+    }),
+    async handler(args) {
+        const p = this.zodSchema.parse(args);
+        const { lab, ...body } = p;
+        try {
+            const { data } = await http.put(`/mcp/labs/${encodeURIComponent(lab)}/newsletter/settings`, 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/updatePost.js

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { http, formatApiError } from '../http.js';
 export const updatePostTool = {
     name: 'update_post',
-    description: "Modifie un post existant (titre / corps / categorie). Champs optionnels : n'envoie que ce que tu veux changer. IMPORTANT : action ecriture, demander confirmation.",
+    description: "Modifie un post existant (titre / corps / categorie / produit Boutique). Champs optionnels : n'envoie que ce que tu veux changer. shop_id : passe l'id d'un produit (list_shops) pour l'attacher, ou null pour retirer le produit du post. IMPORTANT : action ecriture, demander confirmation.",
     inputSchema: {
         type: 'object',
         properties: {
@@ -11,6 +11,7 @@ export const updatePostTool = {
             title: { type: 'string', maxLength: 255 },
             body: { type: 'string' },
             category_id: { type: 'number' },
+            shop_id: { type: ['number', 'null'], description: "Id d'un produit Boutique a mettre en avant (list_shops), ou null pour le retirer." },
         },
         required: ['lab', 'post_id'],
         additionalProperties: false,
@@ -21,6 +22,7 @@ export const updatePostTool = {
         title: z.string().max(255).optional(),
         body: z.string().optional(),
         category_id: z.number().int().positive().optional(),
+        shop_id: z.number().int().positive().nullable().optional(),
     }),
     async handler(args) {
         const parsed = this.zodSchema.parse(args);

package/dist/tools/updateProductAffiliationConfig.js

@@ -0,0 +1,43 @@
+/**
+ * Tool `update_product_affiliation_config` — active/configure l'affiliation
+ * d'un produit (boutique ou agent IA).
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+const PRODUCT_TYPES = ['shop_product', 'agent_ai'];
+export const updateProductAffiliationConfigTool = {
+    name: 'update_product_affiliation_config',
+    description: "Active / configure l'affiliation d'un produit (boutique ou agent IA custom). enabled = activer, percent = commission % reversee a l'affilie, visibility = qui peut devenir affilie (members_only = membres approuves, open = tout utilisateur connecte, approval_required = sur validation manuelle).",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            product_type: { type: 'string', enum: [...PRODUCT_TYPES] },
+            product_id: { type: 'number' },
+            affiliation_enabled: { type: 'boolean' },
+            affiliation_percent: { type: 'number', minimum: 0, maximum: 100 },
+            affiliation_visibility: { type: 'string', enum: ['members_only', 'open', 'approval_required'] },
+        },
+        required: ['lab', 'product_type', 'product_id'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        product_type: z.enum(PRODUCT_TYPES),
+        product_id: z.number().int().positive(),
+        affiliation_enabled: z.boolean().optional(),
+        affiliation_percent: z.number().min(0).max(100).optional(),
+        affiliation_visibility: z.enum(['members_only', 'open', 'approval_required']).optional(),
+    }),
+    async handler(args) {
+        const p = this.zodSchema.parse(args);
+        const { lab, product_type, product_id, ...body } = p;
+        try {
+            const { data } = await http.put(`/mcp/labs/${encodeURIComponent(lab)}/affiliation/products/${product_type}/${product_id}/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/updateShopProduct.js

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { http, formatApiError } from '../http.js';
 export const updateShopProductTool = {
     name: 'update_shop_product',
-    description: "Modifie un produit boutique (titre, prix, description, publication). Champs optionnels. Prix en centimes.",
+    description: "Modifie un produit boutique (titre, prix, description, publication, type d'offre). Champs optionnels. Prix en centimes. Passe offer_type=formation + course_id (list_classes) pour que l'achat debloque un cours ; tout autre offer_type detache le cours lie.",
     inputSchema: {
         type: 'object',
         properties: {
@@ -12,6 +12,8 @@ export const updateShopProductTool = {
             short_description: { type: 'string' },
             description: { type: 'string' },
             price_cents: { type: 'number', minimum: 0 },
+            offer_type: { type: 'string', enum: ['digital', 'calendar', 'formation'] },
+            course_id: { type: 'number', description: "Id d'un cours du Lab (list_classes) — requis/utilise quand offer_type=formation." },
             payment_mode: { type: 'string', enum: ['external', 'stripe'] },
             payment_link_text: { type: 'string', maxLength: 255 },
             support_email: { type: 'string', format: 'email' },
@@ -27,6 +29,8 @@ export const updateShopProductTool = {
         short_description: z.string().optional(),
         description: z.string().optional(),
         price_cents: z.number().int().min(0).nullable().optional(),
+        offer_type: z.enum(['digital', 'calendar', 'formation']).optional(),
+        course_id: z.number().int().positive().nullable().optional(),
         payment_mode: z.enum(['external', 'stripe']).optional(),
         payment_link_text: z.string().max(255).nullable().optional(),
         support_email: z.string().email().nullable().optional(),

package/dist/tools/updateSmartJoinQuestion.js

@@ -0,0 +1,40 @@
+/**
+ * Tool `update_smart_join_question` — modifie une question Smart Join.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+const TYPES = ['email', 'short_text', 'long_text', 'phone', 'number', 'single_choice', 'multiple_choice'];
+export const updateSmartJoinQuestionTool = {
+    name: 'update_smart_join_question',
+    description: "Modifie une question de qualification Smart Join. question_id vient de get_smart_join. Pour single_choice / multiple_choice, fournis options.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            question_id: { type: 'number' },
+            label: { type: 'string', maxLength: 500 },
+            type: { type: 'string', enum: [...TYPES] },
+            options: { type: 'array', items: { type: 'string' } },
+        },
+        required: ['lab', 'question_id'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        question_id: z.number().int().positive(),
+        label: z.string().max(500).optional(),
+        type: z.enum(TYPES).optional(),
+        options: z.array(z.string()).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)}/smart-join/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/updateSmartJoinSettings.js

@@ -0,0 +1,29 @@
+/**
+ * Tool `update_smart_join_settings` — active / désactive le plug-in Smart Join.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const updateSmartJoinSettingsTool = {
+    name: 'update_smart_join_settings',
+    description: "Active ou desactive le plug-in Smart Join (pop-up de questions a l'inscription). is_active = true active le questionnaire de qualification.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            is_active: { type: 'boolean' },
+        },
+        required: ['lab', 'is_active'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({ lab: z.string(), is_active: z.boolean() }),
+    async handler(args) {
+        const p = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.put(`/mcp/labs/${encodeURIComponent(p.lab)}/smart-join`, { is_active: p.is_active });
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};