@connect-xlab/mcp-server 0.3.4 → 0.4.0

package/dist/compact.js

@@ -0,0 +1,301 @@
+/**
+ * Economie de tokens (0.4.0).
+ *
+ *  - Reponses legeres : JSON sans indentation, `fields` pour ne garder que
+ *    certains champs, `limit` a 20 par defaut, `next_offset` quand il reste
+ *    des elements.
+ *  - Descriptions courtes : une phrase par tool et par parametre dans la
+ *    liste envoyee au client ; la doc complete passe par `describe_tool`.
+ *  - Mode compact (defaut) : le client ne voit que search_tools /
+ *    describe_tool / execute ; les 192 tools restent appelables derriere
+ *    `execute`. XLAB_MCP_MODE=full reexpose tous les tools.
+ */
+const DEFAULT_LIMIT = 20;
+/** Actions qui suppriment, retirent ou envoient quelque chose : accord explicite de l'utilisateur. */
+const SENSITIVE_PREFIXES = ['delete_', 'ban_', 'kick_', 'reject_', 'send_', 'revoke_', 'clear_', 'demote_', 'stop_', 'unpublish_'];
+const SENSITIVE_TOOLS = new Set(['update_slug', 'schedule_newsletter_edition', 'set_current_subscription_price', 'publish_podcast_episode']);
+export function isSensitive(name) {
+    return SENSITIVE_TOOLS.has(name) || SENSITIVE_PREFIXES.some(prefix => name.startsWith(prefix));
+}
+/** Tools de lecture : ceux qui acceptent `fields`. */
+export function isReadTool(name) {
+    return /^(list_|get_|search_|preview_|check_)/.test(name) || name === 'newsletter_dashboard';
+}
+/** Premiere phrase, coupee proprement au-dela de `max` caracteres. */
+export function firstSentence(text, max) {
+    if (!text)
+        return '';
+    const flat = text.replace(/\s+/g, ' ').trim();
+    const match = flat.match(/^(.+?[.!?])(\s|$)/);
+    let sentence = match ? match[1] : flat;
+    if (sentence.length > max) {
+        const cut = sentence.slice(0, max - 1);
+        sentence = cut.slice(0, cut.lastIndexOf(' ') > max / 2 ? cut.lastIndexOf(' ') : cut.length) + '…';
+    }
+    return sentence;
+}
+export function shortDescription(tool) {
+    const summary = firstSentence(tool.description, 110);
+    return isSensitive(tool.name) ? `${summary} Action sensible : accord de l'utilisateur avant.` : summary;
+}
+/** Bornes retirees de la liste : la validation du tool (zod) les applique toujours, avec un message clair. */
+const BOUND_KEYS = new Set(['minimum', 'maximum', 'minLength', 'maxLength', 'minItems', 'maxItems', 'additionalProperties']);
+function stripBounds(value) {
+    if (Array.isArray(value))
+        return value.map(stripBounds);
+    if (typeof value !== 'object' || value === null)
+        return value;
+    const copy = {};
+    for (const [key, inner] of Object.entries(value)) {
+        if (!BOUND_KEYS.has(key))
+            copy[key] = stripBounds(inner);
+    }
+    return copy;
+}
+/**
+ * Schema allege : descriptions de parametres raccourcies (celle de `lab`,
+ * commune a tous les tools, est dans les instructions du serveur), bornes
+ * retirees, limit a 20, `fields` sur les lectures.
+ */
+export function lightSchema(tool) {
+    const properties = {};
+    for (const [key, prop] of Object.entries(tool.inputSchema.properties ?? {})) {
+        const copy = stripBounds(prop);
+        if (key === 'lab') {
+            delete copy.description;
+        }
+        else if (typeof copy.description === 'string') {
+            copy.description = firstSentence(copy.description, 50);
+        }
+        if (key === 'limit') {
+            copy.default = defaultLimit(prop);
+        }
+        properties[key] = copy;
+    }
+    if (isReadTool(tool.name)) {
+        properties.fields = { type: 'array', items: { type: 'string' } };
+    }
+    const { additionalProperties: _strict, ...schema } = tool.inputSchema;
+    return { ...schema, properties };
+}
+function defaultLimit(limitProp) {
+    const max = typeof limitProp?.maximum === 'number' ? limitProp.maximum : DEFAULT_LIMIT;
+    return Math.min(DEFAULT_LIMIT, max);
+}
+/**
+ * Lance un tool avec les reglages economes : `fields` retire des arguments,
+ * limit a 20 si le tool en a une et que rien n'est demande, reponse compacte.
+ */
+export async function runTool(tool, rawArgs) {
+    const args = { ...rawArgs };
+    const fields = Array.isArray(args.fields) ? args.fields.filter((f) => typeof f === 'string') : [];
+    delete args.fields;
+    const limitProp = tool.inputSchema.properties?.limit;
+    if (limitProp && args.limit === undefined) {
+        args.limit = defaultLimit(limitProp);
+    }
+    const paged = !!limitProp && !!tool.inputSchema.properties?.offset;
+    let result;
+    try {
+        result = await tool.handler(args);
+    }
+    catch (err) {
+        // Arguments refuses par la validation du tool : message court et relisible.
+        const issues = err.issues;
+        const detail = issues?.length
+            ? issues.map(issue => `${issue.path.join('.') || 'arguments'} : ${issue.message}`).join(' ; ')
+            : err.message ?? String(err);
+        return { isError: true, content: [{ type: 'text', text: `[arguments] ${detail}` }] };
+    }
+    if (result.isError)
+        return result;
+    return {
+        ...result,
+        content: result.content.map(part => ({
+            ...part,
+            text: compactText(part.text, {
+                fields,
+                limit: typeof args.limit === 'number' ? args.limit : undefined,
+                offset: typeof args.offset === 'number' ? args.offset : 0,
+                paged,
+            }),
+        })),
+    };
+}
+function compactText(text, options) {
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+    // Enveloppe { status: true, data } de l'API : seul le contenu compte.
+    if (isObject(value) && value.status === true && 'data' in value) {
+        const { status: _status, ...rest } = value;
+        value = Object.keys(rest).length === 1 ? rest.data : rest;
+    }
+    if (options.fields.length) {
+        value = pickFields(value, options.fields);
+    }
+    // Page pleine : il en reste peut-etre, on donne l'offset suivant.
+    if (options.paged && options.limit) {
+        const list = Array.isArray(value) ? value : isObject(value) && Array.isArray(value.data) ? value.data : null;
+        const nextOffset = options.offset + options.limit;
+        const total = isObject(value) && isObject(value.meta) && typeof value.meta.total === 'number' ? value.meta.total : null;
+        if (list && list.length >= options.limit && (total === null || nextOffset < total)) {
+            value = Array.isArray(value) ? { items: value, next_offset: nextOffset } : { ...value, next_offset: nextOffset };
+        }
+    }
+    return JSON.stringify(value);
+}
+function pickFields(value, fields) {
+    if (Array.isArray(value))
+        return value.map(item => pickFields(item, fields));
+    if (!isObject(value))
+        return value;
+    // Liste enveloppee ({ data: [...], meta }) : le filtre s'applique aux elements.
+    if (Array.isArray(value.data))
+        return { ...value, data: pickFields(value.data, fields) };
+    const picked = {};
+    for (const field of fields) {
+        if (field in value)
+            picked[field] = value[field];
+    }
+    return Object.keys(picked).length ? picked : value;
+}
+function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function normalize(text) {
+    return text.toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '').replace(/_/g, ' ');
+}
+/** Verbes francais -> mot des noms de tools (en anglais). */
+const VERB_HINTS = [
+    [/^envo/, 'send'], [/^supprim|^efface/, 'delete'], [/^cre/, 'create'], [/^modifi|^change|^mettre/, 'update'],
+    [/^list|^voir|^affich/, 'list'], [/^banni/, 'ban'], [/^exclu|^vire|^retir/, 'kick'], [/^publi/, 'publish'],
+    [/^program|^planifi/, 'schedule'], [/^invit/, 'invitation'], [/^approuv|^valid|^accept/, 'approve'],
+    [/^refus|^rejet/, 'reject'], [/^cherch|^trouv/, 'search'], [/^epingl/, 'pin'], [/^stat|^chiffr/, 'stats'],
+    [/^revenu|^gain|^argent/, 'earnings'], [/^vente/, 'sales'], [/^membre/, 'member'], [/^cours|^formation|^classe/, 'class'],
+    [/^evenement/, 'event'], [/^boutique|^produit/, 'shop'], [/^tunnel/, 'funnel'], [/^lien/, 'link'],
+    [/^attente/, 'pending'], [/^abonne/, 'subscription'], [/^prix|^tarif/, 'price'],
+];
+/** Mots trop courants pour departager les actions. */
+const STOP_WORDS = new Set(['le', 'la', 'les', 'un', 'une', 'des', 'du', 'de', 'mes', 'mon', 'ma', 'ses', 'son', 'sa', 'au', 'aux', 'en', 'et', 'pour', 'sur', 'avec', 'dans', 'lab', 'qui', 'que', 'quelqu']);
+/** Recherche simple par mots dans le nom et la description des tools. */
+export function searchTools(tools, query, limit) {
+    const base = normalize(query).split(/[^a-z0-9]+/).filter(word => word.length > 1 && !STOP_WORDS.has(word));
+    const hints = base.flatMap(word => VERB_HINTS.filter(([pattern]) => pattern.test(word)).map(([, hint]) => hint));
+    const ranked = tools
+        .map(tool => {
+        const name = normalize(tool.name);
+        const parts = name.split(' ');
+        const description = normalize(tool.description);
+        let score = base.reduce((sum, word) => {
+            const stem = word.length > 4 ? word.slice(0, -1) : word; // membres ~ membre
+            return sum + (name.includes(stem) ? 3 : 0) + (description.includes(stem) ? 1 : 0);
+        }, 0);
+        // Mot traduit present tel quel dans le nom (« ban » oui, « unban » non) ; verbe en tete : bonus.
+        for (const hint of hints) {
+            if (parts.includes(hint) || parts.includes(hint + 's'))
+                score += parts[0] === hint ? 5 : 4;
+            else if (description.includes(hint))
+                score += 1;
+        }
+        return { tool, score };
+    })
+        .filter(entry => base.length === 0 || entry.score > 0)
+        // A egalite, l'action la plus generale (nom le plus court) d'abord : get_stats avant get_quiz_stats.
+        .sort((a, b) => b.score - a.score || a.tool.name.length - b.tool.name.length || a.tool.name.localeCompare(b.tool.name));
+    if (base.length === 0) {
+        // Sans mots-cles : tous les noms, sans description (catalogue).
+        return { tools: ranked.map(entry => entry.tool.name) };
+    }
+    return {
+        tools: ranked.slice(0, limit).map(entry => ({
+            name: entry.tool.name,
+            summary: firstSentence(entry.tool.description, 140),
+            ...(isSensitive(entry.tool.name) ? { sensitive: true } : {}),
+        })),
+    };
+}
+export const SERVER_INSTRUCTIONS = "Pilote un Lab ConnectXLab. Parametre `lab` : id numerique ou url du Lab, donnes par list_labs. Reponses compactes : limit 20 par defaut, `fields` (lectures) pour ne garder que certains champs, `next_offset` pour la page suivante. Avant une action sensible (suppression, bannissement, envoi), demande l'accord explicite de l'utilisateur.";
+export const COMPACT_INSTRUCTIONS = " Mode compact : trouve l'action avec search_tools, lis ses parametres avec describe_tool, puis lance-la avec execute.";
+/**
+ * Les 3 tools du mode compact, construits sur le catalogue complet. En mode
+ * complet, seul describe_tool est ajoute (doc detaillee a la demande).
+ */
+export function compactTools(catalog) {
+    const byName = new Map(catalog.map(tool => [tool.name, tool]));
+    const text = (value, isError = false) => ({
+        ...(isError ? { isError: true } : {}),
+        content: [{ type: 'text', text: typeof value === 'string' ? value : JSON.stringify(value) }],
+    });
+    const search = {
+        name: 'search_tools',
+        description: `Cherche parmi les ${catalog.length} actions ConnectXLab (membres, posts, cours, evenements, boutique, newsletter, podcast, tunnels, quiz…). Sans query : liste de tous les noms.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Mots-cles, ex. "bannir membre" ou "newsletter envoyer"' },
+                limit: { type: 'number', minimum: 1, maximum: 30, default: 8 },
+            },
+            additionalProperties: false,
+        },
+        async handler(args) {
+            const limit = typeof args.limit === 'number' ? Math.min(30, Math.max(1, args.limit)) : 8;
+            return text(searchTools(catalog, typeof args.query === 'string' ? args.query : '', limit));
+        },
+    };
+    const describe = {
+        name: 'describe_tool',
+        description: "Description complete et parametres d'une action, avant de l'appeler avec execute.",
+        inputSchema: {
+            type: 'object',
+            properties: { name: { type: 'string', description: 'Nom exact, ex. list_members' } },
+            required: ['name'],
+            additionalProperties: false,
+        },
+        async handler(args) {
+            const tool = byName.get(String(args.name ?? ''));
+            if (!tool)
+                return text(`Action inconnue : ${String(args.name)}. Utilise search_tools.`, true);
+            return text({
+                name: tool.name,
+                description: tool.description,
+                ...(isSensitive(tool.name) ? { sensitive: "oui : accord explicite de l'utilisateur, puis execute avec confirm: true" } : {}),
+                ...(isReadTool(tool.name) ? { fields: 'accepte (via execute)' } : {}),
+                input_schema: tool.inputSchema,
+            });
+        },
+    };
+    const execute = {
+        name: 'execute',
+        description: "Lance une action ConnectXLab par son nom avec ses arguments. Actions sensibles : confirm: true, seulement apres accord de l'utilisateur.",
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: "Nom exact de l'action" },
+                arguments: { type: 'object', description: "Arguments de l'action (voir describe_tool)" },
+                fields: { type: 'array', items: { type: 'string' }, description: 'Champs a garder dans la reponse' },
+                confirm: { type: 'boolean', description: 'true pour une action sensible approuvee' },
+            },
+            required: ['name'],
+            additionalProperties: false,
+        },
+        async handler(args) {
+            const name = String(args.name ?? '');
+            const tool = byName.get(name);
+            if (!tool)
+                return text(`Action inconnue : ${name}. Utilise search_tools.`, true);
+            if (isSensitive(name) && args.confirm !== true) {
+                return text(`${name} est une action sensible. Decris-la a l'utilisateur, obtiens son accord explicite, puis relance execute avec confirm: true.`, true);
+            }
+            const toolArgs = isObject(args.arguments) ? { ...args.arguments } : {};
+            if (Array.isArray(args.fields))
+                toolArgs.fields = args.fields;
+            return runTool(tool, toolArgs);
+        },
+    };
+    return [search, describe, execute];
+}

