@charisol/plexo-mcp 1.0.0

package/.github/workflows/publish-npm.yml

@@ -0,0 +1,52 @@
+name: Publish to npm
+
+on:
+  push:
+    branches:
+      - main
+
+  workflow_dispatch:   # allows manual run from GitHub Actions UI
+
+permissions:
+  contents: write      # Required to push the version bump commit back to repository
+  id-token: write      # Required for npm OIDC trusted publishing
+
+jobs:
+  build-and-publish:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout source
+        uses: actions/checkout@v4
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: Upgrade npm CLI to latest
+        run: npm install -g npm@latest
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Build MCP server package
+        run: npm run build
+
+      - name: Auto-bump patch version
+        run: |
+          npm version patch --no-git-tag-version
+
+      - name: Publish to npm
+        run: npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+
+      - name: Commit and push version bump
+        run: |
+          git config --global user.name "github-actions[bot]"
+          git config --global user.email "github-actions[bot]@users.noreply.github.com"
+          git add package.json
+          git commit -m "chore: bump patch version [skip ci]"
+          git push

package/README.md

@@ -0,0 +1,69 @@
+# @charisol/plexo-mcp - Plexo Model Context Protocol (MCP) Server
+
+Official Model Context Protocol (MCP) server for **Plexo** - the AI-powered visual landing page & email template platform.
+
+Connect **Claude Desktop**, **Claude Web**, **ChatGPT**, **Cursor**, **Windsurf**, and **Gemini** directly to your Plexo account.
+
+---
+
+## Capabilities & Tools
+
+- 🚀 **`publish_landing_page`**: Creates, compiles, and publishes a landing page (JSON schema + HTML) to a subdomain or custom domain in 1 step.
+- 📄 **`list_landing_pages`**: Retrieves saved landing page designs and active domain URLs.
+- ✉️ **`list_email_templates`**: Retrieves saved email templates.
+- 📊 **`get_analytics`**: Fetches total page views, unique visitor counts, and daily timelines.
+- 👤 **`get_user_profile`**: Checks subscription plan, AI credit balance, and domain usage limits.
+- 🗑️ **`delete_published_domain`**: Unlinks or deletes published domains.
+
+---
+
+## Quick Start & Installation
+
+### Option 1: Claude Desktop
+
+Add to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "plexo": {
+      "command": "npx",
+      "args": ["-y", "@charisol/plexo-mcp"],
+      "env": {
+        "PLEXO_API_KEY": "plexo_sk_your_key_here",
+        "PLEXO_BASE_URL": "https://plexobuilder.com"
+      }
+    }
+  }
+}
+```
+
+### Option 2: Cursor / Windsurf IDE
+
+Add to `.cursor/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "plexo": {
+      "command": "npx",
+      "args": ["-y", "@charisol/plexo-mcp"],
+      "env": {
+        "PLEXO_API_KEY": "plexo_sk_your_key_here"
+      }
+    }
+  }
+}
+```
+
+### Option 3: Browser Authentication Flow
+If `PLEXO_API_KEY` is omitted, the tool cleanly prompts:
+`Please log into your Plexo account to authenticate: https://plexobuilder.com/mcp/login`
+
+---
+
+## Example AI Prompts
+
+- *"Generate a modern tech SaaS landing page for an AI CRM called Acme and publish it using Plexo to subdomain acme-crm"*
+- *"Show me my page view analytics for the last 7 days"*
+- *"List all my email templates"*

