@connect-xlab/mcp-server 0.1.2 → 0.2.0

package/dist/tools/listProductAffiliates.js

@@ -0,0 +1,49 @@
+/**
+ * Tool `list_product_affiliates` — liste les affiliés d'un produit + KPIs.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+const PRODUCT_TYPES = ['shop_product', 'agent_ai'];
+export const listProductAffiliatesTool = {
+    name: 'list_product_affiliates',
+    description: "Liste les affilies d'un produit (boutique ou agent IA) avec KPIs : nb de referrals, commission payee / en attente, pourcentage effectif, custom_percent, statut (approuve / revoque). Filtre optionnel status = pending | active | revoked. Pagine.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            product_type: { type: 'string', enum: [...PRODUCT_TYPES] },
+            product_id: { type: 'number' },
+            status: { type: 'string', enum: ['pending', 'active', 'revoked'] },
+            page: { type: 'number', minimum: 1 },
+            per_page: { type: 'number', minimum: 1, maximum: 100 },
+        },
+        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(),
+        status: z.enum(['pending', 'active', 'revoked']).optional(),
+        page: z.number().int().min(1).optional(),
+        per_page: z.number().int().min(1).max(100).optional(),
+    }),
+    async handler(args) {
+        const p = this.zodSchema.parse(args);
+        const qs = new URLSearchParams();
+        if (p.status !== undefined)
+            qs.set('status', p.status);
+        if (p.page !== undefined)
+            qs.set('page', String(p.page));
+        if (p.per_page !== undefined)
+            qs.set('per_page', String(p.per_page));
+        const query = qs.toString() ? `?${qs.toString()}` : '';
+        try {
+            const { data } = await http.get(`/mcp/labs/${encodeURIComponent(p.lab)}/affiliation/products/${p.product_type}/${p.product_id}/affiliates${query}`);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/listSmartJoinResponses.js

@@ -0,0 +1,40 @@
+/**
+ * Tool `list_smart_join_responses` — réponses des prospects Smart Join (mini-CRM).
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const listSmartJoinResponsesTool = {
+    name: 'list_smart_join_responses',
+    description: "Liste les reponses des prospects au questionnaire Smart Join (mini-CRM : qui a repondu quoi avant de rejoindre le Lab). Pagine.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            page: { type: 'number', minimum: 1 },
+            per_page: { type: 'number', minimum: 1, maximum: 100 },
+        },
+        required: ['lab'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        page: z.number().int().min(1).optional(),
+        per_page: z.number().int().min(1).max(100).optional(),
+    }),
+    async handler(args) {
+        const p = this.zodSchema.parse(args);
+        const qs = new URLSearchParams();
+        if (p.page !== undefined)
+            qs.set('page', String(p.page));
+        if (p.per_page !== undefined)
+            qs.set('per_page', String(p.per_page));
+        const query = qs.toString() ? `?${qs.toString()}` : '';
+        try {
+            const { data } = await http.get(`/mcp/labs/${encodeURIComponent(p.lab)}/smart-join/responses${query}`);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/manageLabAffiliate.js

@@ -0,0 +1,41 @@
+/**
+ * Tool `manage_lab_affiliate` — revoque / restaure un affilié du Lab, ou fixe
+ * son pourcentage custom. (Pas d'approbation au niveau Lab : le programme est
+ * on/off.)
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const manageLabAffiliateTool = {
+    name: 'manage_lab_affiliate',
+    description: "Gere un affilie du Lab (lab-level). action : revoke (coupe l'affiliation), restore (annule la revocation), set_percent (fixe un pourcentage custom — fournir custom_percent, ou null pour repasser au % du Lab). user_id = id de l'affilie (list_lab_affiliates). IMPORTANT : action ecriture, demander confirmation.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            user_id: { type: 'number' },
+            action: { type: 'string', enum: ['revoke', 'restore', 'set_percent'] },
+            custom_percent: { type: ['number', 'null'], minimum: 0, maximum: 100, description: 'Requis si action=set_percent (null = % du Lab).' },
+        },
+        required: ['lab', 'user_id', 'action'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        user_id: z.number().int().positive(),
+        action: z.enum(['revoke', 'restore', 'set_percent']),
+        custom_percent: z.number().min(0).max(100).nullable().optional(),
+    }),
+    async handler(args) {
+        const p = this.zodSchema.parse(args);
+        const body = { action: p.action };
+        if (p.action === 'set_percent')
+            body.custom_percent = p.custom_percent ?? null;
+        try {
+            const { data } = await http.post(`/mcp/labs/${encodeURIComponent(p.lab)}/affiliation/lab/affiliates/${p.user_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/managePixelRequest.js

@@ -0,0 +1,35 @@
+/**
+ * Tool `manage_pixel_request` — approuve / rejette / révoque une demande de
+ * Meta Pixel d'un affilié.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const managePixelRequestTool = {
+    name: 'manage_pixel_request',
+    description: "Gere une demande de Meta Pixel d'un affilie. action : approve (autorise l'installation du pixel sur la page A propos), reject (refuse une demande en attente), revoke (retire un pixel deja approuve). id = id de la demande (list_pixel_requests). IMPORTANT : action ecriture, demander confirmation.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            id: { type: 'number', description: 'Id de la demande (list_pixel_requests)' },
+            action: { type: 'string', enum: ['approve', 'reject', 'revoke'] },
+        },
+        required: ['lab', 'id', 'action'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        id: z.number().int().positive(),
+        action: z.enum(['approve', 'reject', 'revoke']),
+    }),
+    async handler(args) {
+        const p = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.post(`/mcp/labs/${encodeURIComponent(p.lab)}/subscriptions/pixel-requests/${p.id}`, { action: p.action });
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/manageProductAffiliate.js

@@ -0,0 +1,45 @@
+/**
+ * Tool `manage_product_affiliate` — approuve / revoque / restaure un affilié
+ * d'un produit, ou fixe son pourcentage custom.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+const PRODUCT_TYPES = ['shop_product', 'agent_ai'];
+export const manageProductAffiliateTool = {
+    name: 'manage_product_affiliate',
+    description: "Gere un affilie d'un produit. action : approve (valide une demande en attente), revoke (coupe l'affiliation), restore (annule une revocation), set_percent (fixe un pourcentage custom pour cet affilie — fournir custom_percent, ou null pour repasser au % du produit). user_id = id de l'affilie (list_product_affiliates). IMPORTANT : action ecriture, demander confirmation.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            product_type: { type: 'string', enum: [...PRODUCT_TYPES] },
+            product_id: { type: 'number' },
+            user_id: { type: 'number' },
+            action: { type: 'string', enum: ['approve', 'revoke', 'restore', 'set_percent'] },
+            custom_percent: { type: ['number', 'null'], minimum: 0, maximum: 100, description: 'Requis si action=set_percent (null = % du produit).' },
+        },
+        required: ['lab', 'product_type', 'product_id', 'user_id', 'action'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        product_type: z.enum(PRODUCT_TYPES),
+        product_id: z.number().int().positive(),
+        user_id: z.number().int().positive(),
+        action: z.enum(['approve', 'revoke', 'restore', 'set_percent']),
+        custom_percent: z.number().min(0).max(100).nullable().optional(),
+    }),
+    async handler(args) {
+        const p = this.zodSchema.parse(args);
+        const body = { action: p.action };
+        if (p.action === 'set_percent')
+            body.custom_percent = p.custom_percent ?? null;
+        try {
+            const { data } = await http.post(`/mcp/labs/${encodeURIComponent(p.lab)}/affiliation/products/${p.product_type}/${p.product_id}/affiliates/${p.user_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/reactivateNewsletter.js

@@ -0,0 +1,28 @@
+/**
+ * Tool `reactivate_newsletter` — relance une newsletter arrêtée.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const reactivateNewsletterTool = {
+    name: 'reactivate_newsletter',
+    description: "Relance une newsletter precedemment arretee : la reactive et de-resilie les abonnements premium.",
+    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/reactivate`, {});
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/reorderClass.js

@@ -0,0 +1,34 @@
+/**
+ * Tool `reorder_class` — déplace un cours à une position d'affichage donnée.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const reorderClassTool = {
+    name: 'reorder_class',
+    description: "Deplace un cours a une position d'affichage donnee dans le Lab (0 = premier). class_id vient de list_classes.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            class_id: { type: 'number' },
+            position: { type: 'number', minimum: 0, description: "Position cible (0 = premier)" },
+        },
+        required: ['lab', 'class_id', 'position'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        class_id: z.number().int().positive(),
+        position: z.number().int().min(0),
+    }),
+    async handler(args) {
+        const p = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.put(`/mcp/labs/${encodeURIComponent(p.lab)}/classes/${p.class_id}/reorder`, { position: p.position });
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/reorderSmartJoinQuestions.js

@@ -0,0 +1,32 @@
+/**
+ * Tool `reorder_smart_join_questions` — réordonne les questions Smart Join.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const reorderSmartJoinQuestionsTool = {
+    name: 'reorder_smart_join_questions',
+    description: "Reordonne les questions Smart Join. order est la liste des question_id dans l'ordre souhaite (tous doivent appartenir au Lab).",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            order: { type: 'array', items: { type: 'number' }, minItems: 1 },
+        },
+        required: ['lab', 'order'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        order: z.array(z.number().int().positive()).min(1),
+    }),
+    async handler(args) {
+        const p = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.put(`/mcp/labs/${encodeURIComponent(p.lab)}/smart-join/questions/reorder`, { order: p.order });
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/scheduleNewsletterEdition.js

@@ -0,0 +1,34 @@
+/**
+ * Tool `schedule_newsletter_edition` — programme l'envoi d'une édition.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const scheduleNewsletterEditionTool = {
+    name: 'schedule_newsletter_edition',
+    description: "Programme l'envoi d'une edition de newsletter a une date/heure future. scheduled_at est interprete dans le fuseau configure de la newsletter (ex '2026-09-01T11:00:00'). Une edition deja envoyee ne peut pas etre programmee. edition_id vient de list_newsletter_editions.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            edition_id: { type: 'number' },
+            scheduled_at: { type: 'string', description: "Date/heure d'envoi (ISO local, ex 2026-09-01T11:00:00), dans le futur" },
+        },
+        required: ['lab', 'edition_id', 'scheduled_at'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        edition_id: z.number().int().positive(),
+        scheduled_at: z.string().min(1),
+    }),
+    async handler(args) {
+        const p = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.post(`/mcp/labs/${encodeURIComponent(p.lab)}/newsletter/editions/${p.edition_id}/schedule`, { scheduled_at: p.scheduled_at });
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/setCurrentSubscriptionPrice.js

@@ -0,0 +1,34 @@
+/**
+ * Tool `set_current_subscription_price` — choisit le prix courant d'un Lab
+ * parmi ses tiers, ou repasse le Lab en gratuit.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const setCurrentSubscriptionPriceTool = {
+    name: 'set_current_subscription_price',
+    description: "Definit le prix d'abonnement courant d'un Lab parmi ses tiers existants (price_id, cf get_subscription_settings). Omets price_id (ou passe null) pour desactiver tous les prix et repasser le Lab en gratuit. IMPORTANT : action ecriture, demander confirmation.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            price_id: { type: ['number', 'null'], description: "Id du tier a rendre courant (get_subscription_settings). null = repasse gratuit." },
+        },
+        required: ['lab'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        price_id: z.number().int().positive().nullable().optional(),
+    }),
+    async handler(args) {
+        const p = this.zodSchema.parse(args);
+        const body = { price_id: p.price_id ?? null };
+        try {
+            const { data } = await http.post(`/mcp/labs/${encodeURIComponent(p.lab)}/subscriptions/prices/set-current`, 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/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/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) }] };
+        }
+    },
+};