@connect-xlab/mcp-server 0.1.0

package/dist/config.js

@@ -0,0 +1,18 @@
+/**
+ * Config du serveur MCP. Toutes les valeurs viennent de l'environnement,
+ * poussees par Claude Desktop (via env dans claude_desktop_config.json)
+ * ou par ton shell si tu lances en dev.
+ */
+const requireEnv = (key) => {
+    const v = process.env[key];
+    if (!v || v.trim() === '') {
+        console.error(`[connectxlab-mcp] env var manquante : ${key}`);
+        process.exit(1);
+    }
+    return v;
+};
+export const config = {
+    apiBaseUrl: process.env.XLAB_API_URL || 'https://v1.connectxlab.io/api/v1',
+    mcpToken: requireEnv('XLAB_MCP_TOKEN'),
+    timeoutMs: parseInt(process.env.XLAB_TIMEOUT_MS || '15000', 10),
+};

package/dist/http.js

@@ -0,0 +1,30 @@
+/**
+ * Client axios preconfigure pour l'API Laravel. Toutes les requetes ajoutent
+ * automatiquement le Bearer + gerent les erreurs de facon standardisee pour
+ * que les tools MCP renvoient un message lisible par l'IA.
+ */
+import axios, { AxiosError } from 'axios';
+import { config } from './config.js';
+export const http = axios.create({
+    baseURL: config.apiBaseUrl,
+    timeout: config.timeoutMs,
+    headers: {
+        Authorization: `Bearer ${config.mcpToken}`,
+        Accept: 'application/json',
+    },
+});
+/**
+ * Normalise une erreur axios en message compact que l'IA peut relire.
+ * Retourne toujours un string court prefixe par le status.
+ */
+export function formatApiError(err) {
+    if (err instanceof AxiosError) {
+        const status = err.response?.status ?? 'network';
+        const body = err.response?.data;
+        const msg = (typeof body === 'object' && body && 'message' in body)
+            ? String(body.message)
+            : err.message;
+        return `[HTTP ${status}] ${msg}`;
+    }
+    return `[erreur] ${err.message ?? String(err)}`;
+}

package/dist/index.js