package/dist/client/plexoClient.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlexoClient = void 0;
+const config_js_1 = require("../config.js");
+class PlexoClient {
+    baseUrl;
+    apiKey;
+    constructor(apiKey, baseUrl) {
+        const config = (0, config_js_1.getConfig)();
+        this.baseUrl = (baseUrl || config.baseUrl).replace(/\/$/, "");
+        this.apiKey = apiKey || config.apiKey;
+    }
+    getHeaders() {
+        const headers = {
+            "Content-Type": "application/json",
+            "User-Agent": "Plexo-MCP-Server/1.0",
+        };
+        if (this.apiKey) {
+            headers["Authorization"] = `Bearer ${this.apiKey}`;
+            headers["x-api-key"] = this.apiKey;
+        }
+        return headers;
+    }
+    checkAuth() {
+        if (!this.apiKey) {
+            const loginUrl = `${this.baseUrl}/mcp/login`;
+            throw new Error(`Authentication Required: PLEXO_API_KEY environment variable is not configured.\n` +
+                `Please log into your Plexo account to authenticate: ${loginUrl}\n` +
+                `Once logged in, set PLEXO_API_KEY in your MCP configuration or client headers.`);
+        }
+    }
+    async publishLandingPage(params) {
+        this.checkAuth();
+        const res = await fetch(`${this.baseUrl}/api/v1/publish`, {
+            method: "POST",
+            headers: this.getHeaders(),
+            body: JSON.stringify(params),
+        });
+        const data = (await res.json());
+        if (!res.ok) {
+            throw new Error(data?.error || `Publish failed with status ${res.status}`);
+        }
+        return data;
+    }
+    async getUserProfile() {
+        this.checkAuth();
+        const res = await fetch(`${this.baseUrl}/api/v1/profile`, {
+            method: "GET",
+            headers: this.getHeaders(),
+        });
+        const data = (await res.json());
+        if (!res.ok) {
+            throw new Error(data?.error || `Failed to fetch profile (Status ${res.status})`);
+        }
+        return data;
+    }
+    async getAnalytics(templateId) {
+        this.checkAuth();
+        const url = new URL(`${this.baseUrl}/api/v1/analytics`);
+        if (templateId) {
+            url.searchParams.set("templateId", templateId);
+        }
+        const res = await fetch(url.toString(), {
+            method: "GET",
+            headers: this.getHeaders(),
+        });
+        const data = (await res.json());
+        if (!res.ok) {
+            throw new Error(data?.error || `Failed to fetch analytics (Status ${res.status})`);
+        }
+        return data;
+    }
+    async listTemplates() {
+        this.checkAuth();
+        const res = await fetch(`${this.baseUrl}/api/templates`, {
+            method: "GET",
+            headers: this.getHeaders(),
+        });
+        const data = (await res.json());
+        if (!res.ok) {
+            throw new Error(data?.error || `Failed to list templates (Status ${res.status})`);
+        }
+        return data;
+    }
+    async listDomains(templateId) {
+        this.checkAuth();
+        const url = new URL(`${this.baseUrl}/api/v1/domains`);
+        if (templateId) {
+            url.searchParams.set("templateId", templateId);
+        }
+        const res = await fetch(url.toString(), {
+            method: "GET",
+            headers: this.getHeaders(),
+        });
+        const data = (await res.json());
+        if (!res.ok) {
+            throw new Error(data?.error || `Failed to fetch domains (Status ${res.status})`);
+        }
+        return data;
+    }
+    async deleteDomain(params) {
+        this.checkAuth();
+        const url = new URL(`${this.baseUrl}/api/v1/domains`);
+        if (params.domainId)
+            url.searchParams.set("id", params.domainId);
+        if (params.domain)
+            url.searchParams.set("domain", params.domain);
+        const res = await fetch(url.toString(), {
+            method: "DELETE",
+            headers: this.getHeaders(),
+        });
+        const data = (await res.json());
+        if (!res.ok) {
+            throw new Error(data?.error || `Failed to delete domain (Status ${res.status})`);
+        }
+        return data;
+    }
+}
+exports.PlexoClient = PlexoClient;

package/dist/config.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfig = getConfig;
+function getConfig() {
+    const baseUrl = process.env.PLEXO_BASE_URL || "https://plexobuilder.com";
+    const apiKey = process.env.PLEXO_API_KEY;
+    return {
+        baseUrl,
+        apiKey,
+    };
+}

package/dist/index.js

