@connect-xlab/mcp-server 0.1.0 → 0.1.2

package/dist/index.js

@@ -83,6 +83,14 @@ import { createPodcastEpisodeTool } from './tools/createPodcastEpisode.js';
 import { updatePodcastEpisodeTool } from './tools/updatePodcastEpisode.js';
 import { publishPodcastEpisodeTool } from './tools/publishPodcastEpisode.js';
 import { unpublishPodcastEpisodeTool } from './tools/unpublishPodcastEpisode.js';
+import { getStripeConnectStatusTool } from './tools/getStripeConnectStatus.js';
+import { getLinkInBioTool } from './tools/getLinkInBio.js';
+import { updateLinkInBioTool } from './tools/updateLinkInBio.js';
+import { toggleLinkInBioPublishTool } from './tools/toggleLinkInBioPublish.js';
+import { createLinkInBioBlockTool } from './tools/createLinkInBioBlock.js';
+import { updateLinkInBioBlockTool } from './tools/updateLinkInBioBlock.js';
+import { deleteLinkInBioBlockTool } from './tools/deleteLinkInBioBlock.js';
+import { reorderLinkInBioBlocksTool } from './tools/reorderLinkInBioBlocks.js';
 const tools = [
     listLabsTool,
     listMembersTool,
@@ -152,6 +160,16 @@ const tools = [
     updatePodcastEpisodeTool,
     publishPodcastEpisodeTool,
     unpublishPodcastEpisodeTool,
+    // Stripe Connect
+    getStripeConnectStatusTool,
+    // Link in Bio
+    getLinkInBioTool,
+    updateLinkInBioTool,
+    toggleLinkInBioPublishTool,
+    createLinkInBioBlockTool,
+    updateLinkInBioBlockTool,
+    deleteLinkInBioBlockTool,
+    reorderLinkInBioBlocksTool,
 ];
 const server = new Server({ name: 'connectxlab', version: '0.1.0' }, { capabilities: { tools: {} } });
 server.setRequestHandler(ListToolsRequestSchema, async () => ({

package/dist/tools/createLinkInBioBlock.js

@@ -0,0 +1,55 @@
+/**
+ * Tool `create_link_in_bio_block` — ajoute un bloc a la page :
+ *  - kind=external  : lien URL libre (title + action_url obligatoires)
+ *  - kind=product   : reference une offre du Lab (sellable_type + sellable_id)
+ *  - kind=lab       : reference un autre Lab (sellable_type=lab + sellable_id)
+ *
+ * Position ajoutee automatiquement en fin de liste.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+const SELLABLE_TYPES = ['agent_ai', 'group_shop', 'newsletter', 'podcast_show', 'lab_channel'];
+export const createLinkInBioBlockTool = {
+    name: 'create_link_in_bio_block',
+    description: "Ajoute un bloc a la page Link in Bio. Trois types :\n" +
+        "- kind=external : lien URL libre (title + action_url requis)\n" +
+        "- kind=product : reference une offre du Lab (sellable_type + sellable_id requis, sellable_type dans agent_ai/group_shop/newsletter/podcast_show/lab_channel)\n" +
+        "- kind=lab : reference un autre Lab de l'owner (sellable_id requis)\n" +
+        "Champs optionnels : subtitle, image_url. Position en fin de liste (utiliser reorder pour changer).",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            kind: { type: 'string', enum: ['external', 'product', 'lab'] },
+            title: { type: 'string', maxLength: 60 },
+            subtitle: { type: 'string', maxLength: 120 },
+            action_url: { type: 'string' },
+            image_url: { type: 'string' },
+            sellable_type: { type: 'string', enum: [...SELLABLE_TYPES] },
+            sellable_id: { type: 'number', minimum: 1 },
+        },
+        required: ['lab', 'kind'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        kind: z.enum(['external', 'product', 'lab']),
+        title: z.string().max(60).optional(),
+        subtitle: z.string().max(120).optional(),
+        action_url: z.string().optional(),
+        image_url: z.string().optional(),
+        sellable_type: z.enum(SELLABLE_TYPES).optional(),
+        sellable_id: z.number().int().positive().optional(),
+    }),
+    async handler(args) {
+        const parsed = this.zodSchema.parse(args);
+        const { lab, ...body } = parsed;
+        try {
+            const { data } = await http.post(`/mcp/labs/${encodeURIComponent(lab)}/link-in-bio/blocks`, 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/deleteLinkInBioBlock.js

@@ -0,0 +1,31 @@
+/**
+ * Tool `delete_link_in_bio_block` — supprime definitivement un bloc de la
+ * page. Pour masquer sans supprimer, utiliser plutot update_link_in_bio_block
+ * avec is_active=false.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const deleteLinkInBioBlockTool = {
+    name: 'delete_link_in_bio_block',
+    description: "Supprime definitivement un bloc de la page Link in Bio. Pour un masquage temporaire, prefere update_link_in_bio_block avec is_active=false.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            block_id: { type: 'number', minimum: 1 },
+        },
+        required: ['lab', 'block_id'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({ lab: z.string(), block_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)}/link-in-bio/blocks/${parsed.block_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/getLinkInBio.js

@@ -0,0 +1,29 @@
+/**
+ * Tool `get_link_in_bio` — recupere la page Link in Bio du Lab (settings +
+ * blocs). Renvoie null dans `page` si aucune page n'a encore ete creee.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const getLinkInBioTool = {
+    name: 'get_link_in_bio',
+    description: "Recupere la page Link in Bio d'un Lab : slug, published, display_name, bio, theme, layout (avatar/banner/portrait), desktop_layout (split/centered), avatar/banner/portrait URLs, socials, et la liste ordonnee des blocs (kind = external/product/lab).",
+    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)}/link-in-bio`);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/getStripeConnectStatus.js

@@ -0,0 +1,32 @@
+/**
+ * Tool `get_stripe_connect_status` — introspecte le compte Stripe Connect de
+ * l'owner du Lab. Utile pour verifier si l'owner peut vendre (charges_enabled)
+ * ou s'il doit finir sa configuration.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const getStripeConnectStatusTool = {
+    name: 'get_stripe_connect_status',
+    description: "Etat du compte Stripe Connect de l'owner du Lab (encaissement des ventes). Renvoie can_sell (bool), charges_enabled, has_account, requirements_due[]. Passer refresh=true force un rafraichissement depuis Stripe (utile juste apres onboarding). Le super admin plateforme retourne is_platform_owner=true (encaissement direct, pas de Connect).",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string', description: 'Id ou url du Lab' },
+            refresh: { type: 'boolean', description: 'Force un round-trip Stripe pour synchroniser (defaut false)' },
+        },
+        required: ['lab'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({ lab: z.string(), refresh: z.boolean().optional() }),
+    async handler(args) {
+        const parsed = this.zodSchema.parse(args);
+        try {
+            const qs = parsed.refresh ? '?refresh=1' : '';
+            const { data } = await http.get(`/mcp/labs/${encodeURIComponent(parsed.lab)}/payments/stripe-status${qs}`);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/reorderLinkInBioBlocks.js

@@ -0,0 +1,37 @@
+/**
+ * Tool `reorder_link_in_bio_blocks` — reordonne les blocs. Passer la liste
+ * complete des block_ids dans l'ordre voulu (top → bottom).
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const reorderLinkInBioBlocksTool = {
+    name: 'reorder_link_in_bio_blocks',
+    description: "Reordonne les blocs de la page Link in Bio. Passer la liste complete des block_ids dans l'ordre souhaite (premier = top de la page). Le back rejette si la liste ne matche pas exactement les blocs existants.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            block_ids: {
+                type: 'array',
+                items: { type: 'number', minimum: 1 },
+                minItems: 1,
+            },
+        },
+        required: ['lab', 'block_ids'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        block_ids: z.array(z.number().int().positive()).min(1),
+    }),
+    async handler(args) {
+        const parsed = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.put(`/mcp/labs/${encodeURIComponent(parsed.lab)}/link-in-bio/blocks/reorder`, { block_ids: parsed.block_ids });
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/toggleLinkInBioPublish.js

@@ -0,0 +1,29 @@
+/**
+ * Tool `toggle_link_in_bio_publish` — publie / depublie la page. Une page
+ * depubliee reste editable mais n'est plus accessible via son slug public.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const toggleLinkInBioPublishTool = {
+    name: 'toggle_link_in_bio_publish',
+    description: "Publie ou depublie la page Link in Bio. Le back bascule automatiquement l'etat (pas besoin de passer publish=true/false). Retourne l'etat resultant.",
+    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.post(`/mcp/labs/${encodeURIComponent(parsed.lab)}/link-in-bio/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/updateLinkInBio.js

@@ -0,0 +1,61 @@
+/**
+ * Tool `update_link_in_bio` — upsert des meta de la page (slug, display_name,
+ * bio, theme, layout, socials, URLs de photos). Si la page n'existe pas
+ * encore, elle est creee. Tous les champs sont optionnels : on ne modifie
+ * que ce qui est fourni.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+const SOCIAL_KEYS = ['instagram', 'tiktok', 'youtube', 'x', 'linkedin', 'facebook', 'whatsapp', 'telegram'];
+export const updateLinkInBioTool = {
+    name: 'update_link_in_bio',
+    description: "Upsert de la page Link in Bio (meta). Cree la page si absente. Champs optionnels : slug, display_name, bio, theme (violet/blue/black/pastel), accent_color (#RRGGBB), photo_layout (avatar/banner/portrait), desktop_layout (split/centered), avatar_url, banner_url, portrait_url, socials{instagram, tiktok, youtube, x, linkedin, facebook, whatsapp, telegram}. Attention : changer le slug a un cooldown de 30 jours.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            slug: { type: 'string', maxLength: 40 },
+            display_name: { type: 'string', maxLength: 60 },
+            bio: { type: 'string', maxLength: 300 },
+            theme: { type: 'string', enum: ['violet', 'blue', 'black', 'pastel'] },
+            accent_color: { type: 'string', pattern: '^#[0-9A-Fa-f]{6}$' },
+            photo_layout: { type: 'string', enum: ['avatar', 'banner', 'portrait'] },
+            desktop_layout: { type: 'string', enum: ['split', 'centered'] },
+            avatar_url: { type: 'string' },
+            banner_url: { type: 'string' },
+            portrait_url: { type: 'string' },
+            socials: {
+                type: 'object',
+                properties: Object.fromEntries(SOCIAL_KEYS.map((k) => [k, { type: 'string' }])),
+                additionalProperties: false,
+            },
+        },
+        required: ['lab'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        slug: z.string().max(40).optional(),
+        display_name: z.string().max(60).optional(),
+        bio: z.string().max(300).optional(),
+        theme: z.enum(['violet', 'blue', 'black', 'pastel']).optional(),
+        accent_color: z.string().regex(/^#[0-9A-Fa-f]{6}$/).optional(),
+        photo_layout: z.enum(['avatar', 'banner', 'portrait']).optional(),
+        desktop_layout: z.enum(['split', 'centered']).optional(),
+        avatar_url: z.string().optional(),
+        banner_url: z.string().optional(),
+        portrait_url: z.string().optional(),
+        socials: z.record(z.string()).optional(),
+    }),
+    async handler(args) {
+        const parsed = this.zodSchema.parse(args);
+        const { lab, ...body } = parsed;
+        try {
+            const { data } = await http.post(`/mcp/labs/${encodeURIComponent(lab)}/link-in-bio`, 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/updateLinkInBioBlock.js

@@ -0,0 +1,44 @@
+/**
+ * Tool `update_link_in_bio_block` — modifie un bloc existant. Tous les champs
+ * sont optionnels : seuls ceux fournis sont modifies.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const updateLinkInBioBlockTool = {
+    name: 'update_link_in_bio_block',
+    description: "Modifie un bloc existant (identifie par block_id, entier renvoye par get_link_in_bio ou create_link_in_bio_block). Champs modifiables : title, subtitle, action_url, image_url, is_active (afficher/masquer sans supprimer).",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string' },
+            block_id: { type: 'number', minimum: 1 },
+            title: { type: 'string', maxLength: 60 },
+            subtitle: { type: 'string', maxLength: 120 },
+            action_url: { type: 'string' },
+            image_url: { type: 'string' },
+            is_active: { type: 'boolean' },
+        },
+        required: ['lab', 'block_id'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        block_id: z.number().int().positive(),
+        title: z.string().max(60).optional(),
+        subtitle: z.string().max(120).optional(),
+        action_url: z.string().optional(),
+        image_url: z.string().optional(),
+        is_active: z.boolean().optional(),
+    }),
+    async handler(args) {
+        const parsed = this.zodSchema.parse(args);
+        const { lab, block_id, ...body } = parsed;
+        try {
+            const { data } = await http.put(`/mcp/labs/${encodeURIComponent(lab)}/link-in-bio/blocks/${block_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,19 +1,38 @@
 {
   "name": "@connect-xlab/mcp-server",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Serveur MCP pour piloter ton Lab ConnectXLab depuis Claude Desktop / Cursor / n'importe quel client MCP.",
   "type": "module",
   "main": "dist/index.js",
-  "bin": { "connectxlab-mcp": "dist/index.js" },
-  "files": ["dist"],
+  "bin": {
+    "connectxlab-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Elmzelji/Xlab-Mcp.git"
+  },
+  "homepage": "https://github.com/Elmzelji/Xlab-Mcp#readme",
+  "bugs": {
+    "url": "https://github.com/Elmzelji/Xlab-Mcp/issues"
+  },
   "scripts": {
     "build": "tsc",
     "dev": "tsx watch src/index.ts",
     "start": "node dist/index.js",
     "prepublishOnly": "npm run build"
   },
-  "engines": { "node": ">=20" },
-  "keywords": ["mcp", "model-context-protocol", "connectxlab", "claude"],
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "connectxlab",
+    "claude"
+  ],
   "author": "ConnectXLab",
   "license": "MIT",
   "dependencies": {