@charisol/plexo-mcp 1.0.8 → 1.0.9

package/dist/client/plexoClient.js

@@ -147,15 +147,23 @@ class PlexoClient {
     /**
      * Creates a new page nested under an existing landing page (its home page
      * for a top-level page, or another sub-page's id to nest deeper) — how a
-     * single landing page becomes a multi-page site. Starts blank; use
-     * updateTemplate() with the returned templateId to add content.
+     * single landing page becomes a multi-page site. Starts blank unless
+     * htmlContent is given, in which case it's created as a RAW_UPLOAD page
+     * instead — see updateTemplate() (BUILDER) / updateRawLandingPage()
+     * (RAW_UPLOAD) to add/edit content afterward, depending on which mode.
      */
     async createLandingPageSubpage(params) {
         this.checkAuth();
         const res = await fetch(`${this.baseUrl}/api/templates`, {
             method: "POST",
             headers: this.getHeaders(),
-            body: JSON.stringify({ name: params.name, parentId: params.parentTemplateId, slug: params.slug }),
+            body: JSON.stringify({
+                name: params.name,
+                parentId: params.parentTemplateId,
+                slug: params.slug,
+                htmlContent: params.htmlContent,
+                acceptAup: params.acceptAup,
+            }),
         });
         const data = (await res.json());
         if (!res.ok) {
@@ -163,6 +171,68 @@ class PlexoClient {
         }
         return data;
     }
+    /**
+     * Creates a landing page from raw HTML supplied directly (no designJson),
+     * served byte-for-byte as given — a different storage mode from
+     * createLandingPage/publishLandingPage, which are for the drag-and-drop
+     * BUILDER pages built from designJson. Same endpoint upload-raw's REST
+     * multipart path uses, but with a JSON body — this client has no real
+     * file to upload.
+     */
+    async createRawLandingPage(params) {
+        this.checkAuth();
+        const res = await fetch(`${this.baseUrl}/api/v1/templates/upload-raw`, {
+            method: "POST",
+            headers: this.getHeaders(),
+            body: JSON.stringify(params),
+        });
+        const data = (await res.json());
+        if (!res.ok) {
+            throw new Error(data?.error || `Raw landing page creation failed with status ${res.status}`);
+        }
+        return data;
+    }
+    /**
+     * Creates AND publishes a raw-HTML landing page in one call — the combined
+     * equivalent of createRawLandingPage() + publishExistingLandingPage().
+     */
+    async publishRawLandingPage(params) {
+        const created = await this.createRawLandingPage({
+            name: params.name,
+            htmlContent: params.htmlContent,
+            acceptAup: params.acceptAup,
+        });
+        const templateId = created?.templateId;
+        if (!templateId) {
+            throw new Error(created?.error || "Raw landing page creation did not return a templateId.");
+        }
+        const published = await this.publishExistingLandingPage({
+            templateId,
+            domain: params.domain,
+            type: params.type,
+        });
+        return { ...created, ...published };
+    }
+    /**
+     * Replaces an existing RAW_UPLOAD page's HTML in place, under the same
+     * template id — the editable URL, live URL, and domain (if published) are
+     * all unchanged. Same endpoint replace-upload's REST multipart path uses,
+     * but with a JSON body.
+     */
+    async updateRawLandingPage(params) {
+        this.checkAuth();
+        const { templateId, ...body } = params;
+        const res = await fetch(`${this.baseUrl}/api/v1/templates/${encodeURIComponent(templateId)}/replace-upload`, {
+            method: "POST",
+            headers: this.getHeaders(),
+            body: JSON.stringify(body),
+        });
+        const data = (await res.json());
+        if (!res.ok) {
+            throw new Error(data?.error || `Raw landing page update failed with status ${res.status}`);
+        }
+        return data;
+    }
     /**
      * Returns every page belonging to the same multi-page site as templateId
      * — its home page plus all nested sub-pages. templateId can be the home

package/dist/index.js

@@ -278,6 +278,8 @@ Map the returned tokens into designJson style fields: color-type tokens into bac
                 name: "update_template",
                 description: `Edits an existing landing page or email template in place, under the same template ID. Recompiles and re-saves the HTML from the new designJson — the editable URL stays the same, and for a published landing page the live URL and domain are unchanged too (this does not publish/unpublish or change the domain; call publish_landing_page again with a domain for that).
 
+This is for drag-and-drop BUILDER pages only — it REJECTS a page created via create_raw_landing_page/publish_raw_landing_page/create_landing_page_subpage's htmlContent option. Use update_raw_landing_page for those instead. If unsure which kind an existing page is, check its sourceType via list_landing_pages/get_landing_page_pages first.
+
 Uses the SAME fully-hydrated layout schema as publish_landing_page/create_email_template — designJson MUST be { "body": { "style": {...}, "rows": [{ "id", "style", "columns": [{ "id", "width", "elements": [{ "id", "type", "style", "attributes" }] }] }] } }. There is no shorthand row format; rows without a 'columns' array are rejected, and this replaces the ENTIRE designJson — to edit one section, fetch the current template's designJson first (via list_landing_pages/list_email_templates, or the Plexo dashboard) and send back the full modified tree, not just the changed part. See publish_landing_page's description for a full worked example.`,
                 inputSchema: {
                     type: "object",
@@ -302,6 +304,30 @@ Uses the SAME fully-hydrated layout schema as publish_landing_page/create_email_
                     required: ["templateId", "designJson"],
                 },
             },
+            {
+                name: "update_raw_landing_page",
+                description: `Replaces an existing RAW_UPLOAD page's HTML in place, under the same template ID — the editable URL, live URL, and domain (if published) are all unchanged. This is for pages created via create_raw_landing_page/publish_raw_landing_page/create_landing_page_subpage's htmlContent option ONLY — it REJECTS a drag-and-drop BUILDER page (use update_template for those). If unsure which kind an existing page is, check its sourceType via list_landing_pages/get_landing_page_pages first.
+
+This replaces the ENTIRE HTML document, not a patch — send back the full modified document. Same 1MB single-document scope as create_raw_landing_page.`,
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        templateId: {
+                            type: "string",
+                            description: "ID of the raw-upload page to update — the templateId returned by create_raw_landing_page, publish_raw_landing_page, list_landing_pages, or get_landing_page_pages.",
+                        },
+                        htmlContent: {
+                            type: "string",
+                            description: "The FULL replacement raw HTML document (up to 1MB) — not a partial patch.",
+                        },
+                        name: {
+                            type: "string",
+                            description: "Optional new title for the page. Omit to keep the existing name.",
+                        },
+                    },
+                    required: ["templateId", "htmlContent"],
+                },
+            },
             {
                 name: "create_landing_page",
                 description: `Creates and saves a landing page template WITHOUT publishing it to a domain — use this when the user wants to build a page (or start a multi-page site) first and go live later. Call publish_existing_landing_page afterward with the returned templateId to link a subdomain or custom domain whenever they're ready. To create a page AND publish it in one step, use publish_landing_page instead.
@@ -322,6 +348,63 @@ Uses the SAME fully-hydrated layout schema as publish_landing_page — see its d
                     required: ["designJson"],
                 },
             },
+            {
+                name: "create_raw_landing_page",
+                description: `Creates a landing page from a RAW HTML document you supply directly, WITHOUT publishing it to a domain — for when the user wants a page built from hand-written or externally-sourced HTML/CSS/JS instead of Plexo's drag-and-drop builder. The page is served byte-for-byte as given, completely unsanitized (no designJson, no compilation) — this is a DIFFERENT storage mode from create_landing_page/publish_landing_page/update_template, which are for the drag-and-drop BUILDER pages built from designJson. Do NOT use this tool for a page you want to build with designJson — use create_landing_page instead.
+
+Scope: a single self-contained HTML document only (inline or CDN-linked CSS/JS), up to 1MB — no zip/multi-file sites with separate local asset files (that's a dashboard-only "import a website" feature with no MCP equivalent yet).
+
+Because this serves unsanitized content, the account must accept the Acceptable Use Policy once — see the acceptAup argument. Call publish_existing_landing_page afterward with the returned templateId to link a subdomain or custom domain, or use publish_raw_landing_page to create and publish in one step. To edit this page's HTML later, use update_raw_landing_page (NOT update_template — that tool rejects raw-upload pages).`,
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        name: {
+                            type: "string",
+                            description: "Title of the landing page (e.g. 'Kicks Store').",
+                        },
+                        htmlContent: {
+                            type: "string",
+                            description: "The full, self-contained raw HTML document to serve as-is (up to 1MB). Inline or CDN-linked CSS/JS only — no separate local asset files.",
+                        },
+                        acceptAup: {
+                            type: "boolean",
+                            description: "Pass true ONLY after explicitly telling the user this publishes unsanitized HTML/CSS/JS as-is and getting their confirmation of the Acceptable Use Policy (/legal/acceptable-use). Not needed once the account has accepted it once before.",
+                        },
+                    },
+                    required: ["htmlContent"],
+                },
+            },
+            {
+                name: "publish_raw_landing_page",
+                description: `Creates, and publishes to a domain, a landing page from a RAW HTML document you supply directly — the combined create+publish equivalent of create_raw_landing_page. See create_raw_landing_page's description for the unsanitized-content, AUP, and scope caveats (single self-contained HTML document, up to 1MB, no zip/multi-file sites). For drag-and-drop BUILDER pages built from designJson, use publish_landing_page instead — this tool is a different storage mode.`,
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        name: {
+                            type: "string",
+                            description: "Title of the landing page (e.g. 'Kicks Store').",
+                        },
+                        htmlContent: {
+                            type: "string",
+                            description: "The full, self-contained raw HTML document to serve as-is (up to 1MB). Inline or CDN-linked CSS/JS only — no separate local asset files.",
+                        },
+                        acceptAup: {
+                            type: "boolean",
+                            description: "Pass true ONLY after explicitly telling the user this publishes unsanitized HTML/CSS/JS as-is and getting their confirmation of the Acceptable Use Policy (/legal/acceptable-use). Not needed once the account has accepted it once before.",
+                        },
+                        domain: {
+                            type: "string",
+                            description: "Subdomain slug (e.g. 'kicks') or custom domain ('kicks.com').",
+                        },
+                        type: {
+                            type: "string",
+                            enum: ["SUBDOMAIN", "CUSTOM"],
+                            description: "Domain routing type. Inferred from the domain string if omitted.",
+                        },
+                    },
+                    required: ["htmlContent", "domain"],
+                },
+            },
             {
                 name: "publish_existing_landing_page",
                 description: `Links a subdomain or custom domain to an already-existing landing page template — for a template created via create_landing_page, or the home page of a multi-page site (see create_landing_page_subpage) once its sub-pages are ready. Unlike publish_landing_page, this does NOT create a new template — it publishes the one you already have. Every sub-page nested under templateId automatically becomes reachable at this domain too (e.g. domain.com/about) — no separate publish call is needed per sub-page.`,
@@ -347,9 +430,9 @@ Uses the SAME fully-hydrated layout schema as publish_landing_page — see its d
             },
             {
                 name: "create_landing_page_subpage",
-                description: `Adds a new page nested under an existing landing page, reachable at <site domain>/<slug> — or nested deeper (e.g. /blog/post-1) if parentTemplateId is itself a sub-page rather than the home page. This is how a single landing page becomes a multi-page site. No separate publish step is needed for sub-pages: they automatically become reachable once the site's home page has a domain linked (see publish_existing_landing_page). Requires an Ultra subscription plan — sub-pages are otherwise unlimited per site once enabled.
+                description: `Adds a new page nested under an existing landing page, reachable at <site domain>/<slug> — or nested deeper (e.g. /blog/post-1) if parentTemplateId is itself a sub-page rather than the home page. This is how a single landing page becomes a multi-page site (BUILDER and RAW_UPLOAD pages can be freely mixed within the same site — each page's own sourceType is independent of its siblings). No separate publish step is needed for sub-pages: they automatically become reachable once the site's home page has a domain linked (see publish_existing_landing_page). Requires an Ultra subscription plan — sub-pages are otherwise unlimited per site once enabled.
 
-The new page starts blank — use update_template with the returned templateId to add content.`,
+Provide htmlContent for a raw-HTML sub-page (same unsanitized/AUP/1MB caveats as create_raw_landing_page). Omit it to create a blank BUILDER page — fill it in afterward with update_template using the returned templateId. Edit an existing sub-page's content afterward with update_template (BUILDER) or update_raw_landing_page (RAW_UPLOAD) depending on which mode it was created with.`,
                 inputSchema: {
                     type: "object",
                     properties: {
@@ -365,6 +448,14 @@ The new page starts blank — use update_template with the returned templateId t
                             type: "string",
                             description: "Optional URL segment (e.g. 'about-us'). Auto-generated from name if omitted; auto-suffixed (about-us-2, ...) if it collides with a sibling page under the same parent.",
                         },
+                        htmlContent: {
+                            type: "string",
+                            description: "Optional. A full, self-contained raw HTML document (up to 1MB) to serve as-is. Creates a RAW_UPLOAD sub-page instead of a blank BUILDER one.",
+                        },
+                        acceptAup: {
+                            type: "boolean",
+                            description: "Only relevant when htmlContent is given. Pass true ONLY after explicitly telling the user this publishes unsanitized HTML/CSS/JS as-is and getting their confirmation of the Acceptable Use Policy (/legal/acceptable-use). Not needed once the account has accepted it once before.",
+                        },
                     },
                     required: ["parentTemplateId", "name"],
                 },
@@ -562,6 +653,39 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                     ],
                 };
             }
+            case "create_raw_landing_page": {
+                const result = await client.createRawLandingPage(args);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "publish_raw_landing_page": {
+                const result = await client.publishRawLandingPage(args);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "update_raw_landing_page": {
+                const result = await client.updateRawLandingPage(args);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
             case "publish_existing_landing_page": {
                 const result = await client.publishExistingLandingPage(args);
                 return {

package/package.json

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

package/src/client/plexoClient.ts

@@ -196,19 +196,29 @@ export class PlexoClient {
   /**
    * Creates a new page nested under an existing landing page (its home page
    * for a top-level page, or another sub-page's id to nest deeper) — how a
-   * single landing page becomes a multi-page site. Starts blank; use
-   * updateTemplate() with the returned templateId to add content.
+   * single landing page becomes a multi-page site. Starts blank unless
+   * htmlContent is given, in which case it's created as a RAW_UPLOAD page
+   * instead — see updateTemplate() (BUILDER) / updateRawLandingPage()
+   * (RAW_UPLOAD) to add/edit content afterward, depending on which mode.
    */
   async createLandingPageSubpage(params: {
     parentTemplateId: string;
     name: string;
     slug?: string;
+    htmlContent?: string;
+    acceptAup?: boolean;
   }): Promise<any> {
     this.checkAuth();
     const res = await fetch(`${this.baseUrl}/api/templates`, {
       method: "POST",
       headers: this.getHeaders(),
-      body: JSON.stringify({ name: params.name, parentId: params.parentTemplateId, slug: params.slug }),
+      body: JSON.stringify({
+        name: params.name,
+        parentId: params.parentTemplateId,
+        slug: params.slug,
+        htmlContent: params.htmlContent,
+        acceptAup: params.acceptAup,
+      }),
     });
 
     const data = (await res.json()) as any;
@@ -219,6 +229,81 @@ export class PlexoClient {
     return data;
   }
 
+  /**
+   * Creates a landing page from raw HTML supplied directly (no designJson),
+   * served byte-for-byte as given — a different storage mode from
+   * createLandingPage/publishLandingPage, which are for the drag-and-drop
+   * BUILDER pages built from designJson. Same endpoint upload-raw's REST
+   * multipart path uses, but with a JSON body — this client has no real
+   * file to upload.
+   */
+  async createRawLandingPage(params: { name?: string; htmlContent: string; acceptAup?: boolean }): Promise<any> {
+    this.checkAuth();
+    const res = await fetch(`${this.baseUrl}/api/v1/templates/upload-raw`, {
+      method: "POST",
+      headers: this.getHeaders(),
+      body: JSON.stringify(params),
+    });
+
+    const data = (await res.json()) as any;
+    if (!res.ok) {
+      throw new Error(data?.error || `Raw landing page creation failed with status ${res.status}`);
+    }
+
+    return data;
+  }
+
+  /**
+   * Creates AND publishes a raw-HTML landing page in one call — the combined
+   * equivalent of createRawLandingPage() + publishExistingLandingPage().
+   */
+  async publishRawLandingPage(params: {
+    name?: string;
+    htmlContent: string;
+    acceptAup?: boolean;
+    domain: string;
+    type?: "SUBDOMAIN" | "CUSTOM";
+  }): Promise<any> {
+    const created = await this.createRawLandingPage({
+      name: params.name,
+      htmlContent: params.htmlContent,
+      acceptAup: params.acceptAup,
+    });
+    const templateId = created?.templateId;
+    if (!templateId) {
+      throw new Error(created?.error || "Raw landing page creation did not return a templateId.");
+    }
+    const published = await this.publishExistingLandingPage({
+      templateId,
+      domain: params.domain,
+      type: params.type,
+    });
+    return { ...created, ...published };
+  }
+
+  /**
+   * Replaces an existing RAW_UPLOAD page's HTML in place, under the same
+   * template id — the editable URL, live URL, and domain (if published) are
+   * all unchanged. Same endpoint replace-upload's REST multipart path uses,
+   * but with a JSON body.
+   */
+  async updateRawLandingPage(params: { templateId: string; htmlContent: string; name?: string }): Promise<any> {
+    this.checkAuth();
+    const { templateId, ...body } = params;
+    const res = await fetch(`${this.baseUrl}/api/v1/templates/${encodeURIComponent(templateId)}/replace-upload`, {
+      method: "POST",
+      headers: this.getHeaders(),
+      body: JSON.stringify(body),
+    });
+
+    const data = (await res.json()) as any;
+    if (!res.ok) {
+      throw new Error(data?.error || `Raw landing page update failed with status ${res.status}`);
+    }
+
+    return data;
+  }
+
   /**
    * Returns every page belonging to the same multi-page site as templateId
    * — its home page plus all nested sub-pages. templateId can be the home

package/src/index.ts

@@ -285,6 +285,8 @@ Map the returned tokens into designJson style fields: color-type tokens into bac
         name: "update_template",
         description: `Edits an existing landing page or email template in place, under the same template ID. Recompiles and re-saves the HTML from the new designJson — the editable URL stays the same, and for a published landing page the live URL and domain are unchanged too (this does not publish/unpublish or change the domain; call publish_landing_page again with a domain for that).
 
+This is for drag-and-drop BUILDER pages only — it REJECTS a page created via create_raw_landing_page/publish_raw_landing_page/create_landing_page_subpage's htmlContent option. Use update_raw_landing_page for those instead. If unsure which kind an existing page is, check its sourceType via list_landing_pages/get_landing_page_pages first.
+
 Uses the SAME fully-hydrated layout schema as publish_landing_page/create_email_template — designJson MUST be { "body": { "style": {...}, "rows": [{ "id", "style", "columns": [{ "id", "width", "elements": [{ "id", "type", "style", "attributes" }] }] }] } }. There is no shorthand row format; rows without a 'columns' array are rejected, and this replaces the ENTIRE designJson — to edit one section, fetch the current template's designJson first (via list_landing_pages/list_email_templates, or the Plexo dashboard) and send back the full modified tree, not just the changed part. See publish_landing_page's description for a full worked example.`,
         inputSchema: {
           type: "object",
@@ -309,6 +311,30 @@ Uses the SAME fully-hydrated layout schema as publish_landing_page/create_email_
           required: ["templateId", "designJson"],
         },
       },
+      {
+        name: "update_raw_landing_page",
+        description: `Replaces an existing RAW_UPLOAD page's HTML in place, under the same template ID — the editable URL, live URL, and domain (if published) are all unchanged. This is for pages created via create_raw_landing_page/publish_raw_landing_page/create_landing_page_subpage's htmlContent option ONLY — it REJECTS a drag-and-drop BUILDER page (use update_template for those). If unsure which kind an existing page is, check its sourceType via list_landing_pages/get_landing_page_pages first.
+
+This replaces the ENTIRE HTML document, not a patch — send back the full modified document. Same 1MB single-document scope as create_raw_landing_page.`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            templateId: {
+              type: "string",
+              description: "ID of the raw-upload page to update — the templateId returned by create_raw_landing_page, publish_raw_landing_page, list_landing_pages, or get_landing_page_pages.",
+            },
+            htmlContent: {
+              type: "string",
+              description: "The FULL replacement raw HTML document (up to 1MB) — not a partial patch.",
+            },
+            name: {
+              type: "string",
+              description: "Optional new title for the page. Omit to keep the existing name.",
+            },
+          },
+          required: ["templateId", "htmlContent"],
+        },
+      },
       {
         name: "create_landing_page",
         description: `Creates and saves a landing page template WITHOUT publishing it to a domain — use this when the user wants to build a page (or start a multi-page site) first and go live later. Call publish_existing_landing_page afterward with the returned templateId to link a subdomain or custom domain whenever they're ready. To create a page AND publish it in one step, use publish_landing_page instead.
@@ -329,6 +355,63 @@ Uses the SAME fully-hydrated layout schema as publish_landing_page — see its d
           required: ["designJson"],
         },
       },
+      {
+        name: "create_raw_landing_page",
+        description: `Creates a landing page from a RAW HTML document you supply directly, WITHOUT publishing it to a domain — for when the user wants a page built from hand-written or externally-sourced HTML/CSS/JS instead of Plexo's drag-and-drop builder. The page is served byte-for-byte as given, completely unsanitized (no designJson, no compilation) — this is a DIFFERENT storage mode from create_landing_page/publish_landing_page/update_template, which are for the drag-and-drop BUILDER pages built from designJson. Do NOT use this tool for a page you want to build with designJson — use create_landing_page instead.
+
+Scope: a single self-contained HTML document only (inline or CDN-linked CSS/JS), up to 1MB — no zip/multi-file sites with separate local asset files (that's a dashboard-only "import a website" feature with no MCP equivalent yet).
+
+Because this serves unsanitized content, the account must accept the Acceptable Use Policy once — see the acceptAup argument. Call publish_existing_landing_page afterward with the returned templateId to link a subdomain or custom domain, or use publish_raw_landing_page to create and publish in one step. To edit this page's HTML later, use update_raw_landing_page (NOT update_template — that tool rejects raw-upload pages).`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            name: {
+              type: "string",
+              description: "Title of the landing page (e.g. 'Kicks Store').",
+            },
+            htmlContent: {
+              type: "string",
+              description: "The full, self-contained raw HTML document to serve as-is (up to 1MB). Inline or CDN-linked CSS/JS only — no separate local asset files.",
+            },
+            acceptAup: {
+              type: "boolean",
+              description: "Pass true ONLY after explicitly telling the user this publishes unsanitized HTML/CSS/JS as-is and getting their confirmation of the Acceptable Use Policy (/legal/acceptable-use). Not needed once the account has accepted it once before.",
+            },
+          },
+          required: ["htmlContent"],
+        },
+      },
+      {
+        name: "publish_raw_landing_page",
+        description: `Creates, and publishes to a domain, a landing page from a RAW HTML document you supply directly — the combined create+publish equivalent of create_raw_landing_page. See create_raw_landing_page's description for the unsanitized-content, AUP, and scope caveats (single self-contained HTML document, up to 1MB, no zip/multi-file sites). For drag-and-drop BUILDER pages built from designJson, use publish_landing_page instead — this tool is a different storage mode.`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            name: {
+              type: "string",
+              description: "Title of the landing page (e.g. 'Kicks Store').",
+            },
+            htmlContent: {
+              type: "string",
+              description: "The full, self-contained raw HTML document to serve as-is (up to 1MB). Inline or CDN-linked CSS/JS only — no separate local asset files.",
+            },
+            acceptAup: {
+              type: "boolean",
+              description: "Pass true ONLY after explicitly telling the user this publishes unsanitized HTML/CSS/JS as-is and getting their confirmation of the Acceptable Use Policy (/legal/acceptable-use). Not needed once the account has accepted it once before.",
+            },
+            domain: {
+              type: "string",
+              description: "Subdomain slug (e.g. 'kicks') or custom domain ('kicks.com').",
+            },
+            type: {
+              type: "string",
+              enum: ["SUBDOMAIN", "CUSTOM"],
+              description: "Domain routing type. Inferred from the domain string if omitted.",
+            },
+          },
+          required: ["htmlContent", "domain"],
+        },
+      },
       {
         name: "publish_existing_landing_page",
         description: `Links a subdomain or custom domain to an already-existing landing page template — for a template created via create_landing_page, or the home page of a multi-page site (see create_landing_page_subpage) once its sub-pages are ready. Unlike publish_landing_page, this does NOT create a new template — it publishes the one you already have. Every sub-page nested under templateId automatically becomes reachable at this domain too (e.g. domain.com/about) — no separate publish call is needed per sub-page.`,
@@ -354,9 +437,9 @@ Uses the SAME fully-hydrated layout schema as publish_landing_page — see its d
       },
       {
         name: "create_landing_page_subpage",
-        description: `Adds a new page nested under an existing landing page, reachable at <site domain>/<slug> — or nested deeper (e.g. /blog/post-1) if parentTemplateId is itself a sub-page rather than the home page. This is how a single landing page becomes a multi-page site. No separate publish step is needed for sub-pages: they automatically become reachable once the site's home page has a domain linked (see publish_existing_landing_page). Requires an Ultra subscription plan — sub-pages are otherwise unlimited per site once enabled.
+        description: `Adds a new page nested under an existing landing page, reachable at <site domain>/<slug> — or nested deeper (e.g. /blog/post-1) if parentTemplateId is itself a sub-page rather than the home page. This is how a single landing page becomes a multi-page site (BUILDER and RAW_UPLOAD pages can be freely mixed within the same site — each page's own sourceType is independent of its siblings). No separate publish step is needed for sub-pages: they automatically become reachable once the site's home page has a domain linked (see publish_existing_landing_page). Requires an Ultra subscription plan — sub-pages are otherwise unlimited per site once enabled.
 
-The new page starts blank — use update_template with the returned templateId to add content.`,
+Provide htmlContent for a raw-HTML sub-page (same unsanitized/AUP/1MB caveats as create_raw_landing_page). Omit it to create a blank BUILDER page — fill it in afterward with update_template using the returned templateId. Edit an existing sub-page's content afterward with update_template (BUILDER) or update_raw_landing_page (RAW_UPLOAD) depending on which mode it was created with.`,
         inputSchema: {
           type: "object",
           properties: {
@@ -372,6 +455,14 @@ The new page starts blank — use update_template with the returned templateId t
               type: "string",
               description: "Optional URL segment (e.g. 'about-us'). Auto-generated from name if omitted; auto-suffixed (about-us-2, ...) if it collides with a sibling page under the same parent.",
             },
+            htmlContent: {
+              type: "string",
+              description: "Optional. A full, self-contained raw HTML document (up to 1MB) to serve as-is. Creates a RAW_UPLOAD sub-page instead of a blank BUILDER one.",
+            },
+            acceptAup: {
+              type: "boolean",
+              description: "Only relevant when htmlContent is given. Pass true ONLY after explicitly telling the user this publishes unsanitized HTML/CSS/JS as-is and getting their confirmation of the Acceptable Use Policy (/legal/acceptable-use). Not needed once the account has accepted it once before.",
+            },
           },
           required: ["parentTemplateId", "name"],
         },
@@ -576,6 +667,42 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         };
       }
 
+      case "create_raw_landing_page": {
+        const result = await client.createRawLandingPage(args as any);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2),
+            },
+          ],
+        };
+      }
+
+      case "publish_raw_landing_page": {
+        const result = await client.publishRawLandingPage(args as any);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2),
+            },
+          ],
+        };
+      }
+
+      case "update_raw_landing_page": {
+        const result = await client.updateRawLandingPage(args as any);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2),
+            },
+          ],
+        };
+      }
+
       case "publish_existing_landing_page": {
         const result = await client.publishExistingLandingPage(args as any);
         return {