@@ -0,0 +1,178 @@
+#!/usr/bin/env node
+/**
+ * Serveur MCP ConnectXLab — expose les tools qui appellent l'API Laravel
+ * xlab-back. Se branche a Claude Desktop / Cursor / n'importe quel client
+ * MCP via stdio.
+ *
+ * Config attendue (env) :
+ *   XLAB_MCP_TOKEN  (requis)  ton token cote ConnectXLab, prefixe xlab_mcp_
+ *   XLAB_API_URL    (defaut https://v1.connectxlab.io/api/v1)
+ *   XLAB_TIMEOUT_MS (defaut 15000)
+ *
+ * Distribution :
+ *   npx -y @connect-xlab/mcp-server  (via config Claude Desktop, env transmis)
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { listLabsTool } from './tools/listLabs.js';
+import { listMembersTool } from './tools/listMembers.js';
+import { listPostsTool } from './tools/listPosts.js';
+import { listCategoriesTool } from './tools/listCategories.js';
+import { createPostTool } from './tools/createPost.js';
+import { sendDmTool } from './tools/sendDm.js';
+import { getEarningsTool } from './tools/getEarnings.js';
+import { approveMemberTool } from './tools/approveMember.js';
+import { rejectMemberTool } from './tools/rejectMember.js';
+import { kickMemberTool } from './tools/kickMember.js';
+import { listShopsTool } from './tools/listShops.js';
+import { getShopSalesTool } from './tools/getShopSales.js';
+import { listClassesTool } from './tools/listClasses.js';
+import { createClassTool } from './tools/createClass.js';
+import { deleteClassTool } from './tools/deleteClass.js';
+import { listEventsTool } from './tools/listEvents.js';
+import { createEventTool } from './tools/createEvent.js';
+import { deleteEventTool } from './tools/deleteEvent.js';
+import { pinPostTool } from './tools/pinPost.js';
+import { listCommentsTool } from './tools/listComments.js';
+import { addCommentTool } from './tools/addComment.js';
+import { searchMembersTool } from './tools/searchMembers.js';
+import { listAdminsTool } from './tools/listAdmins.js';
+import { getLabSettingsTool } from './tools/getLabSettings.js';
+import { updateLabSettingsTool } from './tools/updateLabSettings.js';
+import { getStatsTool } from './tools/getStats.js';
+import { updatePostTool } from './tools/updatePost.js';
+import { deletePostTool } from './tools/deletePost.js';
+import { updateClassTool } from './tools/updateClass.js';
+import { banMemberTool } from './tools/banMember.js';
+import { unbanMemberTool } from './tools/unbanMember.js';
+import { promoteAdminTool } from './tools/promoteAdmin.js';
+import { demoteAdminTool } from './tools/demoteAdmin.js';
+import { createCategoryTool } from './tools/createCategory.js';
+import { updateCategoryTool } from './tools/updateCategory.js';
+import { deleteCategoryTool } from './tools/deleteCategory.js';
+import { updateEventTool } from './tools/updateEvent.js';
+import { listInvitationsTool } from './tools/listInvitations.js';
+import { sendInvitationTool } from './tools/sendInvitation.js';
+import { revokeInvitationTool } from './tools/revokeInvitation.js';
+import { listPluginsTool } from './tools/listPlugins.js';
+import { togglePluginTool } from './tools/togglePlugin.js';
+import { setMetaPixelTool } from './tools/setMetaPixel.js';
+import { setWelcomeDmTool } from './tools/setWelcomeDm.js';
+import { listLevelsTool } from './tools/listLevels.js';
+import { updateLevelTool } from './tools/updateLevel.js';
+import { listLabLinksTool } from './tools/listLabLinks.js';
+import { createLabLinkTool } from './tools/createLabLink.js';
+import { updateLabLinkTool } from './tools/updateLabLink.js';
+import { deleteLabLinkTool } from './tools/deleteLabLink.js';
+import { newsletterDashboardTool } from './tools/newsletterDashboard.js';
+import { listNewsletterEditionsTool } from './tools/listNewsletterEditions.js';
+import { createNewsletterEditionTool } from './tools/createNewsletterEdition.js';
+import { sendNewsletterEditionTool } from './tools/sendNewsletterEdition.js';
+import { listNewsletterSubscribersTool } from './tools/listNewsletterSubscribers.js';
+import { listPodcastShowsTool } from './tools/listPodcastShows.js';
+import { createPodcastShowTool } from './tools/createPodcastShow.js';
+import { listPodcastEpisodesTool } from './tools/listPodcastEpisodes.js';
+import { listPodcastSubscribersTool } from './tools/listPodcastSubscribers.js';
+import { updateSlugTool } from './tools/updateSlug.js';
+import { listChannelSubscribersTool } from './tools/listChannelSubscribers.js';
+import { createShopProductTool } from './tools/createShopProduct.js';
+import { updateShopProductTool } from './tools/updateShopProduct.js';
+import { deleteShopProductTool } from './tools/deleteShopProduct.js';
+import { createPodcastEpisodeTool } from './tools/createPodcastEpisode.js';
+import { updatePodcastEpisodeTool } from './tools/updatePodcastEpisode.js';
+import { publishPodcastEpisodeTool } from './tools/publishPodcastEpisode.js';
+import { unpublishPodcastEpisodeTool } from './tools/unpublishPodcastEpisode.js';
+const tools = [
+    listLabsTool,
+    listMembersTool,
+    listPostsTool,
+    listCategoriesTool,
+    createPostTool,
+    sendDmTool,
+    getEarningsTool,
+    approveMemberTool,
+    rejectMemberTool,
+    kickMemberTool,
+    listShopsTool,
+    getShopSalesTool,
+    listClassesTool,
+    createClassTool,
+    deleteClassTool,
+    listEventsTool,
+    createEventTool,
+    deleteEventTool,
+    pinPostTool,
+    listCommentsTool,
+    addCommentTool,
+    searchMembersTool,
+    listAdminsTool,
+    getLabSettingsTool,
+    updateLabSettingsTool,
+    getStatsTool,
+    updatePostTool,
+    deletePostTool,
+    updateClassTool,
+    banMemberTool,
+    unbanMemberTool,
+    promoteAdminTool,
+    demoteAdminTool,
+    createCategoryTool,
+    updateCategoryTool,
+    deleteCategoryTool,
+    updateEventTool,
+    listInvitationsTool,
+    sendInvitationTool,
+    revokeInvitationTool,
+    listPluginsTool,
+    togglePluginTool,
+    setMetaPixelTool,
+    setWelcomeDmTool,
+    listLevelsTool,
+    updateLevelTool,
+    listLabLinksTool,
+    createLabLinkTool,
+    updateLabLinkTool,
+    deleteLabLinkTool,
+    newsletterDashboardTool,
+    listNewsletterEditionsTool,
+    createNewsletterEditionTool,
+    sendNewsletterEditionTool,
+    listNewsletterSubscribersTool,
+    listPodcastShowsTool,
+    createPodcastShowTool,
+    listPodcastEpisodesTool,
+    listPodcastSubscribersTool,
+    updateSlugTool,
+    listChannelSubscribersTool,
+    createShopProductTool,
+    updateShopProductTool,
+    deleteShopProductTool,
+    createPodcastEpisodeTool,
+    updatePodcastEpisodeTool,
+    publishPodcastEpisodeTool,
+    unpublishPodcastEpisodeTool,
+];
+const server = new Server({ name: 'connectxlab', version: '0.1.0' }, { capabilities: { tools: {} } });
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: tools.map(t => ({
+        name: t.name,
+        description: t.description,
+        inputSchema: t.inputSchema,
+    })),
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const tool = tools.find(t => t.name === name);
+    if (!tool) {
+        return {
+            isError: true,
+            content: [{ type: 'text', text: `Tool inconnu : ${name}` }],
+        };
+    }
+    return await tool.handler(args ?? {});
+});
+const transport = new StdioServerTransport();
+await server.connect(transport);
+// Log stderr pour debug (Claude Desktop l'affiche dans les logs).
+console.error(`[connectxlab-mcp] ready — ${tools.length} tools : ${tools.map(t => t.name).join(', ')}`);

package/dist/tools/addComment.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const addCommentTool = {
+    name: 'add_comment',
+    description: "Ajoute un commentaire a un post au nom de l'owner (le token).",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            post_id: { type: 'number' },
+            body: { type: 'string', description: 'Contenu du commentaire (max 5000 car)' },
+        },
+        required: ['lab', 'post_id', 'body'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        post_id: z.number().int().positive(),
+        body: 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)}/posts/${parsed.post_id}/comments`, { body: parsed.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/approveMember.js

@@ -0,0 +1,29 @@
+/**
+ * Tool `approve_member` — approuve un membre pending.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const approveMemberTool = {
+    name: 'approve_member',
+    description: "Approuve un membre en attente (pending -> approved). L'id est celui de list_members data[].id. Idempotent.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string', description: 'Id ou url du Lab' },
+            member_id: { type: 'number', description: "Id du membre (list_members data[].id)" },
+        },
+        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}/approve`);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/banMember.js

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const banMemberTool = {
+    name: 'ban_member',
+    description: "Bannit un membre du Lab : passe son status a 'blocked' (l'empeche de se reinscrire, different de kick qui autorise le retour). IMPORTANT : action forte, demander confirmation utilisateur.",
+    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}/ban`);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/createCategory.js

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const createCategoryTool = {
+    name: 'create_category',
+    description: "Cree une categorie pour classer les posts du Lab. is_private cache la categorie aux non-abonnes payants.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            name: { type: 'string', maxLength: 30 },
+            description: { type: 'string', maxLength: 255 },
+            is_private: { type: 'boolean' },
+            min_user_level: { type: 'number', minimum: 0 },
+        },
+        required: ['lab', 'name', 'description'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        name: z.string().max(30),
+        description: z.string().max(255),
+        is_private: z.boolean().optional(),
+        min_user_level: z.number().int().min(0).nullable().optional(),
+    }),
+    async handler(args) {
+        const parsed = this.zodSchema.parse(args);
+        const { lab, ...body } = parsed;
+        try {
+            const { data } = await http.post(`/mcp/labs/${encodeURIComponent(lab)}/categories`, 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/createClass.js

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const createClassTool = {
+    name: 'create_class',
+    description: "Cree une classe/cours dans un Lab. name max 50 car, description max 400 car.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            name: { type: 'string', description: 'Titre de la classe (max 50 car)' },
+            description: { type: 'string', description: 'Description (max 400 car)' },
+            access: { type: 'string', description: "Type d'acces (ex: 'all', 'ONLY'). Defaut 'all'." },
+            min_user_level: { type: 'number', description: 'Niveau membre requis (optionnel)' },
+            is_published: { type: 'boolean', default: false },
+        },
+        required: ['lab', 'name', 'description'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        name: z.string().max(50),
+        description: z.string().max(400),
+        access: z.string().optional(),
+        min_user_level: z.number().int().min(0).optional(),
+        is_published: z.boolean().optional(),
+    }),
+    async handler(args) {
+        const parsed = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.post(`/mcp/labs/${encodeURIComponent(parsed.lab)}/classes`, parsed);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/createEvent.js

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const createEventTool = {
+    name: 'create_event',
+    description: "Cree un evenement dans un Lab. event_date au format ISO 8601 (ex: 2026-08-15T18:00:00Z). timezone au format IANA (ex: Europe/Paris).",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            title: { type: 'string', description: 'Titre (max 50 car)' },
+            description: { type: 'string' },
+            event_date: { type: 'string', description: 'Date/heure ISO 8601' },
+            timezone: { type: 'string', description: 'IANA (ex: Europe/Paris)' },
+            duration: { type: 'string', description: 'ex: "1 hour", "90 min"' },
+            reminder_enabled: { type: 'boolean', default: false },
+        },
+        required: ['lab', 'title', 'description', 'event_date', 'timezone', 'duration'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        title: z.string().max(50),
+        description: z.string(),
+        event_date: z.string(),
+        timezone: z.string(),
+        duration: z.string(),
+        reminder_enabled: z.boolean().optional(),
+    }),
+    async handler(args) {
+        const parsed = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.post(`/mcp/labs/${encodeURIComponent(parsed.lab)}/events`, parsed);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/createLabLink.js

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const createLabLinkTool = {
+    name: 'create_lab_link',
+    description: "Cree un lien sidebar custom (label + url). Max 5 par Lab. Position ajoutee automatiquement a la fin.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            label: { type: 'string', maxLength: 30 },
+            url: { type: 'string', maxLength: 255 },
+        },
+        required: ['lab', 'label', 'url'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({ lab: z.string(), label: z.string().max(30), url: z.string().max(255) }),
+    async handler(args) {
+        const parsed = this.zodSchema.parse(args);
+        const { lab, ...body } = parsed;
+        try {
+            const { data } = await http.post(`/mcp/labs/${encodeURIComponent(lab)}/links`, 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/createNewsletterEdition.js

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const createNewsletterEditionTool = {
+    name: 'create_newsletter_edition',
+    description: "Cree un draft d'edition newsletter (title + subject + body HTML). L'envoi se fait via send_newsletter_edition.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            title: { type: 'string', maxLength: 255 },
+            subject: { type: 'string', maxLength: 255, description: "Objet email" },
+            body_html: { type: 'string', description: "Corps HTML" },
+            access: { type: 'string', enum: ['free', 'premium'] },
+            audience: { type: 'string', enum: ['all', 'premium', 'free', 'lab_members'] },
+        },
+        required: ['lab', 'title', 'subject', 'body_html'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        title: z.string().max(255),
+        subject: z.string().max(255),
+        body_html: z.string(),
+        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, ...body } = p;
+        try {
+            const { data } = await http.post(`/mcp/labs/${encodeURIComponent(lab)}/newsletter/editions`, 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/createPodcastEpisode.js

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const createPodcastEpisodeTool = {
+    name: 'create_podcast_episode',
+    description: "Cree un episode (draft) dans un show. Audio a uploader ensuite via le front. Numero d'episode assigne automatiquement.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            show_id: { type: 'number' },
+            title: { type: 'string', maxLength: 255 },
+            description: { type: 'string' },
+            access: { type: 'string', enum: ['free', 'premium'] },
+            season: { type: 'number', minimum: 1 },
+        },
+        required: ['lab', 'show_id', 'title'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        show_id: z.number().int().positive(),
+        title: z.string().max(255),
+        description: z.string().nullable().optional(),
+        access: z.enum(['free', 'premium']).optional(),
+        season: z.number().int().min(1).optional(),
+    }),
+    async handler(args) {
+        const p = this.zodSchema.parse(args);
+        const { lab, show_id, ...body } = p;
+        try {
+            const { data } = await http.post(`/mcp/labs/${encodeURIComponent(lab)}/podcast/shows/${show_id}/episodes`, 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/createPodcastShow.js

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const createPodcastShowTool = {
+    name: 'create_podcast_show',
+    description: "Cree un nouveau show podcast dans le Lab (titre + description + auteur). Le slug est genere automatiquement.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            title: { type: 'string', maxLength: 255 },
+            description: { type: 'string' },
+            author_name: { type: 'string', maxLength: 191 },
+        },
+        required: ['lab', 'title'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        title: z.string().max(255),
+        description: z.string().nullable().optional(),
+        author_name: z.string().max(191).nullable().optional(),
+    }),
+    async handler(args) {
+        const p = this.zodSchema.parse(args);
+        const { lab, ...body } = p;
+        try {
+            const { data } = await http.post(`/mcp/labs/${encodeURIComponent(lab)}/podcast/shows`, 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/createPost.js

@@ -0,0 +1,41 @@
+/**
+ * Tool `create_post` — cree un post dans un Lab. Necessite un category_id
+ * valide (recupere via list_categories).
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const createPostTool = {
+    name: 'create_post',
+    description: "Cree un nouveau post dans un Lab. Le body peut etre du texte simple (sera wrappe en <p>) ou du HTML. Necessite un category_id valide — utilise list_categories pour l'obtenir.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string', description: 'Id ou url du Lab' },
+            title: { type: 'string', description: 'Titre du post (max 255 char)' },
+            body: { type: 'string', description: 'Contenu du post — texte ou HTML' },
+            category_id: { type: 'number', description: "Id d'une categorie du Lab (list_categories)" },
+        },
+        required: ['lab', 'title', 'body', 'category_id'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        title: z.string().min(1).max(255),
+        body: z.string().min(1),
+        category_id: z.number().int().positive(),
+    }),
+    async handler(args) {
+        const parsed = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.post(`/mcp/labs/${encodeURIComponent(parsed.lab)}/posts`, {
+                title: parsed.title,
+                body: parsed.body,
+                category_id: parsed.category_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/createShopProduct.js

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const createShopProductTool = {
+    name: 'create_shop_product',
+    description: "Cree un produit dans la boutique du Lab. Files (bannieres, PDF) non geres par MCP — a uploader ensuite via le front. Prix en centimes (price_cents).",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            title: { type: 'string', maxLength: 255 },
+            short_description: { type: 'string' },
+            description: { type: 'string' },
+            price_cents: { type: 'number', minimum: 0, description: 'Prix en centimes (ex 2990 = 29.90 EUR)' },
+            offer_type: { type: 'string', enum: ['digital', 'physical', 'calendar', 'service'] },
+            payment_mode: { type: 'string', enum: ['external', 'stripe'] },
+            payment_link_text: { type: 'string', maxLength: 255 },
+            support_email: { type: 'string', format: 'email' },
+            is_published: { type: 'boolean' },
+        },
+        required: ['lab', 'title', 'short_description', 'description'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        title: z.string().max(255),
+        short_description: z.string(),
+        description: z.string(),
+        price_cents: z.number().int().min(0).nullable().optional(),
+        offer_type: z.enum(['digital', 'physical', 'calendar', 'service']).optional(),
+        payment_mode: z.enum(['external', 'stripe']).optional(),
+        payment_link_text: z.string().max(255).nullable().optional(),
+        support_email: z.string().email().nullable().optional(),
+        is_published: z.boolean().optional(),
+    }),
+    async handler(args) {
+        const p = this.zodSchema.parse(args);
+        const { lab, ...body } = p;
+        try {
+            const { data } = await http.post(`/mcp/labs/${encodeURIComponent(lab)}/shops`, body);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};