@@ -0,0 +1,210 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const plexoClient_js_1 = require("./client/plexoClient.js");
+const server = new index_js_1.Server({
+    name: "plexo-mcp",
+    version: "1.0.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// Define tool schemas
+server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: "publish_landing_page",
+                description: "Creates, compiles, and publishes a landing page to Plexo in one atomic step. Returns the published live URL and editable visual builder URL.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        name: {
+                            type: "string",
+                            description: "Title or name of the landing page (e.g. 'Acme AI CRM')",
+                        },
+                        designJson: {
+                            type: "object",
+                            description: "Plexo layout schema containing body style and rows array",
+                        },
+                        compiledHtml: {
+                            type: "string",
+                            description: "Optional pre-compiled HTML string. If omitted, Plexo compiles designJson automatically.",
+                        },
+                        domain: {
+                            type: "string",
+                            description: "Subdomain slug (e.g. 'acme-crm') or custom domain (e.g. 'myacme.com')",
+                        },
+                        type: {
+                            type: "string",
+                            enum: ["SUBDOMAIN", "CUSTOM"],
+                            description: "Domain routing type (SUBDOMAIN or CUSTOM)",
+                        },
+                    },
+                    required: ["designJson"],
+                },
+            },
+            {
+                name: "list_landing_pages",
+                description: "Lists all saved landing page templates and published domain URLs in the user's Plexo account.",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            {
+                name: "list_email_templates",
+                description: "Lists all saved email templates in the user's Plexo account.",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            {
+                name: "get_analytics",
+                description: "Fetches visitor analytics, total page views, unique visitor counts, and timeline data.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        templateId: {
+                            type: "string",
+                            description: "Optional template ID to filter analytics for a specific page",
+                        },
+                    },
+                },
+            },
+            {
+                name: "get_user_profile",
+                description: "Retrieves user details, subscription plan (FREE, PRO, ULTRA), AI credit balance, and domain usage limits.",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            {
+                name: "delete_published_domain",
+                description: "Deletes or unlinks a published domain from a landing page.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        domain: {
+                            type: "string",
+                            description: "Domain name to delete (e.g. 'acme.plexobuilder.com' or 'myacme.com')",
+                        },
+                        domainId: {
+                            type: "string",
+                            description: "ID of the domain record to delete",
+                        },
+                    },
+                },
+            },
+        ],
+    };
+});
+// Implement tool handlers
+server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const client = new plexoClient_js_1.PlexoClient();
+    try {
+        switch (name) {
+            case "publish_landing_page": {
+                const result = await client.publishLandingPage(args);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "list_landing_pages": {
+                const data = await client.listTemplates();
+                const landingPages = (data.templates || []).filter((t) => t.kind === "LANDING_PAGE");
+                const domainsRes = await client.listDomains();
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                landingPages,
+                                publishedDomains: domainsRes.domains || [],
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "list_email_templates": {
+                const data = await client.listTemplates();
+                const emailTemplates = (data.templates || []).filter((t) => t.kind === "EMAIL");
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({ emailTemplates }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "get_analytics": {
+                const result = await client.getAnalytics(args?.templateId);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "get_user_profile": {
+                const result = await client.getUserProfile();
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "delete_published_domain": {
+                const result = await client.deleteDomain(args);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error executing tool ${name}: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+async function run() {
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    console.error("Plexo MCP Server running on stdio transport.");
+}
+run().catch((err) => {
+    console.error("Fatal error starting Plexo MCP server:", err);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@charisol/plexo-mcp",
+  "version": "1.0.0",
+  "description": "Model Context Protocol (MCP) Server for Plexo - Landing page generation, email templates, publishing, and analytics.",
+  "main": "dist/index.js",
+  "bin": {
+    "plexo-mcp": "dist/index.js"
+  },
+  "keywords": [
+    "plexo",
+    "mcp",
+    "model-context-protocol",
+    "claude",
+    "chatgpt",
+    "cursor",
+    "landing-page",
+    "email-builder"
+  ],
+  "license": "MIT",
+  "homepage": "https://plexo.charisol.io",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Challaris/plexo-mcp.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Challaris/plexo-mcp/issues"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "ts-node src/index.ts"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.1",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.3.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/client/plexoClient.ts

@@ -0,0 +1,148 @@
+import { getConfig } from "../config.js";
+
+export class PlexoClient {
+  private baseUrl: string;
+  private apiKey?: string;
+
+  constructor(apiKey?: string, baseUrl?: string) {
+    const config = getConfig();
+    this.baseUrl = (baseUrl || config.baseUrl).replace(/\/$/, "");
+    this.apiKey = apiKey || config.apiKey;
+  }
+
+  private getHeaders(): Record<string, string> {
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+      "User-Agent": "Plexo-MCP-Server/1.0",
+    };
+
+    if (this.apiKey) {
+      headers["Authorization"] = `Bearer ${this.apiKey}`;
+      headers["x-api-key"] = this.apiKey;
+    }
+
+    return headers;
+  }
+
+  private checkAuth(): void {
+    if (!this.apiKey) {
+      const loginUrl = `${this.baseUrl}/mcp/login`;
+      throw new Error(
+        `Authentication Required: PLEXO_API_KEY environment variable is not configured.\n` +
+        `Please log into your Plexo account to authenticate: ${loginUrl}\n` +
+        `Once logged in, set PLEXO_API_KEY in your MCP configuration or client headers.`
+      );
+    }
+  }
+
+  async publishLandingPage(params: {
+    name?: string;
+    designJson: Record<string, any>;
+    compiledHtml?: string;
+    domain?: string;
+    type?: "SUBDOMAIN" | "CUSTOM";
+  }): Promise<any> {
+    this.checkAuth();
+    const res = await fetch(`${this.baseUrl}/api/v1/publish`, {
+      method: "POST",
+      headers: this.getHeaders(),
+      body: JSON.stringify(params),
+    });
+
+    const data = (await res.json()) as any;
+    if (!res.ok) {
+      throw new Error(data?.error || `Publish failed with status ${res.status}`);
+    }
+
+    return data;
+  }
+
+  async getUserProfile(): Promise<any> {
+    this.checkAuth();
+    const res = await fetch(`${this.baseUrl}/api/v1/profile`, {
+      method: "GET",
+      headers: this.getHeaders(),
+    });
+
+    const data = (await res.json()) as any;
+    if (!res.ok) {
+      throw new Error(data?.error || `Failed to fetch profile (Status ${res.status})`);
+    }
+
+    return data;
+  }
+
+  async getAnalytics(templateId?: string): Promise<any> {
+    this.checkAuth();
+    const url = new URL(`${this.baseUrl}/api/v1/analytics`);
+    if (templateId) {
+      url.searchParams.set("templateId", templateId);
+    }
+
+    const res = await fetch(url.toString(), {
+      method: "GET",
+      headers: this.getHeaders(),
+    });
+
+    const data = (await res.json()) as any;
+    if (!res.ok) {
+      throw new Error(data?.error || `Failed to fetch analytics (Status ${res.status})`);
+    }
+
+    return data;
+  }
+
+  async listTemplates(): Promise<any> {
+    this.checkAuth();
+    const res = await fetch(`${this.baseUrl}/api/templates`, {
+      method: "GET",
+      headers: this.getHeaders(),
+    });
+
+    const data = (await res.json()) as any;
+    if (!res.ok) {
+      throw new Error(data?.error || `Failed to list templates (Status ${res.status})`);
+    }
+
+    return data;
+  }
+
+  async listDomains(templateId?: string): Promise<any> {
+    this.checkAuth();
+    const url = new URL(`${this.baseUrl}/api/v1/domains`);
+    if (templateId) {
+      url.searchParams.set("templateId", templateId);
+    }
+
+    const res = await fetch(url.toString(), {
+      method: "GET",
+      headers: this.getHeaders(),
+    });
+
+    const data = (await res.json()) as any;
+    if (!res.ok) {
+      throw new Error(data?.error || `Failed to fetch domains (Status ${res.status})`);
+    }
+
+    return data;
+  }
+
+  async deleteDomain(params: { domainId?: string; domain?: string }): Promise<any> {
+    this.checkAuth();
+    const url = new URL(`${this.baseUrl}/api/v1/domains`);
+    if (params.domainId) url.searchParams.set("id", params.domainId);
+    if (params.domain) url.searchParams.set("domain", params.domain);
+
+    const res = await fetch(url.toString(), {
+      method: "DELETE",
+      headers: this.getHeaders(),
+    });
+
+    const data = (await res.json()) as any;
+    if (!res.ok) {
+      throw new Error(data?.error || `Failed to delete domain (Status ${res.status})`);
+    }
+
+    return data;
+  }
+}

package/src/config.ts

@@ -0,0 +1,14 @@
+export interface PlexoConfig {
+  baseUrl: string;
+  apiKey?: string;
+}
+
+export function getConfig(): PlexoConfig {
+  const baseUrl = process.env.PLEXO_BASE_URL || "https://plexobuilder.com";
+  const apiKey = process.env.PLEXO_API_KEY;
+
+  return {
+    baseUrl,
+    apiKey,
+  };
+}

package/src/index.ts

@@ -0,0 +1,237 @@
+#!/usr/bin/env node
+
+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 { PlexoClient } from "./client/plexoClient.js";
+
+const server = new Server(
+  {
+    name: "plexo-mcp",
+    version: "1.0.0",
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+// Define tool schemas
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [
+      {
+        name: "publish_landing_page",
+        description:
+          "Creates, compiles, and publishes a landing page to Plexo in one atomic step. Returns the published live URL and editable visual builder URL.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name: {
+              type: "string",
+              description: "Title or name of the landing page (e.g. 'Acme AI CRM')",
+            },
+            designJson: {
+              type: "object",
+              description: "Plexo layout schema containing body style and rows array",
+            },
+            compiledHtml: {
+              type: "string",
+              description: "Optional pre-compiled HTML string. If omitted, Plexo compiles designJson automatically.",
+            },
+            domain: {
+              type: "string",
+              description: "Subdomain slug (e.g. 'acme-crm') or custom domain (e.g. 'myacme.com')",
+            },
+            type: {
+              type: "string",
+              enum: ["SUBDOMAIN", "CUSTOM"],
+              description: "Domain routing type (SUBDOMAIN or CUSTOM)",
+            },
+          },
+          required: ["designJson"],
+        },
+      },
+      {
+        name: "list_landing_pages",
+        description: "Lists all saved landing page templates and published domain URLs in the user's Plexo account.",
+        inputSchema: {
+          type: "object",
+          properties: {},
+        },
+      },
+      {
+        name: "list_email_templates",
+        description: "Lists all saved email templates in the user's Plexo account.",
+        inputSchema: {
+          type: "object",
+          properties: {},
+        },
+      },
+      {
+        name: "get_analytics",
+        description: "Fetches visitor analytics, total page views, unique visitor counts, and timeline data.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            templateId: {
+              type: "string",
+              description: "Optional template ID to filter analytics for a specific page",
+            },
+          },
+        },
+      },
+      {
+        name: "get_user_profile",
+        description: "Retrieves user details, subscription plan (FREE, PRO, ULTRA), AI credit balance, and domain usage limits.",
+        inputSchema: {
+          type: "object",
+          properties: {},
+        },
+      },
+      {
+        name: "delete_published_domain",
+        description: "Deletes or unlinks a published domain from a landing page.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            domain: {
+              type: "string",
+              description: "Domain name to delete (e.g. 'acme.plexobuilder.com' or 'myacme.com')",
+            },
+            domainId: {
+              type: "string",
+              description: "ID of the domain record to delete",
+            },
+          },
+        },
+      },
+    ],
+  };
+});
+
+// Implement tool handlers
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  const client = new PlexoClient();
+
+  try {
+    switch (name) {
+      case "publish_landing_page": {
+        const result = await client.publishLandingPage(args as any);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2),
+            },
+          ],
+        };
+      }
+
+      case "list_landing_pages": {
+        const data = await client.listTemplates();
+        const landingPages = (data.templates || []).filter(
+          (t: any) => t.kind === "LANDING_PAGE"
+        );
+        const domainsRes = await client.listDomains();
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  landingPages,
+                  publishedDomains: domainsRes.domains || [],
+                },
+                null,
+                2
+              ),
+            },
+          ],
+        };
+      }
+
+      case "list_email_templates": {
+        const data = await client.listTemplates();
+        const emailTemplates = (data.templates || []).filter(
+          (t: any) => t.kind === "EMAIL"
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({ emailTemplates }, null, 2),
+            },
+          ],
+        };
+      }
+
+      case "get_analytics": {
+        const result = await client.getAnalytics((args as any)?.templateId);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2),
+            },
+          ],
+        };
+      }
+
+      case "get_user_profile": {
+        const result = await client.getUserProfile();
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2),
+            },
+          ],
+        };
+      }
+
+      case "delete_published_domain": {
+        const result = await client.deleteDomain(args as any);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2),
+            },
+          ],
+        };
+      }
+
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error executing tool ${name}: ${
+            error instanceof Error ? error.message : String(error)
+          }`,
+        },
+      ],
+      isError: true,
+    };
+  }
+});
+
+async function run() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("Plexo MCP Server running on stdio transport.");
+}
+
+run().catch((err) => {
+  console.error("Fatal error starting Plexo MCP server:", err);
+  process.exit(1);
+});

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*"]
+}