@charisol/plexo-mcp 1.0.9 → 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.9",
+  "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

@@ -570,4 +570,325 @@ export class PlexoClient {
   async deleteBlogComment(templateId: string, commentId: string): Promise<any> {
     return this.blogFetch("DELETE", templateId, `/comments/${encodeURIComponent(commentId)}`);
   }
+
+  /** Shared request helper for every /api/v1/commerce/{templateId}/... route below — the
+   * same admin endpoints the Plexo dashboard's own Commerce UI calls, same Bearer/x-api-key
+   * auth as the rest of this client (see resolveCommerceAdmin server-side). */
+  private async commerceFetch(method: string, templateId: string, path: string, body?: unknown): Promise<any> {
+    this.checkAuth();
+    const res = await fetch(`${this.baseUrl}/api/v1/commerce/${encodeURIComponent(templateId)}${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 || `Commerce request failed (Status ${res.status})`);
+    return data;
+  }
+
+  async listCommerceProducts(templateId: string, params: { kind?: string; activeOnly?: boolean } = {}): Promise<any> {
+    const query = new URLSearchParams();
+    if (params.kind) query.set("kind", params.kind);
+    if (params.activeOnly) query.set("activeOnly", "true");
+    const qs = query.toString();
+    return this.commerceFetch("GET", templateId, `/products${qs ? `?${qs}` : ""}`);
+  }
+
+  async getCommerceProduct(templateId: string, productId: string): Promise<any> {
+    return this.commerceFetch("GET", templateId, `/products/${encodeURIComponent(productId)}`);
+  }
+
+  async createCommerceProduct(templateId: string, payload: Record<string, any>): Promise<any> {
+    return this.commerceFetch("POST", templateId, "/products", payload);
+  }
+
+  async updateCommerceProduct(templateId: string, productId: string, payload: Record<string, any>): Promise<any> {
+    return this.commerceFetch("PATCH", templateId, `/products/${encodeURIComponent(productId)}`, payload);
+  }
+
+  async deleteCommerceProduct(templateId: string, productId: string): Promise<any> {
+    return this.commerceFetch("DELETE", templateId, `/products/${encodeURIComponent(productId)}`);
+  }
+
+  async getCommerceSettings(templateId: string): Promise<any> {
+    return this.commerceFetch("GET", templateId, "/settings");
+  }
+
+  async updateCommerceSettings(templateId: string, payload: Record<string, any>): Promise<any> {
+    return this.commerceFetch("PUT", templateId, "/settings", payload);
+  }
+
+  async listCommerceOrders(templateId: string, params: { status?: string; q?: string; page?: number } = {}): Promise<any> {
+    const query = new URLSearchParams();
+    if (params.status) query.set("status", params.status);
+    if (params.q) query.set("q", params.q);
+    if (params.page) query.set("page", String(params.page));
+    const qs = query.toString();
+    return this.commerceFetch("GET", templateId, `/orders${qs ? `?${qs}` : ""}`);
+  }
+
+  async getCommerceOrder(templateId: string, orderId: string): Promise<any> {
+    return this.commerceFetch("GET", templateId, `/orders/${encodeURIComponent(orderId)}`);
+  }
+
+  async updateCommerceOrder(templateId: string, orderId: string, fulfillmentStatus: string): Promise<any> {
+    return this.commerceFetch("PATCH", templateId, `/orders/${encodeURIComponent(orderId)}`, { fulfillmentStatus });
+  }
+
+  async refundCommerceOrder(templateId: string, orderId: string): Promise<any> {
+    return this.commerceFetch("POST", templateId, `/orders/${encodeURIComponent(orderId)}/refund`);
+  }
+
+  async resendDigitalDelivery(templateId: string, orderId: string, deliveryId: string): Promise<any> {
+    return this.commerceFetch("POST", templateId, `/orders/${encodeURIComponent(orderId)}/resend-digital-delivery`, { deliveryId });
+  }
+
+  async getCommerceWallet(templateId: string): Promise<any> {
+    return this.commerceFetch("GET", templateId, "/wallet");
+  }
+
+  async listCommerceWithdrawals(templateId: string): Promise<any> {
+    return this.commerceFetch("GET", templateId, "/wallet/withdrawals");
+  }
+
+  async requestCommerceWithdrawal(templateId: string, payload: { amountCents: number; accountNumber: string; accountHolderName: string; bankName: string }): Promise<any> {
+    return this.commerceFetch("POST", templateId, "/wallet/withdrawals", payload);
+  }
+
+  async getCommerceStripeAccessStatus(): Promise<any> {
+    this.checkAuth();
+    const res = await fetch(`${this.baseUrl}/api/v1/commerce/stripe-access`, { method: "GET", headers: this.getHeaders() });
+    const data = (await res.json().catch(() => ({}))) as any;
+    if (!res.ok) throw new Error(data?.error || `Failed to fetch Stripe access status (Status ${res.status})`);
+    return data;
+  }
+
+  async requestCommerceStripeAccess(payload: { reason?: string; expectedVolume?: string } = {}): Promise<any> {
+    this.checkAuth();
+    const res = await fetch(`${this.baseUrl}/api/v1/commerce/stripe-access`, {
+      method: "POST",
+      headers: this.getHeaders(),
+      body: JSON.stringify(payload),
+    });
+    const data = (await res.json().catch(() => ({}))) as any;
+    if (!res.ok) throw new Error(data?.error || `Failed to request Stripe access (Status ${res.status})`);
+    return data;
+  }
+
+  async listCommerceDeliveryMethods(templateId: string): Promise<any> {
+    return this.commerceFetch("GET", templateId, "/delivery-methods");
+  }
+
+  async createCommerceDeliveryMethod(templateId: string, payload: Record<string, any>): Promise<any> {
+    return this.commerceFetch("POST", templateId, "/delivery-methods", payload);
+  }
+
+  async updateCommerceDeliveryMethod(templateId: string, id: string, payload: Record<string, any>): Promise<any> {
+    return this.commerceFetch("PATCH", templateId, `/delivery-methods/${encodeURIComponent(id)}`, payload);
+  }
+
+  async deleteCommerceDeliveryMethod(templateId: string, id: string): Promise<any> {
+    return this.commerceFetch("DELETE", templateId, `/delivery-methods/${encodeURIComponent(id)}`);
+  }
+
+  async listCommerceDiscounts(templateId: string): Promise<any> {
+    return this.commerceFetch("GET", templateId, "/discounts");
+  }
+
+  async createCommerceDiscount(templateId: string, payload: Record<string, any>): Promise<any> {
+    return this.commerceFetch("POST", templateId, "/discounts", payload);
+  }
+
+  async updateCommerceDiscount(templateId: string, id: string, payload: Record<string, any>): Promise<any> {
+    return this.commerceFetch("PATCH", templateId, `/discounts/${encodeURIComponent(id)}`, payload);
+  }
+
+  async deleteCommerceDiscount(templateId: string, id: string): Promise<any> {
+    return this.commerceFetch("DELETE", templateId, `/discounts/${encodeURIComponent(id)}`);
+  }
+
+  async listCommerceCustomers(templateId: string, page?: number): Promise<any> {
+    return this.commerceFetch("GET", templateId, `/customers${page ? `?page=${page}` : ""}`);
+  }
+
+  /** Shared request helper for every /api/v1/lms/funnels/{templateId}/... route below. */
+  private async lmsFetch(method: string, templateId: string, path: string, body?: unknown): Promise<any> {
+    this.checkAuth();
+    const res = await fetch(`${this.baseUrl}/api/v1/lms/funnels/${encodeURIComponent(templateId)}${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 || `Funnel request failed (Status ${res.status})`);
+    return data;
+  }
+
+  async createFunnel(templateId: string): Promise<any> {
+    this.checkAuth();
+    const res = await fetch(`${this.baseUrl}/api/v1/lms/funnels`, {
+      method: "POST",
+      headers: this.getHeaders(),
+      body: JSON.stringify({ templateId }),
+    });
+    const data = (await res.json().catch(() => ({}))) as any;
+    if (!res.ok) throw new Error(data?.error || `Funnel creation failed (Status ${res.status})`);
+    return data;
+  }
+
+  async getFunnel(templateId: string): Promise<any> {
+    return this.lmsFetch("GET", templateId, "");
+  }
+
+  async updateFunnel(templateId: string, payload: Record<string, any>): Promise<any> {
+    return this.lmsFetch("PATCH", templateId, "", payload);
+  }
+
+  async deleteFunnel(templateId: string): Promise<any> {
+    return this.lmsFetch("DELETE", templateId, "");
+  }
+
+  async listFunnelPages(templateId: string): Promise<any> {
+    return this.lmsFetch("GET", templateId, "/pages");
+  }
+
+  async createFunnelPage(templateId: string, payload: { title?: string; kind?: string } = {}): Promise<any> {
+    return this.lmsFetch("POST", templateId, "/pages", payload);
+  }
+
+  async updateFunnelPage(templateId: string, pageId: string, payload: Record<string, any>): Promise<any> {
+    return this.lmsFetch("PATCH", templateId, `/pages/${encodeURIComponent(pageId)}`, payload);
+  }
+
+  async deleteFunnelPage(templateId: string, pageId: string): Promise<any> {
+    return this.lmsFetch("DELETE", templateId, `/pages/${encodeURIComponent(pageId)}`);
+  }
+
+  async reorderFunnelPages(templateId: string, orderedPageIds: string[]): Promise<any> {
+    return this.lmsFetch("POST", templateId, "/pages/reorder", { orderedPageIds });
+  }
+
+  async listFunnelEnrollments(templateId: string): Promise<any> {
+    return this.lmsFetch("GET", templateId, "/enrollments");
+  }
+
+  async getFunnelEnrollment(templateId: string, email: string): Promise<any> {
+    return this.lmsFetch("GET", templateId, `/enrollments/${encodeURIComponent(email)}`);
+  }
+
+  async setFunnelEnrollmentStatus(templateId: string, email: string, status: "ACTIVE" | "REVOKED"): Promise<any> {
+    return this.lmsFetch("PATCH", templateId, `/enrollments/${encodeURIComponent(email)}`, { status });
+  }
+
+  async approveFunnelEnrollmentPage(templateId: string, email: string, pageId: string): Promise<any> {
+    return this.lmsFetch("POST", templateId, `/enrollments/${encodeURIComponent(email)}/approve`, { pageId });
+  }
+
+  async resendFunnelMagicLink(templateId: string, email: string): Promise<any> {
+    return this.lmsFetch("POST", templateId, `/enrollments/${encodeURIComponent(email)}/resend-magic-link`);
+  }
+
+  async getFunnelAddonSlots(): Promise<any> {
+    this.checkAuth();
+    const res = await fetch(`${this.baseUrl}/api/v1/lms/addon-slots`, { method: "GET", headers: this.getHeaders() });
+    const data = (await res.json().catch(() => ({}))) as any;
+    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");
+  }
 }