@typeroll/mcp-server 0.43.16 → 0.44.0

package/dist/client.js

@@ -103,4 +103,7 @@ export class TyperollClient {
     rootPost(path, body) {
         return this.request('POST', this.rootUrl(path), body);
     }
+    rootPut(path, body) {
+        return this.request('PUT', this.rootUrl(path), body);
+    }
 }

package/dist/tools/domain.js

@@ -16,6 +16,64 @@
 import { z } from 'zod';
 import { ok, withErrorBoundary } from './helpers.js';
 export const domainTools = [
+    {
+        name: 'prepare_publishing_domain_change',
+        description: 'Prepare future website and media hosts using only the last successfully published snapshot. Saved CMS changes stay unpublished. Requires the current domain revision. Poll read_publishing_domains for certificate and DNS requirements, then explicitly approve the verified cutover.',
+        inputSchema: { revision: z.string() },
+        handler: withErrorBoundary(async (args, { client, siteId }) => ok(await client.post(siteId, 'publishing/prepare', args))),
+    },
+    {
+        name: 'read_organization_media_migration',
+        description: 'Read progress and actionable failures while original media moves to the organization Cloudflare account. Requires an organization API key.',
+        inputSchema: {},
+        handler: withErrorBoundary(async (_args, { client }) => ok(await client.rootGet('publishing/media-migration'))),
+    },
+    {
+        name: 'retry_organization_media_migration',
+        description: 'Resume verified media migration after fixing account, R2 or domain setup. Source files remain readable; pointer changes require matching hashes. Requires an organization API key.',
+        inputSchema: {},
+        handler: withErrorBoundary(async (_args, { client }) => ok(await client.rootPost('publishing/media-migration', {}))),
+    },
+    {
+        name: 'read_publishing_readiness',
+        description: 'Check required publishing connections and domains for the selected site. Returns actionable setup requirements. Editing and temporary previews remain available before publishing is configured.',
+        inputSchema: {},
+        handler: withErrorBoundary(async (_args, { client, siteId }) => ok(await client.get(siteId, 'publishing'))),
+    },
+    {
+        name: 'approve_publishing_domain_cutover',
+        description: 'Approve switching website traffic to the verified frozen deployment. Read publishing domains first and review DNS requirements and certificate readiness. Existing traffic is preserved until validation succeeds. External DNS management remains the caller’s responsibility.',
+        inputSchema: { revision: z.string(), candidate_id: z.string() },
+        handler: withErrorBoundary(async (args, { client, siteId }) => ok(await client.post(siteId, 'publishing/cutover', args))),
+    },
+    {
+        name: 'read_publishing_domains',
+        description: 'Read the desired and active website and media hosts, retained media aliases, DNS management mode and domain configuration revision. Saving intent does not switch traffic.',
+        inputSchema: {},
+        handler: withErrorBoundary(async (_args, { client, siteId }) => ok(await client.get(siteId, 'publishing/domains'))),
+    },
+    {
+        name: 'set_publishing_domains',
+        description: 'Save future website and media hosts before preparing a deployment. Requires the current revision from read_publishing_domains. This does not publish content or change traffic DNS. Choose external DNS when your agent manages Cloudflare independently.',
+        inputSchema: {
+            revision: z.string(), website_host: z.string().nullable(), media_host: z.string().nullable(),
+            media_path_prefix: z.string().optional().describe('Empty on a separate media host; /media when using the website host.'),
+            dns_mode: z.enum(['automatic', 'external']),
+        },
+        handler: withErrorBoundary(async (args, { client, siteId }) => ok(await client.put(siteId, 'publishing/domains', args))),
+    },
+    {
+        name: 'read_organization_publishing_domains',
+        description: 'Read the organization default domain. Requires an organization API key; site keys cannot access organization publishing settings.',
+        inputSchema: {},
+        handler: withErrorBoundary(async (_args, { client }) => ok(await client.rootGet('publishing/domains'))),
+    },
+    {
+        name: 'set_organization_publishing_domains',
+        description: 'Save the organization default domain used for demos and site versions. Requires an organization API key and the current settings revision. Does not modify DNS or replace an existing active domain.',
+        inputSchema: { revision: z.string(), default_domain: z.string().nullable(), dns_mode: z.enum(['automatic', 'external']) },
+        handler: withErrorBoundary(async (args, { client }) => ok(await client.rootPut('publishing/domains', args))),
+    },
     {
         name: 'read_domain',
         description: "Read the current state of the site's custom domain. Returns " +

package/dist/tools/media.js

@@ -100,6 +100,12 @@ async function uploadFromUrl(args, deps) {
     };
 }
 export const mediaTools = [
+    {
+        name: 'read_private_media_url',
+        description: 'Get a 60-second read URL for a private media original. Use it for authorized image inspection; never store it in page content or generated source. Use the stable media URL or ID in content.',
+        inputSchema: { media_id: z.string() },
+        handler: withErrorBoundary(async (args, { client, siteId }) => ok(await client.get(siteId, `media/${encodeURIComponent(args.media_id)}/content`))),
+    },
     {
         name: 'list_media',
         description: 'List uploaded media items (CDN URLs, alt text, mime). Newest first, cursor-paginated.',
@@ -240,11 +246,12 @@ export const mediaTools = [
     },
     {
         name: 'update_media',
-        description: 'Patch a media item\'s alt_text or filename. Other fields are immutable.',
+        description: 'Patch a media item\'s alt text, filename or public path. A public path change is applied at the next publication.',
         inputSchema: {
             media_id: z.string(),
             alt_text: z.string().optional(),
             filename: z.string().optional(),
+            public_path: z.string().nullable().optional().describe('Optional stable path such as /wp-content/uploads/2023/photo.jpg. Applied at the next build; existing public image URLs stay available.'),
         },
         handler: withErrorBoundary(async (args, { client, siteId }) => {
             const { media_id, ...body } = args;

package/dist/tools/preview.js

@@ -4,9 +4,20 @@ function v(version) {
     return version ? { version } : undefined;
 }
 export const previewTools = [
+    {
+        name: 'revoke_preview_link',
+        description: 'Revoke one previously issued preview link. Page access stops immediately; any media read URLs already issued expire within 60 seconds. Does not affect other preview links.',
+        inputSchema: { preview_url: z.string() },
+        handler: withErrorBoundary(async (args, { client, siteId }) => {
+            const token = new URL(args.preview_url).searchParams.get('t');
+            if (!token)
+                throw new Error('Expected a signed preview URL.');
+            return ok(await client.post(siteId, 'preview-link/revoke', { token }));
+        }),
+    },
     {
         name: 'get_preview_link',
-        description: 'Mint a signed URL the user (or your own browser tool) can open to SEE the rendered preview. Renders LIVE from the database with NO build — this is the PREFERRED way to preview design/content changes as you iterate; reach for this, not trigger_deploy, when previewing. BUFFER MODEL: your edits are unsaved drafts, so for the iteration loop mint the link with include_working_copy:true (drafts visible); a plain link shows SAVED content only — right for stakeholders reviewing what will deploy. Mint ONCE and REUSE that single URL across edits — internal links keep the token so it navigates the whole branch, and it stays valid until the TTL lapses (24h default and max). Target a page (page_id), a collection item (collection_name + item_id), or a raw slug; omit all for the home page. (For a permanently-bookmarkable link to the COMPILED static site, deploy and share the {branch}.{project}.pages.dev alias instead.)',
+        description: 'Mint a signed URL the user (or your own browser tool) can open to SEE the rendered preview. Renders LIVE from the database with NO build — this is the PREFERRED way to preview design/content changes as you iterate; reach for this, not trigger_deploy, when previewing. BUFFER MODEL: your edits are unsaved drafts, so for the iteration loop mint the link with include_working_copy:true (drafts visible); a plain link shows SAVED content only — right for stakeholders reviewing what will deploy. Mint ONCE and REUSE that single URL across edits — internal links keep the token so it navigates the whole branch, and it stays valid until the TTL lapses (24h default and max). Target a page (page_id), a collection item (collection_name + item_id), or a raw slug; omit all for the home page. (For a permanent public link, complete Publishing setup and wait for a verified deployment on the organization or site domain.)',
         inputSchema: {
             page_id: z.string().optional(),
             slug: z.string().optional(),

package/dist/version.js

@@ -8,4 +8,4 @@
 //
 // Keep it in lockstep with package.json: tests/version.test.ts asserts
 // VERSION === package.json.version, so a bump that forgets this line fails CI.
-export const VERSION = '0.43.16';
+export const VERSION = '0.44.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typeroll/mcp-server",
-  "version": "0.43.16",
+  "version": "0.44.0",
   "description": "Model Context Protocol server for the Typeroll public API. Use with Claude Code or any MCP-compatible client to manage a Typeroll site.",
   "license": "MIT",
   "repository": {