package/dist/config.js

@@ -15,4 +15,7 @@ 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),
+    // compact (defaut) : 3 tools search_tools / describe_tool / execute ;
+    // full : les ~190 tools exposes directement (descriptions courtes).
+    mode: process.env.XLAB_MCP_MODE === 'full' ? 'full' : 'compact',
 };

package/dist/index.js

@@ -15,6 +15,8 @@
 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 { config } from './config.js';
+import { COMPACT_INSTRUCTIONS, SERVER_INSTRUCTIONS, compactTools, lightSchema, runTool, shortDescription } from './compact.js';
 import { listLabsTool } from './tools/listLabs.js';
 import { listMembersTool } from './tools/listMembers.js';
 import { listPostsTool } from './tools/listPosts.js';
@@ -199,6 +201,14 @@ import { rejectAssistantActionTool } from './tools/rejectAssistantAction.js';
 import { correctAssistantActionTool } from './tools/correctAssistantAction.js';
 import { requestAssistantPostDraftTool } from './tools/requestAssistantPostDraft.js';
 import { getAssistantSummaryTool } from './tools/getAssistantSummary.js';
+import { listPartnerAgentsTool } from './tools/listPartnerAgents.js';
+import { getPartnerAgentTool } from './tools/getPartnerAgent.js';
+import { createPartnerAgentTool } from './tools/createPartnerAgent.js';
+import { updatePartnerAgentTool } from './tools/updatePartnerAgent.js';
+import { setPartnerAgentPublishedTool } from './tools/setPartnerAgentPublished.js';
+import { deletePartnerAgentTool } from './tools/deletePartnerAgent.js';
+import { checkPartnerAgentLinksTool } from './tools/checkPartnerAgentLinks.js';
+import { getPartnerAgentStatsTool } from './tools/getPartnerAgentStats.js';
 const tools = [
     listLabsTool,
     listMembersTool,
@@ -397,27 +407,45 @@ const tools = [
     correctAssistantActionTool,
     requestAssistantPostDraftTool,
     getAssistantSummaryTool,
+    listPartnerAgentsTool,
+    getPartnerAgentTool,
+    createPartnerAgentTool,
+    updatePartnerAgentTool,
+    setPartnerAgentPublishedTool,
+    deletePartnerAgentTool,
+    checkPartnerAgentLinksTool,
+    getPartnerAgentStatsTool,
 ];
-const server = new Server({ name: 'connectxlab', version: '0.1.0' }, { capabilities: { tools: {} } });
+const catalog = tools;
+const [searchTool, describeTool, executeTool] = compactTools(catalog);
+const compact = config.mode === 'compact';
+const server = new Server({ name: 'connectxlab', version: '0.4.0' }, {
+    capabilities: { tools: {} },
+    instructions: SERVER_INSTRUCTIONS + (compact ? COMPACT_INSTRUCTIONS : ''),
+});
+// Mode compact : 3 tools. Mode complet : tous les tools (descriptions courtes) + describe_tool.
+const exposed = compact ? [searchTool, describeTool, executeTool] : [...catalog, describeTool];
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: tools.map(t => ({
-        name: t.name,
-        description: t.description,
-        inputSchema: t.inputSchema,
-    })),
+    tools: exposed.map(t => compact || t === describeTool
+        ? { name: t.name, description: t.description, inputSchema: t.inputSchema }
+        : { name: t.name, description: shortDescription(t), inputSchema: lightSchema(t) }),
 }));
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
-    const tool = tools.find(t => t.name === name);
+    const tool = exposed.find(t => t.name === name);
     if (!tool) {
         return {
             isError: true,
             content: [{ type: 'text', text: `Tool inconnu : ${name}` }],
         };
     }
