@connect-xlab/mcp-server 0.1.0

package/dist/tools/listMembers.js

@@ -0,0 +1,49 @@
+/**
+ * Tool `list_members` — liste les membres d'un Lab.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const listMembersTool = {
+    name: 'list_members',
+    description: "Liste les membres d'un Lab. Utilise l'id ou l'url du Lab (recupere avec list_labs). Filtre par status (approved/pending/rejected/left).",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string', description: "Id numerique OU url (group_url) du Lab" },
+            status: { type: 'string', enum: ['approved', 'pending', 'rejected', 'left'], default: 'approved' },
+            limit: { type: 'number', minimum: 1, maximum: 100, default: 50 },
+            offset: { type: 'number', minimum: 0, default: 0 },
+        },
+        required: ['lab'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        status: z.enum(['approved', 'pending', 'rejected', 'left']).optional(),
+        limit: z.number().int().min(1).max(100).optional(),
+        offset: z.number().int().min(0).optional(),
+    }),
+    async handler(args) {
+        const parsed = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.get(`/mcp/labs/${encodeURIComponent(parsed.lab)}/members`, {
+                params: {
+                    status: parsed.status,
+                    limit: parsed.limit,
+                    offset: parsed.offset,
+                },
+            });
+            return {
+                content: [
+                    { type: 'text', text: JSON.stringify(data, null, 2) },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                isError: true,
+                content: [{ type: 'text', text: formatApiError(err) }],
+            };
+        }
+    },
+};

package/dist/tools/listNewsletterEditions.js

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const listNewsletterEditionsTool = {
+    name: 'list_newsletter_editions',
+    description: "Liste les editions de la newsletter du Lab (drafts + scheduled + sent).",
+    inputSchema: { type: 'object', properties: { lab: { type: 'string' }, limit: { type: 'number', minimum: 1, maximum: 50 } }, required: ['lab'], additionalProperties: false },
+    zodSchema: z.object({ lab: z.string(), limit: z.number().int().min(1).max(50).optional() }),
+    async handler(args) {
+        const p = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.get(`/mcp/labs/${encodeURIComponent(p.lab)}/newsletter/editions`, { params: { limit: p.limit } });
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/listNewsletterSubscribers.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const listNewsletterSubscribersTool = {
+    name: 'list_newsletter_subscribers',
+    description: "Liste les abonnes de la newsletter du Lab. Filtrable par access (free / premium).",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            plan: { type: 'string', enum: ['free', 'monthly', 'yearly', 'lab_member'] },
+            limit: { type: 'number', minimum: 1, maximum: 200 },
+        },
+        required: ['lab'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        plan: z.enum(['free', 'monthly', 'yearly', 'lab_member']).optional(),
+        limit: z.number().int().min(1).max(200).optional(),
+    }),
+    async handler(args) {
+        const p = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.get(`/mcp/labs/${encodeURIComponent(p.lab)}/newsletter/subscribers`, { params: { plan: p.plan, limit: p.limit } });
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/listPlugins.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const listPluginsTool = {
+    name: 'list_plugins',
+    description: "Liste l'etat des plug-ins du Lab : Meta Pixel, Google Ads (via meta_google), Welcome DM, langue du Lab.",
+    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.get(`/mcp/labs/${encodeURIComponent(parsed.lab)}/plugins`);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/listPodcastEpisodes.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const listPodcastEpisodesTool = {
+    name: 'list_podcast_episodes',
+    description: "Liste les episodes d'un show podcast (drafts + publies). show_id vient de list_podcast_shows.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            show_id: { type: 'number' },
+            limit: { type: 'number', minimum: 1, maximum: 100 },
+        },
+        required: ['lab', 'show_id'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        show_id: z.number().int().positive(),
+        limit: z.number().int().min(1).max(100).optional(),
+    }),
+    async handler(args) {
+        const p = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.get(`/mcp/labs/${encodeURIComponent(p.lab)}/podcast/shows/${p.show_id}/episodes`, { params: { limit: p.limit } });
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/listPodcastShows.js

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const listPodcastShowsTool = {
+    name: 'list_podcast_shows',
+    description: "Liste les shows podcast d'un Lab (Podcast Studio, modele multi-shows).",
+    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.get(`/mcp/labs/${encodeURIComponent(p.lab)}/podcast/shows`);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/listPodcastSubscribers.js

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const listPodcastSubscribersTool = {
+    name: 'list_podcast_subscribers',
+    description: "Liste les abonnes premium podcast d'un Lab (1 abo debloque tous les shows).",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            limit: { type: 'number', minimum: 1, maximum: 200 },
+        },
+        required: ['lab'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({ lab: z.string(), limit: z.number().int().min(1).max(200).optional() }),
+    async handler(args) {
+        const p = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.get(`/mcp/labs/${encodeURIComponent(p.lab)}/podcast/subscribers`, { params: { limit: p.limit } });
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/listPosts.js

@@ -0,0 +1,49 @@
+/**
+ * Tool `list_posts` — liste les posts d'un Lab.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const listPostsTool = {
+    name: 'list_posts',
+    description: "Liste les posts d'un Lab (les plus recents d'abord). Option `pinned_only: true` pour ne renvoyer que les posts epingles.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string', description: "Id ou url du Lab" },
+            limit: { type: 'number', minimum: 1, maximum: 100, default: 20 },
+            offset: { type: 'number', minimum: 0, default: 0 },
+            pinned_only: { type: 'boolean', default: false },
+        },
+        required: ['lab'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        limit: z.number().int().min(1).max(100).optional(),
+        offset: z.number().int().min(0).optional(),
+        pinned_only: z.boolean().optional(),
+    }),
+    async handler(args) {
+        const parsed = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.get(`/mcp/labs/${encodeURIComponent(parsed.lab)}/posts`, {
+                params: {
+                    limit: parsed.limit,
+                    offset: parsed.offset,
+                    pinned: parsed.pinned_only ? '1' : undefined,
+                },
+            });
+            return {
+                content: [
+                    { type: 'text', text: JSON.stringify(data, null, 2) },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                isError: true,
+                content: [{ type: 'text', text: formatApiError(err) }],
+            };
+        }
+    },
+};

package/dist/tools/listShops.js

@@ -0,0 +1,28 @@
+/**
+ * Tool `list_shops` — liste les produits/offres de la boutique d'un Lab.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const listShopsTool = {
+    name: 'list_shops',
+    description: "Liste les produits/offres de la boutique d'un Lab. Renvoie id, shop_url, titre, description courte, offer_type (digital/calendar/etc), prix, publie/visible.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string', description: 'Id ou url du Lab' },
+        },
+        required: ['lab'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({ lab: z.string() }),
+    async handler(args) {
+        const parsed = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.get(`/mcp/labs/${encodeURIComponent(parsed.lab)}/shops`);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/newsletterDashboard.js

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const newsletterDashboardTool = {
+    name: 'newsletter_dashboard',
+    description: "Snapshot du plug-in Newsletter d'un Lab : abonnes (total/premium/free), editions (total/sent/draft/scheduled), etat actif.",
+    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.get(`/mcp/labs/${encodeURIComponent(p.lab)}/newsletter/dashboard`);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/pinPost.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const pinPostTool = {
+    name: 'pin_post',
+    description: "Epingle ou desepingle un post du Lab. Passer pinned=false pour desepingler.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            post_id: { type: 'number' },
+            pinned: { type: 'boolean', default: true, description: 'true pour epingler, false pour retirer' },
+        },
+        required: ['lab', 'post_id'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        post_id: z.number().int().positive(),
+        pinned: z.boolean().optional(),
+    }),
+    async handler(args) {
+        const parsed = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.put(`/mcp/labs/${encodeURIComponent(parsed.lab)}/posts/${parsed.post_id}/pin`, { pinned: parsed.pinned ?? true });
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/promoteAdmin.js

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const promoteAdminTool = {
+    name: 'promote_admin',
+    description: "Promeut un membre en admin (type 'basic' -> 'admin'). Un admin peut moderer, poster, gerer les autres membres. Idempotent. Un super-admin ne peut pas etre modifie via MCP.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            member_id: { type: 'number' },
+        },
+        required: ['lab', 'member_id'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({ lab: z.string(), member_id: z.number().int().positive() }),
+    async handler(args) {
+        const parsed = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.put(`/mcp/labs/${encodeURIComponent(parsed.lab)}/members/${parsed.member_id}/promote`);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/publishPodcastEpisode.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const publishPodcastEpisodeTool = {
+    name: 'publish_podcast_episode',
+    description: "Publie un episode podcast (draft -> published + published_at=now). Rendu accessible aux membres/abonnes.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            show_id: { type: 'number' },
+            episode_id: { type: 'number' },
+        },
+        required: ['lab', 'show_id', 'episode_id'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        show_id: z.number().int().positive(),
+        episode_id: z.number().int().positive(),
+    }),
+    async handler(args) {
+        const p = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.patch(`/mcp/labs/${encodeURIComponent(p.lab)}/podcast/shows/${p.show_id}/episodes/${p.episode_id}/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/rejectMember.js

@@ -0,0 +1,29 @@
+/**
+ * Tool `reject_member` — refuse une demande d'adhesion pending.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const rejectMemberTool = {
+    name: 'reject_member',
+    description: "Refuse une demande d'adhesion en attente (pending -> rejected). L'id est celui de list_members data[].id.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string', description: 'Id ou url du Lab' },
+            member_id: { type: 'number', description: 'Id du membre' },
+        },
+        required: ['lab', 'member_id'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({ lab: z.string(), member_id: z.number().int().positive() }),
+    async handler(args) {
+        const parsed = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.put(`/mcp/labs/${encodeURIComponent(parsed.lab)}/members/${parsed.member_id}/reject`);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/revokeInvitation.js

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const revokeInvitationTool = {
+    name: 'revoke_invitation',
+    description: "Revoque une invitation en attente. L'id est celui renvoye par list_invitations.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            invitation_id: { type: 'number' },
+        },
+        required: ['lab', 'invitation_id'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({ lab: z.string(), invitation_id: z.number().int().positive() }),
+    async handler(args) {
+        const parsed = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.delete(`/mcp/labs/${encodeURIComponent(parsed.lab)}/invitations/${parsed.invitation_id}`);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/searchMembers.js

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const searchMembersTool = {
+    name: 'search_members',
+    description: "Recherche des membres du Lab par firstname/lastname/email (min 2 caracteres). Utile quand tu veux trouver un membre precis dans un Lab qui en a beaucoup.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            q: { type: 'string', description: 'Terme de recherche (min 2 car)' },
+            limit: { type: 'number', minimum: 1, maximum: 50, default: 20 },
+        },
+        required: ['lab', 'q'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        q: z.string().min(2),
+        limit: z.number().int().min(1).max(50).optional(),
+    }),
+    async handler(args) {
+        const parsed = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.get(`/mcp/labs/${encodeURIComponent(parsed.lab)}/members/search`, {
+                params: { q: parsed.q, limit: parsed.limit },
+            });
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/sendDm.js

@@ -0,0 +1,35 @@
+/**
+ * Tool `send_dm` — envoie un message direct a un membre du Lab.
+ * L'id membre est celui retourne par list_members (`data[].id`, pas user_id).
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const sendDmTool = {
+    name: 'send_dm',
+    description: "Envoie un message direct a un membre du Lab. L'id du membre est celui retourne par list_members (colonne `id`, PAS user_id).",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string', description: 'Id ou url du Lab' },
+            member_id: { type: 'number', description: 'Id de la ligne membre (list_members data[].id)' },
+            message: { type: 'string', description: 'Contenu du message (max 5000 char)' },
+        },
+        required: ['lab', 'member_id', 'message'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        member_id: z.number().int().positive(),
+        message: z.string().min(1).max(5000),
+    }),
+    async handler(args) {
+        const parsed = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.post(`/mcp/labs/${encodeURIComponent(parsed.lab)}/members/${parsed.member_id}/dm`, { message: parsed.message });
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/sendInvitation.js

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const sendInvitationTool = {
+    name: 'send_invitation',
+    description: "Envoie une invitation par email a rejoindre le Lab. Accepte un seul email ou une liste. Ignore les emails deja invites.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            email: { type: 'string', format: 'email' },
+            emails: { type: 'array', items: { type: 'string', format: 'email' } },
+        },
+        required: ['lab'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        email: z.string().email().optional(),
+        emails: z.array(z.string().email()).optional(),
+    }).refine(d => d.email || (d.emails && d.emails.length > 0), {
+        message: 'Fournir au moins un email (email ou emails[]).',
+    }),
+    async handler(args) {
+        const parsed = this.zodSchema.parse(args);
+        const { lab, ...body } = parsed;
+        try {
+            const { data } = await http.post(`/mcp/labs/${encodeURIComponent(lab)}/invitations`, 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/sendNewsletterEdition.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const sendNewsletterEditionTool = {
+    name: 'send_newsletter_edition',
+    description: "Marque une edition draft comme envoyee. NOTE : cet appel MCP flag l'edition en 'sent' — l'envoi email reel se fait via l'endpoint xlab standard. Demander confirmation.",
+    inputSchema: {
+        type: 'object',
+        properties: { lab: { type: 'string' }, edition_id: { type: 'number' } },
+        required: ['lab', 'edition_id'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({ lab: z.string(), edition_id: z.number().int().positive() }),
+    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}/send`);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/setMetaPixel.js

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const setMetaPixelTool = {
+    name: 'set_meta_pixel',
+    description: "Configure le pixel Meta (Facebook/Instagram) sur le Lab : id du pixel + access token optionnel.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            meta_id: { type: 'string', description: 'Id du pixel Meta' },
+            token: { type: 'string', description: 'Access token Meta (optionnel)' },
+            enabled: { type: 'boolean' },
+        },
+        required: ['lab', 'meta_id'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        meta_id: z.string().max(255),
+        token: z.string().nullable().optional(),
+        enabled: z.boolean().optional(),
+    }),
+    async handler(args) {
+        const parsed = this.zodSchema.parse(args);
+        const { lab, ...body } = parsed;
+        try {
+            const { data } = await http.put(`/mcp/labs/${encodeURIComponent(lab)}/plugins/meta-pixel`, 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/setWelcomeDm.js

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const setWelcomeDmTool = {
+    name: 'set_welcome_dm',
+    description: "Configure le DM de bienvenue envoye automatiquement aux nouveaux membres. Champs optionnels : n'envoie que ce que tu veux changer.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            enabled: { type: 'boolean' },
+            title: { type: 'string', maxLength: 500 },
+            text: { type: 'string' },
+            cta_text: { type: 'string', maxLength: 255 },
+            cta_url: { type: 'string', maxLength: 255 },
+        },
+        required: ['lab'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        enabled: z.boolean().optional(),
+        title: z.string().max(500).nullable().optional(),
+        text: z.string().nullable().optional(),
+        cta_text: z.string().max(255).nullable().optional(),
+        cta_url: z.string().max(255).nullable().optional(),
+    }),
+    async handler(args) {
+        const parsed = this.zodSchema.parse(args);
+        const { lab, ...body } = parsed;
+        try {
+            const { data } = await http.put(`/mcp/labs/${encodeURIComponent(lab)}/plugins/welcome-dm`, body);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};