@charisol/plexo-mcp 1.0.10 → 1.0.11

package/dist/wpMigrationTools.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WP_MIGRATION_TOOL_NAMES = exports.WP_MIGRATION_TOOL_DEFS = void 0;
+exports.handleWpMigrationToolCall = handleWpMigrationToolCall;
+// WordPress → Plexo migration — same tools, same descriptions as the live connector in
+// plexo-web (lib/mcp/wpMigrationTools.ts), executed through plexo-web's REST API.
+// get_wordpress_migration advances the migration one step per call, like the dashboard.
+exports.WP_MIGRATION_TOOL_DEFS = [
+    {
+        name: "preview_wordpress_migration",
+        description: `Checks a WordPress website and previews what moving it to Plexo would involve — WITHOUT changing anything. Finds WordPress even when it's installed in a subfolder or behind a splash/landing page, and returns page/post/media counts, the theme, and what will happen to each plugin (replaced by a Plexo feature, carried over as-is, needs attention, or not needed). Call this first and show the owner the plugin outcomes — especially anything marked NEEDS_ATTENTION (e.g. payment/donation plugins) — before calling start_wordpress_migration.`,
+        inputSchema: {
+            type: "object",
+            properties: {
+                url: { type: "string", description: "The site's public address, e.g. 'example.org' or 'https://example.org/blog'. Any page on the site works." },
+            },
+            required: ["url"],
+        },
+    },
+    {
+        name: "start_wordpress_migration",
+        description: `Starts moving a WordPress site to a NEW Plexo site (never overwrites an existing one). Copies every page exactly as it looks (theme, Elementor and other page-builder designs, fonts, animations), every blog post into Plexo Blog, the whole media library, and every SEO tag — keeping every web address identical so search rankings and links survive. Forms (Forminator, Contact Form 7, WPForms, Elementor) are reconnected to Plexo Forms. The WordPress site itself is not changed.
+
+Requires the owner's explicit confirmation that they own the site (ownershipConfirmed: true) — ask them, never assume. If their account hasn't accepted Plexo's Acceptable Use Policy yet, the call fails with requiresAupAcceptance; ask them to read /legal/acceptable-use and retry with acceptAcceptableUsePolicy: true only if they agree.
+
+Returns templateId + jobId. Then call get_wordpress_migration repeatedly (each call advances the migration) until phase is COMPLETED.`,
+        inputSchema: {
+            type: "object",
+            properties: {
+                url: { type: "string", description: "The site's public address (same as preview_wordpress_migration)." },
+                ownershipConfirmed: { type: "boolean", description: "true only if the owner confirmed they own the site or have permission to move it." },
+                acceptAcceptableUsePolicy: { type: "boolean", description: "true only if the owner agreed to Plexo's Acceptable Use Policy (needed once per account)." },
+            },
+            required: ["url", "ownershipConfirmed"],
+        },
+    },
+    {
+        name: "get_wordpress_migration",
+        description: `Advances a WordPress migration by one step and returns its progress — call it repeatedly until phase is COMPLETED (or PAUSED_ERROR, in which case calling again retries from where it stopped). When COMPLETED, returns the report: what was copied, SEO comparison, what happened to each plugin, and a cutover checklist. Items with status "blocked" (e.g. connecting payments for a donation form) must be done before the owner points their domain at Plexo; tell the owner about them plainly. Omit jobId to get the organization's most recent migration.`,
+        inputSchema: {
+            type: "object",
+            properties: {
+                templateId: { type: "string", description: "The Plexo site id returned by start_wordpress_migration." },
+                jobId: { type: "string", description: "The migration id returned by start_wordpress_migration." },
+            },
+        },
+    },
+    {
+        name: "connect_wordpress_migrator_plugin",
+        description: `Starts copying what WordPress keeps private (past form entries and applications, donation history, drafts, redirect rules, the team list) for a finished migration. Returns a download link for the read-only "Plexo Migrator" WordPress plugin and a connection code. Tell the owner: install and activate the plugin (Plugins → Add New → Upload Plugin), then paste the code in WordPress under Tools → Plexo Migrator. Then call import_wordpress_private_data.`,
+        inputSchema: { type: "object", properties: { templateId: { type: "string" }, jobId: { type: "string" } }, required: ["templateId", "jobId"] },
+    },
+    {
+        name: "import_wordpress_private_data",
+        description: `Checks the Plexo Migrator plugin connection and copies the next batch of private data. Call repeatedly until stage is "done". If it returns an error message, relay it to the owner (it says exactly what to do, e.g. "paste the code in Tools → Plexo Migrator"). When done, the result lists the team found on WordPress — offer to invite them.`,
+        inputSchema: { type: "object", properties: { templateId: { type: "string" }, jobId: { type: "string" } }, required: ["templateId", "jobId"] },
+    },
+    {
+        name: "get_domain_switch_plan",
+        description: `For a finished migration: reads the old domain's live DNS and returns exactly how to point it at Plexo — who hosts the DNS (and whether cancelling the WordPress hosting would delete it), the email provider, records to KEEP unchanged (email, verification), records to ADD for Plexo, step-by-step instructions and a zone file. Connect the domain first with publish_existing_landing_page (CUSTOM, both apex and www) so the certificate records are included. Always relay the warnings to the owner.`,
+        inputSchema: { type: "object", properties: { templateId: { type: "string" }, jobId: { type: "string" } }, required: ["templateId", "jobId"] },
+    },
+    {
+        name: "verify_domain_switch",
+        description: `Checks on the real domain that Plexo now serves every migrated URL, email records are intact, DNS no longer depends on the old host, and nothing in the migration is blocking. Only tell the owner it's safe to cancel WordPress hosting when safeToCancelWordPress is true. Call get_domain_switch_plan first.`,
+        inputSchema: { type: "object", properties: { templateId: { type: "string" }, jobId: { type: "string" } }, required: ["templateId", "jobId"] },
+    },
+];
+exports.WP_MIGRATION_TOOL_NAMES = new Set(exports.WP_MIGRATION_TOOL_DEFS.map((t) => t.name));
+const TERMINAL = new Set(["COMPLETED", "FAILED", "CANCELLED"]);
+function ids(args) {
+    const templateId = typeof args?.templateId === "string" ? args.templateId.trim() : "";
+    const jobId = typeof args?.jobId === "string" ? args.jobId.trim() : "";
+    if (!templateId || !jobId)
+        throw new Error("templateId and jobId are required (from start_wordpress_migration).");
+    return { templateId, jobId };
+}
+function summarizeReport(report) {
+    return {
+        readyForCutover: report.readyForCutover,
+        checklist: report.checklist,
+        summary: report.summary,
+        seo: report.seo,
+        plugins: (report.plugins ?? []).map((p) => ({ name: p.name, outcome: p.outcome, explanation: p.explanation })),
+        formsReconnected: (report.forms ?? []).map((f) => ({ page: f.page, name: f.name, fields: f.fields })),
+        brokenLinks: (report.brokenLinks ?? []).slice(0, 20),
+        failedFiles: (report.failedFiles ?? []).slice(0, 20),
+    };
+}
+async function handleWpMigrationToolCall(name, args, client) {
+    const base = client.appBaseUrl;
+    switch (name) {
+        case "preview_wordpress_migration": {
+            if (typeof args?.url !== "string" || !args.url.trim())
+                throw new Error("url is required.");
+            const result = await client.previewWordPressMigration(args.url);
+            return { preview: result.preview };
+        }
+        case "start_wordpress_migration": {
+            const result = await client.startWordPressMigration({
+                sourceUrl: String(args?.url ?? ""),
+                ownershipAttested: args?.ownershipConfirmed === true,
+                acceptAup: args?.acceptAcceptableUsePolicy === true ? true : undefined,
+            });
+            if (!result.ok)
+                return { started: false, error: result.error, requiresAupAcceptance: result.requiresAupAcceptance ?? false, existingMigration: result.existing ?? null };
+            return {
+                started: true,
+                templateId: result.templateId,
+                jobId: result.jobId,
+                dashboardUrl: `${base}/dashboard/migrate/wordpress?site=${result.templateId}&job=${result.jobId}`,
+                next: "Call get_wordpress_migration with this templateId and jobId until phase is COMPLETED.",
+            };
+        }
+        case "get_wordpress_migration": {
+            let templateId = typeof args?.templateId === "string" ? args.templateId : "";
+            let jobId = typeof args?.jobId === "string" ? args.jobId : "";
+            if (!templateId || !jobId) {
+                const { migrations } = await client.listWordPressMigrations();
+                if (!migrations?.length)
+                    return { found: false, message: "No WordPress migrations yet — start one with start_wordpress_migration." };
+                templateId = migrations[0].templateId;
+                jobId = migrations[0].id;
+            }
+            const before = await client.getWordPressMigration(templateId, jobId);
+            if (!TERMINAL.has(before.job.phase))
+                await client.stepWordPressMigration(templateId, jobId);
+            const { job, domains } = await client.getWordPressMigration(templateId, jobId);
+            const dashboardUrl = `${base}/dashboard/migrate/wordpress?site=${templateId}&job=${jobId}`;
+            if (job.phase === "COMPLETED" && job.report) {
+                return {
+                    phase: job.phase,
+                    templateId,
+                    jobId,
+                    dashboardUrl,
+                    publishedDomains: (domains ?? []).map((d) => d.domain),
+                    report: summarizeReport(job.report),
+                    next: "Use get_domain_switch_plan to move the owner's domain; keep WordPress running until verify_domain_switch says it's safe.",
+                };
+            }
+            return {
+                phase: job.phase,
+                templateId,
+                jobId,
+                dashboardUrl,
+                counts: job.counts ?? null,
+                lastError: job.phase === "PAUSED_ERROR" ? (job.errors ?? []).slice(-1)[0] : undefined,
+                next: job.phase === "PAUSED_ERROR" ? "Call get_wordpress_migration again to retry from where it stopped." : "Call get_wordpress_migration again to continue.",
+            };
+        }
+        case "get_domain_switch_plan": {
+            const { templateId, jobId } = ids(args);
+            const result = await client.getDomainSwitchPlan(templateId, jobId);
+            return { ...result.plan, connectedDomains: (result.connected ?? []).map((d) => d.domain) };
+        }
+        case "verify_domain_switch": {
+            const { templateId, jobId } = ids(args);
+            return (await client.verifyDomainSwitch(templateId, jobId)).verification;
+        }
+        case "connect_wordpress_migrator_plugin": {
+            const { templateId, jobId } = ids(args);
+            const current = await client.getMigratorConnector(templateId, jobId);
+            const code = current.connector?.code ?? (await client.createMigratorConnector(templateId, jobId)).connector.code;
+            return {
+                pluginDownloadUrl: `${base}/api/v1/wp-migration/plugin`,
+                connectionCode: code,
+                steps: [
+                    "Download the plugin (sign in to Plexo in the browser first) and install it: Plugins → Add New → Upload Plugin, then Activate.",
+                    "In WordPress, go to Tools → Plexo Migrator and paste the connection code.",
+                    "Then call import_wordpress_private_data.",
+                ],
+            };
+        }
+        case "import_wordpress_private_data": {
+            const { templateId, jobId } = ids(args);
+            let { connector } = await client.getMigratorConnector(templateId, jobId);
+            if (connector?.status !== "CONNECTED") {
+                connector = (await client.getMigratorConnector(templateId, jobId, true)).connector;
+                if (connector?.status !== "CONNECTED")
+                    return { connected: false, message: connector?.error ?? "Call connect_wordpress_migrator_plugin first." };
+            }
+            const { extras } = await client.importMigratorData(templateId, jobId);
+            return {
+                connected: true,
+                stage: extras.stage,
+                counts: extras.counts,
+                team: extras.stage === "done" ? extras.team : undefined,
+                error: extras.error,
+                next: extras.stage === "done" ? "Done. Offer to invite the team (admins as admin, others as editor of this site)." : "Call import_wordpress_private_data again to continue.",
+            };
+        }
+    }
+    throw new Error(`Unknown tool: ${name}`);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@charisol/plexo-mcp",
-  "version": "1.0.10",
+  "version": "1.0.11",
   "description": "Model Context Protocol (MCP) Server for Plexo - Landing page generation, email templates, publishing, and analytics.",
   "main": "dist/index.js",
   "bin": {

package/src/blogTools.ts

@@ -1,26 +1,28 @@
 import { PlexoClient } from "./client/plexoClient.js";
 
 const BLOG_LAYOUT_EXAMPLE = `
+DESIGN QUALITY applies here exactly as in publish_landing_page's description: pick one small ink/paper/accent palette and a serif-heading + sans-body (+ optional uppercase-mono eyebrow) type system, keep borderRadius near 0, use boxShadow sparingly, and give blog_content a constrained maxWidth (~680-760px) so long-form reading stays comfortable — do not default to generic #ffffff/Inter/fontWeight-800.
+
 EXAMPLE — a single-post layout with a hero image, title, meta line, and content:
 {
   "body": {
-    "style": { "backgroundColor": "#ffffff", "color": "#1e293b", "fontFamily": "Inter, sans-serif", "htmlTitle": "Blog Post" },
+    "style": { "backgroundColor": "#FAF7F1", "color": "#1B2430", "fontFamily": "'Inter', sans-serif", "htmlTitle": "Blog Post" },
     "rows": [
       { "id": "row-hero", "style": { "paddingTop": "0px" }, "columns": [
         { "id": "col-hero", "width": "100%", "elements": [
           { "id": "el-featured", "type": "blog_featured_image", "style": { "width": "100%", "maxHeight": "420px", "objectFit": "cover" }, "attributes": {} }
         ] }
       ] },
-      { "id": "row-meta", "style": { "paddingTop": "32px", "paddingBottom": "8px" }, "columns": [
+      { "id": "row-meta", "style": { "paddingTop": "40px", "paddingBottom": "8px", "maxWidth": "760px", "margin": "0 auto" }, "columns": [
         { "id": "col-title", "width": "100%", "elements": [
-          { "id": "el-title", "type": "blog_title", "style": { "fontSize": "40px", "fontWeight": "800" }, "attributes": {} },
-          { "id": "el-authordate", "type": "blog_author", "style": { "fontSize": "14px", "color": "#64748b", "display": "inline-block", "marginRight": "12px" }, "attributes": {} },
-          { "id": "el-date", "type": "blog_date", "style": { "fontSize": "14px", "color": "#64748b", "display": "inline-block" }, "attributes": {} }
+          { "id": "el-title", "type": "blog_title", "style": { "fontFamily": "'Playfair Display', serif", "fontWeight": "600", "fontSize": "40px", "lineHeight": "1.15" }, "attributes": {} },
+          { "id": "el-authordate", "type": "blog_author", "style": { "fontFamily": "'IBM Plex Mono', monospace", "fontSize": "12px", "letterSpacing": "0.1em", "textTransform": "uppercase", "color": "#5B6472", "display": "inline-block", "marginRight": "12px", "marginTop": "16px" }, "attributes": {} },
+          { "id": "el-date", "type": "blog_date", "style": { "fontFamily": "'IBM Plex Mono', monospace", "fontSize": "12px", "letterSpacing": "0.1em", "textTransform": "uppercase", "color": "#5B6472", "display": "inline-block" }, "attributes": {} }
         ] }
       ] },
-      { "id": "row-body", "style": { "paddingTop": "24px", "paddingBottom": "48px" }, "columns": [
+      { "id": "row-body", "style": { "paddingTop": "24px", "paddingBottom": "48px", "maxWidth": "760px", "margin": "0 auto" }, "columns": [
         { "id": "col-body", "width": "100%", "elements": [
-          { "id": "el-content", "type": "blog_content", "style": { "fontSize": "17px", "lineHeight": "1.7" }, "attributes": {} },
+          { "id": "el-content", "type": "blog_content", "style": { "fontFamily": "'Inter', sans-serif", "fontSize": "17px", "lineHeight": "1.75", "color": "#1B2430" }, "attributes": {} },
           { "id": "el-comments", "type": "blog_comments", "style": { "marginTop": "48px" }, "attributes": {} }
         ] }
       ] }
@@ -31,14 +33,15 @@ EXAMPLE — a single-post layout with a hero image, title, meta line, and conten
 EXAMPLE — a listing layout with a 3-column post grid:
 {
   "body": {
-    "style": { "backgroundColor": "#ffffff", "color": "#1e293b", "fontFamily": "Inter, sans-serif", "htmlTitle": "Blog" },
+    "style": { "backgroundColor": "#FAF7F1", "color": "#1B2430", "fontFamily": "'Inter', sans-serif", "htmlTitle": "Blog" },
     "rows": [
-      { "id": "row-heading", "style": { "paddingTop": "48px", "paddingBottom": "16px" }, "columns": [
+      { "id": "row-heading", "style": { "paddingTop": "56px", "paddingBottom": "16px" }, "columns": [
         { "id": "col-heading", "width": "100%", "elements": [
-          { "id": "el-heading", "type": "heading", "style": { "fontSize": "36px", "fontWeight": "800", "textAlign": "center" }, "attributes": { "text": "Latest Posts" } }
+          { "id": "el-eyebrow", "type": "text", "style": { "fontFamily": "'IBM Plex Mono', monospace", "fontSize": "12px", "letterSpacing": "0.16em", "textTransform": "uppercase", "color": "#C4623B", "textAlign": "center" }, "attributes": { "text": "Journal" } },
+          { "id": "el-heading", "type": "heading", "style": { "fontFamily": "'Playfair Display', serif", "fontWeight": "600", "fontSize": "36px", "textAlign": "center", "margin": "8px 0 0" }, "attributes": { "text": "Latest Posts" } }
         ] }
       ] },
-      { "id": "row-list", "style": { "paddingBottom": "48px" }, "columns": [
+      { "id": "row-list", "style": { "paddingBottom": "56px" }, "columns": [
         { "id": "col-list", "width": "100%", "elements": [
           { "id": "el-postlist", "type": "blog_post_list", "style": { "gridColumns": "3" }, "attributes": {} }
         ] }

package/src/client/plexoClient.ts

@@ -795,4 +795,100 @@ export class PlexoClient {
     if (!res.ok) throw new Error(data?.error || `Failed to fetch funnel addon slots (Status ${res.status})`);
     return data;
   }
+
+  /** Shared request helper for routes outside the blog/commerce/LMS families (WordPress migration, donations). */
+  private async apiFetch(method: string, path: string, body?: unknown, label = "Request"): Promise<any> {
+    this.checkAuth();
+    const res = await fetch(`${this.baseUrl}${path}`, {
+      method,
+      headers: this.getHeaders(),
+      ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
+    });
+    const data = (await res.json().catch(() => ({}))) as any;
+    if (!res.ok) throw new Error(data?.error || `${label} failed (Status ${res.status})`);
+    return data;
+  }
+
+  get appBaseUrl(): string {
+    return this.baseUrl;
+  }
+
+  // ── Commerce: bank transfers ────────────────────────────────────────────────
+
+  async resolveBankTransferOrder(templateId: string, orderId: string, action: "confirm" | "reject", reason?: string): Promise<any> {
+    return this.commerceFetch("POST", templateId, `/orders/${encodeURIComponent(orderId)}/bank-transfer`, { action, ...(reason ? { reason } : {}) });
+  }
+
+  // ── Donations (/api/v1/commerce/{templateId}/donations) ─────────────────────
+
+  async listDonations(templateId: string): Promise<any> {
+    return this.commerceFetch("GET", templateId, "/donations");
+  }
+
+  async createDonationCampaign(templateId: string, payload: Record<string, any>): Promise<any> {
+    return this.commerceFetch("POST", templateId, "/donations", payload);
+  }
+
+  async updateDonationCampaign(templateId: string, campaignId: string, payload: Record<string, any>): Promise<any> {
+    return this.commerceFetch("PATCH", templateId, `/donations/${encodeURIComponent(campaignId)}`, payload);
+  }
+
+  async cancelMonthlyDonation(templateId: string, subscriptionId: string): Promise<any> {
+    return this.commerceFetch("DELETE", templateId, `/donations/subscriptions/${encodeURIComponent(subscriptionId)}`);
+  }
+
+  async adoptMonthlyDonors(templateId: string, campaignId: string): Promise<any> {
+    return this.commerceFetch("POST", templateId, "/donations/adopt-monthly-donors", { campaignId });
+  }
+
+  // ── WordPress migration (/api/v1/wp-migration) ──────────────────────────────
+
+  async previewWordPressMigration(sourceUrl: string): Promise<any> {
+    return this.apiFetch("POST", "/api/v1/wp-migration/detect", { sourceUrl }, "WordPress check");
+  }
+
+  async startWordPressMigration(params: { sourceUrl: string; ownershipAttested: boolean; acceptAup?: boolean }): Promise<any> {
+    this.checkAuth();
+    const res = await fetch(`${this.baseUrl}/api/v1/wp-migration`, { method: "POST", headers: this.getHeaders(), body: JSON.stringify(params) });
+    const data = (await res.json().catch(() => ({}))) as any;
+    // Recoverable outcomes (needs AUP consent, already running) are returned, not thrown, so the assistant can act on them.
+    if (!res.ok && !data?.requiresAupAcceptance && !data?.existing) throw new Error(data?.error || `Migration start failed (Status ${res.status})`);
+    return { ok: res.ok, ...data };
+  }
+
+  async listWordPressMigrations(): Promise<any> {
+    return this.apiFetch("GET", "/api/v1/wp-migration", undefined, "Migration list");
+  }
+
+  private migrationPath(templateId: string, jobId: string): string {
+    return `/api/v1/wp-migration/${encodeURIComponent(templateId)}/${encodeURIComponent(jobId)}`;
+  }
+
+  async getWordPressMigration(templateId: string, jobId: string): Promise<any> {
+    return this.apiFetch("GET", this.migrationPath(templateId, jobId), undefined, "Migration status");
+  }
+
+  async stepWordPressMigration(templateId: string, jobId: string): Promise<any> {
+    return this.apiFetch("POST", `${this.migrationPath(templateId, jobId)}/step`, undefined, "Migration step");
+  }
+
+  async getMigratorConnector(templateId: string, jobId: string, check = false): Promise<any> {
+    return this.apiFetch("GET", `${this.migrationPath(templateId, jobId)}/connector${check ? "?check=1" : ""}`, undefined, "Plugin connection");
+  }
+
+  async createMigratorConnector(templateId: string, jobId: string): Promise<any> {
+    return this.apiFetch("POST", `${this.migrationPath(templateId, jobId)}/connector`, undefined, "Plugin connection");
+  }
+
+  async importMigratorData(templateId: string, jobId: string): Promise<any> {
+    return this.apiFetch("POST", `${this.migrationPath(templateId, jobId)}/connector/import`, undefined, "Private data import");
+  }
+
+  async getDomainSwitchPlan(templateId: string, jobId: string): Promise<any> {
+    return this.apiFetch("GET", `${this.migrationPath(templateId, jobId)}/cutover`, undefined, "Domain switch plan");
+  }
+
+  async verifyDomainSwitch(templateId: string, jobId: string): Promise<any> {
+    return this.apiFetch("POST", `${this.migrationPath(templateId, jobId)}/cutover/verify`, undefined, "Domain check");
+  }
 }

package/src/commerceTools.ts

@@ -310,6 +310,20 @@ export const COMMERCE_TOOL_DEFS = [
       required: ["templateId", "deliveryMethodId"],
     },
   },
+  {
+    name: "resolve_bank_transfer_order",
+    description: "Confirms or rejects a bank-transfer order that's waiting for payment (status PENDING, paymentMethod BANK_TRANSFER). action \"confirm\" marks it PAID and runs the normal paid flow (customer confirmation email, digital delivery, booking confirmed) — only use it once the site owner says the money has actually arrived in their account. action \"reject\" cancels it, releases its stock/booking slot, and emails the customer (optional reason is included).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        templateId: { type: "string", description: "The site's home page template id." },
+        orderId: { type: "string" },
+        action: { type: "string", enum: ["confirm", "reject"] },
+        reason: { type: "string", description: "Optional note to the customer when rejecting." },
+      },
+      required: ["templateId", "orderId", "action"],
+    },
+  },
   {
     name: "list_commerce_discounts",
     description: "Lists a site's discount codes, most recently created first.",
@@ -364,7 +378,7 @@ export const COMMERCE_TOOL_DEFS = [
   },
   {
     name: "list_commerce_customers",
-    description: "Lists this site's customers directly from its Paystack account (the merchant account that actually processed their payments) — requires Paystack to be configured on this site.",
+    description: "Lists everyone who's completed a paid order with this site, aggregated from its own orders (works for Stripe or Paystack, however the customer paid).",
     inputSchema: {
       type: "object",
       properties: {
@@ -485,6 +499,14 @@ export async function handleCommerceToolCall(name: string, args: any, client: Pl
       await client.deleteCommerceDeliveryMethod(templateId, args.deliveryMethodId);
       return { success: true, deletedDeliveryMethodId: args.deliveryMethodId };
 
+    case "resolve_bank_transfer_order": {
+      const orderId = typeof args.orderId === "string" ? args.orderId.trim() : "";
+      if (!orderId) throw new Error("orderId is required.");
+      if (args.action !== "confirm" && args.action !== "reject") throw new Error('action must be "confirm" or "reject".');
+      const result = await client.resolveBankTransferOrder(templateId, orderId, args.action, typeof args.reason === "string" ? args.reason : undefined);
+      return { success: true, order: result.order };
+    }
+
     case "list_commerce_discounts":
       return await client.listCommerceDiscounts(templateId);
 

package/src/donationTools.ts

@@ -0,0 +1,98 @@
+import { PlexoClient } from "./client/plexoClient.js";
+
+// Plexo Donations — same tools, same descriptions as the live connector in plexo-web
+// (lib/mcp/donationTools.ts), executed through plexo-web's REST API. Amounts are in the
+// smallest currency unit, like every other Commerce tool.
+
+const CAMPAIGN_FIELDS = {
+  name: { type: "string", description: "What donors are giving to, e.g. 'Support our mission'." },
+  description: { type: "string", description: "Optional one-line description shown on the form." },
+  presetAmounts: {
+    type: "array",
+    description: "Suggested amounts in the smallest currency unit, optionally named — e.g. [{\"amountMinor\":2500,\"label\":\"Bronze\"},{\"amountMinor\":5000}].",
+    items: { type: "object", properties: { amountMinor: { type: "number" }, label: { type: "string" } }, required: ["amountMinor"] },
+  },
+  defaultPresetIndex: { type: "number", description: "Which suggested amount is pre-selected (0-based)." },
+  allowCustomAmount: { type: "boolean", description: "Let donors type their own amount (default true)." },
+  minAmountMinor: { type: "number", description: "Smallest custom amount, smallest currency unit (default 100)." },
+  allowMonthly: { type: "boolean", description: "Offer monthly giving (default true; needs Stripe or Paystack connected)." },
+  defaultFrequency: { type: "string", enum: ["ONCE", "MONTHLY"], description: "Which frequency is pre-selected." },
+  goalAmountMinor: { type: ["number", "null"], description: "Optional fundraising goal — shows a progress bar." },
+  thankYouMessage: { type: "string", description: "Shown after donating and in the receipt email." },
+  buttonLabel: { type: "string", description: "Donate button text (default 'Donate')." },
+};
+
+export const DONATION_TOOL_DEFS = [
+  {
+    name: "list_donations",
+    description:
+      "Shows a site's donations: totals (raised, donors, monthly donors), every donation form (campaign) with its amounts and progress, monthly donors, and recent gifts. Also says whether payments are connected yet (paymentsReady) — if not, tell the owner to connect Stripe/Paystack or add bank details in Commerce → Settings → Payments.",
+    inputSchema: { type: "object", properties: { templateId: { type: "string", description: "The site's home page id (see list_landing_pages)." } }, required: ["templateId"] },
+  },
+  {
+    name: "create_donation_campaign",
+    description:
+      "Creates a donation form (campaign) for a site — one-time and optional monthly giving — and switches on everything donations need (no shop is created). Returns the campaign id and the embed snippet `<div data-plexo-donation=\"<id>\"></div>`: add that HTML to any page (e.g. via update_landing_page_page or a raw HTML page) to show a working donate form styled to the site.",
+    inputSchema: { type: "object", properties: { templateId: { type: "string", description: "The site's home page id." }, ...CAMPAIGN_FIELDS }, required: ["templateId", "name", "presetAmounts"] },
+  },
+  {
+    name: "update_donation_campaign",
+    description: "Edits a donation campaign. Only the fields you pass change. Pass active:false to turn a form off (gifts history is kept).",
+    inputSchema: {
+      type: "object",
+      properties: { templateId: { type: "string" }, campaignId: { type: "string" }, active: { type: "boolean" }, ...CAMPAIGN_FIELDS },
+      required: ["templateId", "campaignId"],
+    },
+  },
+  {
+    name: "cancel_monthly_donation",
+    description: "Stops one donor's monthly gift (at Stripe/Paystack too) — they won't be charged again. Only do this when the owner asks; confirm the donor first using list_donations.",
+    inputSchema: { type: "object", properties: { templateId: { type: "string" }, subscriptionId: { type: "string", description: "From list_donations' monthlyDonors[].id." } }, required: ["templateId", "subscriptionId"] },
+  },
+  {
+    name: "adopt_monthly_donors",
+    description:
+      "Brings monthly donors over from a previous website: finds active monthly gifts on the site's connected Stripe/Paystack account that Plexo doesn't know yet and records them under a campaign, so every future charge is receipted and counted. Donors don't have to do anything. Requires the SAME payment account the old site used to be connected.",
+    inputSchema: { type: "object", properties: { templateId: { type: "string" }, campaignId: { type: "string" } }, required: ["templateId", "campaignId"] },
+  },
+];
+
+export const DONATION_TOOL_NAMES = new Set(DONATION_TOOL_DEFS.map((t) => t.name));
+
+export async function handleDonationToolCall(name: string, args: any, client: PlexoClient): Promise<any> {
+  const templateId = typeof args?.templateId === "string" ? args.templateId.trim() : "";
+  if (!templateId) throw new Error("templateId is required — pass the site's home page id (see list_landing_pages).");
+  const { templateId: _t, campaignId, subscriptionId, ...fields } = args ?? {};
+  switch (name) {
+    case "list_donations":
+      return await client.listDonations(templateId);
+
+    case "create_donation_campaign": {
+      const { campaign } = await client.createDonationCampaign(templateId, fields);
+      const overview = await client.listDonations(templateId);
+      return {
+        campaign,
+        embedHtml: `<div data-plexo-donation="${campaign.id}"></div>`,
+        paymentsReady: overview.paymentsReady,
+        next: overview.paymentsReady
+          ? "Add embedHtml to the page where donors should give."
+          : "Add embedHtml to a page, and ask the owner to connect Stripe/Paystack (or add bank details) in Commerce → Settings → Payments — the form shows 'being set up' until then.",
+      };
+    }
+
+    case "update_donation_campaign": {
+      if (!campaignId) throw new Error("campaignId is required — use list_donations for ids.");
+      const { campaign } = await client.updateDonationCampaign(templateId, String(campaignId), fields);
+      return { updated: true, campaign };
+    }
+
+    case "cancel_monthly_donation":
+      if (!subscriptionId) throw new Error("subscriptionId is required — use list_donations' monthlyDonors[].id.");
+      return await client.cancelMonthlyDonation(templateId, String(subscriptionId));
+
+    case "adopt_monthly_donors":
+      if (!campaignId) throw new Error("campaignId is required — use list_donations for ids.");
+      return await client.adoptMonthlyDonors(templateId, String(campaignId));
+  }
+  throw new Error(`Unknown tool: ${name}`);
+}