-    return await tool.handler(args ?? {});
+    // Les tools du mode compact gerent eux-memes l'appel ; les autres passent par runTool.
+    if (tool === searchTool || tool === describeTool || tool === executeTool) {
+        return await tool.handler(args ?? {});
+    }
+    return await runTool(tool, 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(', ')}`);
+console.error(`[connectxlab-mcp] ready — mode ${config.mode}, ${catalog.length} actions, ${exposed.length} tools exposes`);

package/dist/tools/checkPartnerAgentLinks.js

@@ -0,0 +1,40 @@
+/**
+ * Tool `check_partner_agent_links` — verifie que des liens repondent.
+ * Scope : partner_agents.read. Super admin, Lab officiel uniquement.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const checkPartnerAgentLinksTool = {
+    name: 'check_partner_agent_links',
+    description: "Verifie que le lien d'affiliation et/ou le site de l'editeur repondent avant de les enregistrer. Simple avertissement : certains sites bloquent les verifications.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string', description: 'group_url ou id du Lab officiel XLab' },
+            affiliate: { type: 'string', description: "Lien d'affiliation (https://)" },
+            landing: { type: 'string', description: "Site de l'editeur (https://)" },
+        },
+        required: ['lab'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        affiliate: z.string().max(2000).optional(),
+        landing: z.string().max(2000).optional(),
+    }),
+    async handler(args) {
+        const { lab, affiliate, landing } = this.zodSchema.parse(args);
+        const urls = {};
+        if (affiliate)
+            urls.affiliate = affiliate;
+        if (landing)
+            urls.landing = landing;
+        try {
+            const { data } = await http.post(`/mcp/labs/${encodeURIComponent(lab)}/partner-agents/check-links`, { urls });
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/createPartnerAgent.js

@@ -0,0 +1,45 @@
+/**
+ * Tool `create_partner_agent` — cree un agent partenaire et sa page de vente.
+ * Scope : partner_agents.write. Super admin, Lab officiel uniquement.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+import { partnerAgentProperties, partnerAgentZod } from './partnerAgentFields.js';
+export const createPartnerAgentTool = {
+    name: 'create_partner_agent',
+    description: "Cree un agent partenaire dans le Lab officiel XLab : carte marketplace + page de vente dont les boutons menent au lien d'affiliation (suivi des vues et clics). Jamais propose en tunnel de vente, sans abonnement XLab. Publie par defaut (published=false pour le garder masque). Action visible publiquement : la faire confirmer.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string', description: 'group_url ou id du Lab officiel XLab' },
+            ...partnerAgentProperties,
+            published: { type: 'boolean', description: 'Visible sur la marketplace (defaut true)' },
+        },
+        required: ['lab', 'title', 'short_description', 'call_to_action_text', 'shop_image', 'affiliate_url'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        title: partnerAgentZod.title,
+        short_description: partnerAgentZod.short_description,
+        description: partnerAgentZod.description.optional(),
+        call_to_action_text: partnerAgentZod.call_to_action_text,
+        shop_image: partnerAgentZod.shop_image,
+        icon: partnerAgentZod.icon.optional(),
+        affiliate_url: partnerAgentZod.affiliate_url,
+        pricing_label: partnerAgentZod.pricing_label.optional(),
+        landing_template: partnerAgentZod.landing_template.optional(),
+        landing_external_url: partnerAgentZod.landing_external_url.optional(),
+        published: z.boolean().optional(),
+    }),
+    async handler(args) {
+        const { lab, ...body } = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.post(`/mcp/labs/${encodeURIComponent(lab)}/partner-agents`, 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/deletePartnerAgent.js

@@ -0,0 +1,33 @@
+/**
+ * Tool `delete_partner_agent` — supprime un agent partenaire et ses statistiques.
+ * Scope : partner_agents.write. Super admin, Lab officiel uniquement.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const deletePartnerAgentTool = {
+    name: 'delete_partner_agent',
+    description: "Supprime definitivement un agent partenaire (carte, page de vente, vues et clics). Irreversible : la faire confirmer. Pour le retirer temporairement : set_partner_agent_published false.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string', description: 'group_url ou id du Lab officiel XLab' },
+            agent_id: { type: 'number', description: 'id de l agent partenaire (list_partner_agents)' },
+        },
+        required: ['lab', 'agent_id'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        agent_id: z.number().int().min(1),
+    }),
+    async handler(args) {
+        const p = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.delete(`/mcp/labs/${encodeURIComponent(p.lab)}/partner-agents/${p.agent_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/getPartnerAgent.js

@@ -0,0 +1,33 @@
+/**
+ * Tool `get_partner_agent` — detail d'un agent partenaire (page de vente complete).
+ * Scope : partner_agents.read. Super admin, Lab officiel uniquement.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const getPartnerAgentTool = {
+    name: 'get_partner_agent',
+    description: "Detail d'un agent partenaire du Lab officiel : textes de la page de vente (description HTML comprise), image, lien d'affiliation, texte du bouton, prix affiche, publication et liens suivis (page de vente, affiliation).",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string', description: 'group_url ou id du Lab officiel XLab' },
+            agent_id: { type: 'number', description: 'id de l agent partenaire (list_partner_agents)' },
+        },
+        required: ['lab', 'agent_id'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        agent_id: z.number().int().min(1),
+    }),
+    async handler(args) {
+        const p = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.get(`/mcp/labs/${encodeURIComponent(p.lab)}/partner-agents/${p.agent_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/getPartnerAgentStats.js

@@ -0,0 +1,39 @@
+/**
+ * Tool `get_partner_agent_stats` — vues et clics d'un agent partenaire, jour par jour.
+ * Scope : partner_agents.read. Super admin, Lab officiel uniquement.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const getPartnerAgentStatsTool = {
+    name: 'get_partner_agent_stats',
+    description: "Vues de la page de vente et clics vers le lien d'affiliation d'un agent partenaire, jour par jour. period : today, 7d, 30d (defaut) ou custom avec from / to (YYYY-MM-DD, 366 jours max).",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string', description: 'group_url ou id du Lab officiel XLab' },
+            agent_id: { type: 'number', description: 'id de l agent partenaire (list_partner_agents)' },
+            period: { type: 'string', enum: ['today', '7d', '30d', 'custom'] },
+            from: { type: 'string', description: 'YYYY-MM-DD (period=custom)' },
+            to: { type: 'string', description: 'YYYY-MM-DD (period=custom)' },
+        },
+        required: ['lab', 'agent_id'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        agent_id: z.number().int().min(1),
+        period: z.enum(['today', '7d', '30d', 'custom']).optional(),
+        from: z.string().optional(),
+        to: z.string().optional(),
+    }),
+    async handler(args) {
+        const { lab, agent_id, ...params } = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.get(`/mcp/labs/${encodeURIComponent(lab)}/partner-agents/${agent_id}/stats`, { params });
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/listPartnerAgents.js

@@ -0,0 +1,31 @@
+/**
+ * Tool `list_partner_agents` — agents partenaires du Lab officiel XLab.
+ * Scope : partner_agents.read. Super admin, Lab officiel uniquement.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const listPartnerAgentsTool = {
+    name: 'list_partner_agents',
+    description: "Liste les agents partenaires (agents IA d'autres editeurs vendus via un lien d'affiliation) du Lab officiel XLab : titre, image, lien d'affiliation, prix affiche, publication, vues et clics sur 30 jours. Reserve au super admin, uniquement dans le Lab officiel.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string', description: 'group_url ou id du Lab officiel XLab' },
+        },
+        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)}/partner-agents`);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/partnerAgentFields.js

@@ -0,0 +1,29 @@
+/**
+ * Champs de la page de vente d'un agent partenaire, partages par
+ * create_partner_agent et update_partner_agent.
+ */
+import { z } from 'zod';
+export const partnerAgentProperties = {
+    title: { type: 'string', maxLength: 255, description: "Nom de l'agent" },
+    short_description: { type: 'string', maxLength: 500, description: 'Phrase courte de la carte marketplace' },
+    description: { type: 'string', description: 'Description de la page de vente (HTML simple accepte)' },
+    call_to_action_text: { type: 'string', maxLength: 120, description: 'Texte du bouton de la page de vente (ex. "Essayer l\'agent")' },
+    shop_image: { type: 'string', description: "Image de la carte : URL https ou image encodee (data:image/...;base64,...)" },
+    icon: { type: 'string', description: 'Logo (URL https ou data URI), optionnel' },
+    affiliate_url: { type: 'string', maxLength: 2000, description: "Lien d'affiliation chez l'editeur, en https:// (les boutons de la page y menent)" },
+    pricing_label: { type: 'string', maxLength: 80, description: 'Prix affiche, texte libre (ex. "Des 29 euros/mois")' },
+    landing_template: { type: 'string', enum: ['', 'external_url'], description: '"" = page de vente XLab ; "external_url" = la carte mene au site de l editeur' },
+    landing_external_url: { type: 'string', maxLength: 2000, description: "Site de l'editeur en https:// (obligatoire si landing_template = external_url)" },
+};
+export const partnerAgentZod = {
+    title: z.string().max(255),
+    short_description: z.string().max(500),
+    description: z.string(),
+    call_to_action_text: z.string().max(120),
+    shop_image: z.string(),
+    icon: z.string().nullable(),
+    affiliate_url: z.string().max(2000),
+    pricing_label: z.string().max(80).nullable(),
+    landing_template: z.enum(['', 'external_url']),
+    landing_external_url: z.string().max(2000).nullable(),
+};

package/dist/tools/setPartnerAgentPublished.js

@@ -0,0 +1,35 @@
+/**
+ * Tool `set_partner_agent_published` — publie ou masque un agent partenaire.
+ * Scope : partner_agents.write. Super admin, Lab officiel uniquement.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const setPartnerAgentPublishedTool = {
+    name: 'set_partner_agent_published',
+    description: "Publie (published=true) ou masque (false) un agent partenaire sur la marketplace. Action visible publiquement : la faire confirmer.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string', description: 'group_url ou id du Lab officiel XLab' },
+            agent_id: { type: 'number', description: 'id de l agent partenaire (list_partner_agents)' },
+            published: { type: 'boolean' },
+        },
+        required: ['lab', 'agent_id', 'published'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        agent_id: z.number().int().min(1),
+        published: z.boolean(),
+    }),
+    async handler(args) {
+        const p = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.put(`/mcp/labs/${encodeURIComponent(p.lab)}/partner-agents/${p.agent_id}/published`, { published: p.published });
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/updatePartnerAgent.js

@@ -0,0 +1,45 @@
+/**
+ * Tool `update_partner_agent` — modifie la page de vente d'un agent partenaire.
+ * Scope : partner_agents.write. Super admin, Lab officiel uniquement.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+import { partnerAgentProperties, partnerAgentZod } from './partnerAgentFields.js';
+export const updatePartnerAgentTool = {
+    name: 'update_partner_agent',
+    description: "Modifie un agent partenaire du Lab officiel : n'envoyer que les champs a changer, les autres gardent leur valeur (textes, image, lien d'affiliation, texte du bouton, prix affiche, type de page). Pour publier ou masquer : set_partner_agent_published.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string', description: 'group_url ou id du Lab officiel XLab' },
+            agent_id: { type: 'number', description: 'id de l agent partenaire (list_partner_agents)' },
+            ...partnerAgentProperties,
+        },
+        required: ['lab', 'agent_id'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        agent_id: z.number().int().min(1),
+        title: partnerAgentZod.title.optional(),
+        short_description: partnerAgentZod.short_description.optional(),
+        description: partnerAgentZod.description.optional(),
+        call_to_action_text: partnerAgentZod.call_to_action_text.optional(),
+        shop_image: partnerAgentZod.shop_image.optional(),
+        icon: partnerAgentZod.icon.optional(),
+        affiliate_url: partnerAgentZod.affiliate_url.optional(),
+        pricing_label: partnerAgentZod.pricing_label.optional(),
+        landing_template: partnerAgentZod.landing_template.optional(),
+        landing_external_url: partnerAgentZod.landing_external_url.optional(),
+    }),
+    async handler(args) {
+        const { lab, agent_id, ...body } = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.put(`/mcp/labs/${encodeURIComponent(lab)}/partner-agents/${agent_id}`, body);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@connect-xlab/mcp-server",
-  "version": "0.3.4",
+  "version": "0.4.0",
   "description": "Serveur MCP pour piloter ton Lab ConnectXLab depuis Claude Desktop / Cursor / n'importe quel client MCP.",
   "type": "module",
   "main": "dist/index.js",