pulsemcp-cms-admin-mcp-server 0.9.10 → 0.9.12

package/build/shared/src/tools.js

@@ -66,6 +66,10 @@ import { getProctorMetadata } from './tools/get-proctor-metadata.js';
 import { listDiscoveredUrls } from './tools/list-discovered-urls.js';
 import { markDiscoveredUrlProcessed } from './tools/mark-discovered-url-processed.js';
 import { getDiscoveredUrlStats } from './tools/get-discovered-url-stats.js';
+// MOZ tools
+import { getMozMetrics } from './tools/get-moz-metrics.js';
+import { getMozBacklinks } from './tools/get-moz-backlinks.js';
+import { getMozStoredMetrics } from './tools/get-moz-stored-metrics.js';
 const ALL_TOOLS = [
     // Newsletter tools (all are write operations except get_newsletter_posts/post and get_authors)
     { factory: getNewsletterPosts, groups: ['newsletter'], isWriteOperation: false },
@@ -242,6 +246,10 @@ const ALL_TOOLS = [
         isWriteOperation: true,
     },
     { factory: getDiscoveredUrlStats, groups: ['discovered_urls'], isWriteOperation: false },
+    // MOZ tools (all read-only - live metrics, backlinks, and stored data)
+    { factory: getMozMetrics, groups: ['moz'], isWriteOperation: false },
+    { factory: getMozBacklinks, groups: ['moz'], isWriteOperation: false },
+    { factory: getMozStoredMetrics, groups: ['moz'], isWriteOperation: false },
 ];
 /**
  * All valid tool groups (base groups and their _readonly variants)
@@ -271,6 +279,8 @@ const VALID_TOOL_GROUPS = [
     'proctor_readonly',
     'discovered_urls',
     'discovered_urls_readonly',
+    'moz',
+    'moz_readonly',
     'notifications',
 ];
 /**
@@ -289,6 +299,7 @@ const BASE_TOOL_GROUPS = [
     'good_jobs',
     'proctor',
     'discovered_urls',
+    'moz',
     'notifications',
 ];
 /**
@@ -374,6 +385,8 @@ function shouldIncludeTool(toolDef, enabledGroups) {
  * - proctor_readonly: Proctor tools (read only - get_exam_result, list_proctor_runs, and get_proctor_metadata)
  * - discovered_urls: Discovered URL management tools for processing URLs into MCP implementations (read + write)
  * - discovered_urls_readonly: Discovered URL tools (read only - list and stats)
+ * - moz: MOZ SEO metrics tools - live URL metrics, backlinks, and stored historical data (all read-only)
+ * - moz_readonly: MOZ tools (read only - same as moz since all tools are read-only)
  * - notifications: Notification email tools - send_impl_posted_notif (write-only, no readonly variant)
  *
  * @param clientFactory - Factory function that creates client instances

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pulsemcp-cms-admin-mcp-server",
-  "version": "0.9.10",
+  "version": "0.9.12",
   "description": "Local implementation of PulseMCP CMS Admin MCP server",
   "mcpName": "com.pulsemcp.servers/pulsemcp-cms-admin",
   "main": "build/index.js",

package/shared/exam-result-store.js

@@ -21,7 +21,8 @@ export function extractExamId(line) {
  */
 export function extractStatus(line) {
     const data = line.data;
-    return data?.status || line.status || 'unknown';
+    const result = data?.result;
+    return (result?.status || data?.status || line.status || 'unknown');
 }
 /**
  * Maximum number of results to keep on disk. Oldest results are evicted

package/shared/pulsemcp-admin-client/lib/get-moz-backlinks.d.ts

@@ -0,0 +1,7 @@
+import type { MozBacklinksResponse } from '../../types.js';
+export declare function getMozBacklinks(apiKey: string, baseUrl: string, params: {
+    url: string;
+    scope?: 'url' | 'domain' | 'subdomain';
+    limit?: number;
+}): Promise<MozBacklinksResponse>;
+//# sourceMappingURL=get-moz-backlinks.d.ts.map

package/shared/pulsemcp-admin-client/lib/get-moz-backlinks.js

@@ -0,0 +1,39 @@
+export async function getMozBacklinks(apiKey, baseUrl, params) {
+    const apiUrl = new URL('/api/moz/backlinks', baseUrl);
+    apiUrl.searchParams.append('url', params.url);
+    if (params.scope) {
+        apiUrl.searchParams.append('scope', params.scope);
+    }
+    if (params.limit !== undefined) {
+        apiUrl.searchParams.append('limit', params.limit.toString());
+    }
+    const response = await fetch(apiUrl.toString(), {
+        method: 'GET',
+        headers: {
+            'X-API-Key': apiKey,
+            Accept: 'application/json',
+        },
+    });
+    if (!response.ok) {
+        if (response.status === 401) {
+            throw new Error('Invalid API key');
+        }
+        if (response.status === 403) {
+            throw new Error('User lacks admin privileges');
+        }
+        if (response.status === 400) {
+            const errorData = (await response.json());
+            throw new Error(errorData.error || 'Bad request');
+        }
+        if (response.status === 429) {
+            throw new Error('MOZ API rate limit exceeded. Please try again later.');
+        }
+        if (response.status === 502) {
+            const errorData = (await response.json());
+            throw new Error(errorData.error || 'MOZ API error');
+        }
+        throw new Error(`Failed to fetch MOZ backlinks: ${response.status} ${response.statusText}`);
+    }
+    const data = (await response.json());
+    return data.data;
+}

package/shared/pulsemcp-admin-client/lib/get-moz-metrics.d.ts

@@ -0,0 +1,6 @@
+import type { MozMetricsResponse } from '../../types.js';
+export declare function getMozMetrics(apiKey: string, baseUrl: string, params: {
+    url: string;
+    scope?: 'url' | 'domain' | 'subdomain';
+}): Promise<MozMetricsResponse>;
+//# sourceMappingURL=get-moz-metrics.d.ts.map

package/shared/pulsemcp-admin-client/lib/get-moz-metrics.js

@@ -0,0 +1,36 @@
+export async function getMozMetrics(apiKey, baseUrl, params) {
+    const apiUrl = new URL('/api/moz/metrics', baseUrl);
+    apiUrl.searchParams.append('url', params.url);
+    if (params.scope) {
+        apiUrl.searchParams.append('scope', params.scope);
+    }
+    const response = await fetch(apiUrl.toString(), {
+        method: 'GET',
+        headers: {
+            'X-API-Key': apiKey,
+            Accept: 'application/json',
+        },
+    });
+    if (!response.ok) {
+        if (response.status === 401) {
+            throw new Error('Invalid API key');
+        }
+        if (response.status === 403) {
+            throw new Error('User lacks admin privileges');
+        }
+        if (response.status === 400) {
+            const errorData = (await response.json());
+            throw new Error(errorData.error || 'Bad request');
+        }
+        if (response.status === 429) {
+            throw new Error('MOZ API rate limit exceeded. Please try again later.');
+        }
+        if (response.status === 502) {
+            const errorData = (await response.json());
+            throw new Error(errorData.error || 'MOZ API error');
+        }
+        throw new Error(`Failed to fetch MOZ metrics: ${response.status} ${response.statusText}`);
+    }
+    const data = (await response.json());
+    return data.data;
+}

package/shared/pulsemcp-admin-client/lib/get-moz-stored-metrics.d.ts

@@ -0,0 +1,8 @@
+import type { MozStoredMetricsResponse } from '../../types.js';
+export declare function getMozStoredMetrics(apiKey: string, baseUrl: string, params: {
+    server_id: string;
+    canonical_id?: number;
+    limit?: number;
+    offset?: number;
+}): Promise<MozStoredMetricsResponse>;
+//# sourceMappingURL=get-moz-stored-metrics.d.ts.map

package/shared/pulsemcp-admin-client/lib/get-moz-stored-metrics.js

@@ -0,0 +1,39 @@
+export async function getMozStoredMetrics(apiKey, baseUrl, params) {
+    const apiUrl = new URL('/api/moz/stored_metrics', baseUrl);
+    apiUrl.searchParams.append('server_id', params.server_id);
+    if (params.canonical_id !== undefined) {
+        apiUrl.searchParams.append('canonical_id', params.canonical_id.toString());
+    }
+    if (params.limit !== undefined) {
+        apiUrl.searchParams.append('limit', params.limit.toString());
+    }
+    if (params.offset !== undefined) {
+        apiUrl.searchParams.append('offset', params.offset.toString());
+    }
+    const response = await fetch(apiUrl.toString(), {
+        method: 'GET',
+        headers: {
+            'X-API-Key': apiKey,
+            Accept: 'application/json',
+        },
+    });
+    if (!response.ok) {
+        if (response.status === 401) {
+            throw new Error('Invalid API key');
+        }
+        if (response.status === 403) {
+            throw new Error('User lacks admin privileges');
+        }
+        if (response.status === 400) {
+            const errorData = (await response.json());
+            throw new Error(errorData.error || 'Bad request');
+        }
+        if (response.status === 404) {
+            const errorData = (await response.json());
+            throw new Error(errorData.error || 'Server not found');
+        }
+        throw new Error(`Failed to fetch MOZ stored metrics: ${response.status} ${response.statusText}`);
+    }
+    const data = (await response.json());
+    return data;
+}

package/shared/pulsemcp-admin-client/lib/upload-image.js

@@ -3,7 +3,7 @@ export async function uploadImage(apiKey, baseUrl, postSlug, fileName, fileData)
     // Create form data for multipart upload
     const formData = new FormData();
     // Create a blob from the buffer
-    const blob = new Blob([fileData], { type: 'image/png' }); // Default to PNG, adjust as needed
+    const blob = new Blob([new Uint8Array(fileData)], { type: 'image/png' });
     // Add file to form data
     formData.append('file', blob, fileName);
     // Add folder and filepath as documented in the API

package/shared/pulsemcp-admin-client/pulsemcp-admin-client.integration-mock.js

@@ -997,5 +997,31 @@ export function createMockPulseMCPAdminClient(mockData) {
                 errored_today: 0,
             };
         },
+        async getMozMetrics() {
+            return {
+                metrics: { page_authority: 50, domain_authority: 60 },
+                raw_response: {},
+                processed_at: new Date().toISOString(),
+            };
+        },
+        async getMozBacklinks() {
+            return {
+                backlinks: [],
+                raw_response: {},
+                processed_at: new Date().toISOString(),
+            };
+        },
+        async getMozStoredMetrics() {
+            return {
+                data: [],
+                meta: {
+                    current_page: 1,
+                    total_pages: 0,
+                    total_count: 0,
+                    has_next: false,
+                    limit: 30,
+                },
+            };
+        },
     };
 }

package/shared/server.d.ts

@@ -1,5 +1,5 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import type { Post, PostsResponse, CreatePostParams, UpdatePostParams, ImageUploadResponse, Author, AuthorsResponse, MCPServer, MCPClient, MCPImplementation, MCPImplementationsResponse, SaveMCPImplementationParams, CreateMCPImplementationParams, Provider, ProvidersResponse, OfficialMirrorQueueStatus, OfficialMirrorQueueResponse, OfficialMirrorQueueItemDetail, OfficialMirrorQueueActionResponse, UnofficialMirror, UnofficialMirrorsResponse, CreateUnofficialMirrorParams, UpdateUnofficialMirrorParams, OfficialMirrorRest, OfficialMirrorsResponse, Tenant, TenantsResponse, McpJson, McpJsonsResponse, CreateMcpJsonParams, UpdateMcpJsonParams, UnifiedMCPServer, UnifiedMCPServersResponse, UpdateUnifiedMCPServerParams, Redirect, RedirectsResponse, RedirectStatus, CreateRedirectParams, UpdateRedirectParams, GoodJob, GoodJobsResponse, GoodJobStatus, GoodJobCronSchedule, GoodJobProcess, GoodJobStatistics, GoodJobActionResponse, GoodJobCleanupResponse, ProctorRunExamParams, ProctorRunExamResponse, ProctorSaveResultsParams, ProctorSaveResultsResponse, ProctorRunsResponse, GetProctorRunsParams, ProctorMetadataResponse, DiscoveredUrlsResponse, MarkDiscoveredUrlProcessedParams, MarkDiscoveredUrlProcessedResponse, DiscoveredUrlStats } from './types.js';
+import type { Post, PostsResponse, CreatePostParams, UpdatePostParams, ImageUploadResponse, Author, AuthorsResponse, MCPServer, MCPClient, MCPImplementation, MCPImplementationsResponse, SaveMCPImplementationParams, CreateMCPImplementationParams, Provider, ProvidersResponse, OfficialMirrorQueueStatus, OfficialMirrorQueueResponse, OfficialMirrorQueueItemDetail, OfficialMirrorQueueActionResponse, UnofficialMirror, UnofficialMirrorsResponse, CreateUnofficialMirrorParams, UpdateUnofficialMirrorParams, OfficialMirrorRest, OfficialMirrorsResponse, Tenant, TenantsResponse, McpJson, McpJsonsResponse, CreateMcpJsonParams, UpdateMcpJsonParams, UnifiedMCPServer, UnifiedMCPServersResponse, UpdateUnifiedMCPServerParams, Redirect, RedirectsResponse, RedirectStatus, CreateRedirectParams, UpdateRedirectParams, GoodJob, GoodJobsResponse, GoodJobStatus, GoodJobCronSchedule, GoodJobProcess, GoodJobStatistics, GoodJobActionResponse, GoodJobCleanupResponse, ProctorRunExamParams, ProctorRunExamResponse, ProctorSaveResultsParams, ProctorSaveResultsResponse, ProctorRunsResponse, GetProctorRunsParams, ProctorMetadataResponse, DiscoveredUrlsResponse, MarkDiscoveredUrlProcessedParams, MarkDiscoveredUrlProcessedResponse, DiscoveredUrlStats, MozMetricsResponse, MozBacklinksResponse, MozStoredMetricsResponse } from './types.js';
 export interface IPulseMCPAdminClient {
     getPosts(params?: {
         search?: string;
@@ -169,6 +169,21 @@ export interface IPulseMCPAdminClient {
     }): Promise<DiscoveredUrlsResponse>;
     markDiscoveredUrlProcessed(params: MarkDiscoveredUrlProcessedParams): Promise<MarkDiscoveredUrlProcessedResponse>;
     getDiscoveredUrlStats(): Promise<DiscoveredUrlStats>;
+    getMozMetrics(params: {
+        url: string;
+        scope?: 'url' | 'domain' | 'subdomain';
+    }): Promise<MozMetricsResponse>;
+    getMozBacklinks(params: {
+        url: string;
+        scope?: 'url' | 'domain' | 'subdomain';
+        limit?: number;
+    }): Promise<MozBacklinksResponse>;
+    getMozStoredMetrics(params: {
+        server_id: string;
+        canonical_id?: number;
+        limit?: number;
+        offset?: number;
+    }): Promise<MozStoredMetricsResponse>;
 }
 export declare class PulseMCPAdminClient implements IPulseMCPAdminClient {
     private apiKey;
@@ -342,6 +357,21 @@ export declare class PulseMCPAdminClient implements IPulseMCPAdminClient {
     }): Promise<DiscoveredUrlsResponse>;
     markDiscoveredUrlProcessed(params: MarkDiscoveredUrlProcessedParams): Promise<MarkDiscoveredUrlProcessedResponse>;
     getDiscoveredUrlStats(): Promise<DiscoveredUrlStats>;
+    getMozMetrics(params: {
+        url: string;
+        scope?: 'url' | 'domain' | 'subdomain';
+    }): Promise<MozMetricsResponse>;
+    getMozBacklinks(params: {
+        url: string;
+        scope?: 'url' | 'domain' | 'subdomain';
+        limit?: number;
+    }): Promise<MozBacklinksResponse>;
+    getMozStoredMetrics(params: {
+        server_id: string;
+        canonical_id?: number;
+        limit?: number;
+        offset?: number;
+    }): Promise<MozStoredMetricsResponse>;
 }
 export type ClientFactory = () => IPulseMCPAdminClient;
 export interface CreateMCPServerOptions {

package/shared/server.js

@@ -68,6 +68,9 @@ import { getProctorMetadata } from './pulsemcp-admin-client/lib/get-proctor-meta
 import { getDiscoveredUrls } from './pulsemcp-admin-client/lib/get-discovered-urls.js';
 import { markDiscoveredUrlProcessed } from './pulsemcp-admin-client/lib/mark-discovered-url-processed.js';
 import { getDiscoveredUrlStats } from './pulsemcp-admin-client/lib/get-discovered-url-stats.js';
+import { getMozMetrics } from './pulsemcp-admin-client/lib/get-moz-metrics.js';
+import { getMozBacklinks } from './pulsemcp-admin-client/lib/get-moz-backlinks.js';
+import { getMozStoredMetrics } from './pulsemcp-admin-client/lib/get-moz-stored-metrics.js';
 // PulseMCP Admin API client implementation
 export class PulseMCPAdminClient {
     apiKey;
@@ -284,6 +287,16 @@ export class PulseMCPAdminClient {
     async getDiscoveredUrlStats() {
         return getDiscoveredUrlStats(this.apiKey, this.baseUrl);
     }
+    // MOZ REST API methods
+    async getMozMetrics(params) {
+        return getMozMetrics(this.apiKey, this.baseUrl, params);
+    }
+    async getMozBacklinks(params) {
+        return getMozBacklinks(this.apiKey, this.baseUrl, params);
+    }
+    async getMozStoredMetrics(params) {
+        return getMozStoredMetrics(this.apiKey, this.baseUrl, params);
+    }
 }
 export function createMCPServer(options) {
     const server = new Server({

package/shared/tools/get-exam-result.js

@@ -67,9 +67,16 @@ Typical usage:
                 const targetType = typeMap[validatedArgs.section];
                 lines = lines.filter((line) => line.type === targetType);
             }
-            // Filter by mirror_id
+            // Filter by mirror_id — check both top-level and data.mirror_id
+            // since the backend nests mirror_id inside the data payload.
             if (validatedArgs.mirror_id !== undefined) {
-                lines = lines.filter((line) => line.type !== 'exam_result' || line.mirror_id === validatedArgs.mirror_id);
+                lines = lines.filter((line) => {
+                    if (line.type !== 'exam_result')
+                        return true;
+                    const data = line.data;
+                    const mirrorId = line.mirror_id ?? data?.mirror_id;
+                    return mirrorId === validatedArgs.mirror_id;
+                });
             }
             let content = `**Exam Result Details**\n\n`;
             content += `Result ID: ${stored.result_id}\n`;

package/shared/tools/get-moz-backlinks.d.ts

@@ -0,0 +1,41 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import type { ClientFactory } from '../server.js';
+export declare function getMozBacklinks(_server: Server, clientFactory: ClientFactory): {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            url: {
+                type: string;
+                description: "The URL to fetch backlinks for. Must be a valid HTTP/HTTPS URL.";
+            };
+            scope: {
+                type: string;
+                enum: string[];
+                description: "Scope of the backlinks lookup: \"url\" (exact URL, default), \"domain\" (entire root domain), or \"subdomain\" (specific subdomain)";
+            };
+            limit: {
+                type: string;
+                minimum: number;
+                maximum: number;
+                description: "Number of backlinks to return, 1-50. Default: 1";
+            };
+        };
+        required: string[];
+    };
+    handler: (args: unknown) => Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+        isError?: undefined;
+    } | {
+        content: {
+            type: string;
+            text: string;
+        }[];
+        isError: boolean;
+    }>;
+};
+//# sourceMappingURL=get-moz-backlinks.d.ts.map

package/shared/tools/get-moz-backlinks.js

@@ -0,0 +1,102 @@
+import { z } from 'zod';
+const PARAM_DESCRIPTIONS = {
+    url: 'The URL to fetch backlinks for. Must be a valid HTTP/HTTPS URL.',
+    scope: 'Scope of the backlinks lookup: "url" (exact URL, default), "domain" (entire root domain), or "subdomain" (specific subdomain)',
+    limit: 'Number of backlinks to return, 1-50. Default: 1',
+};
+const GetMozBacklinksSchema = z.object({
+    url: z.string().describe(PARAM_DESCRIPTIONS.url),
+    scope: z.enum(['url', 'domain', 'subdomain']).optional().describe(PARAM_DESCRIPTIONS.scope),
+    limit: z.number().min(1).max(50).optional().describe(PARAM_DESCRIPTIONS.limit),
+});
+export function getMozBacklinks(_server, clientFactory) {
+    return {
+        name: 'get_moz_backlinks',
+        description: `Fetch live backlink data from the MOZ API. Returns source pages, anchor text, and domain authority for backlinks pointing to a given URL.
+
+Example response:
+{
+  "backlinks": [
+    {
+      "source_page": "https://other.com/blog",
+      "anchor_text": "example link",
+      "domain_authority": 72
+    }
+  ],
+  "raw_response": { ... },
+  "processed_at": "2026-03-15T12:00:00Z"
+}
+
+Use cases:
+- Discover which sites link to a given MCP server URL
+- Analyze the quality of backlinks (by domain authority)
+- Research link profiles for SEO analysis`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                url: { type: 'string', description: PARAM_DESCRIPTIONS.url },
+                scope: {
+                    type: 'string',
+                    enum: ['url', 'domain', 'subdomain'],
+                    description: PARAM_DESCRIPTIONS.scope,
+                },
+                limit: {
+                    type: 'number',
+                    minimum: 1,
+                    maximum: 50,
+                    description: PARAM_DESCRIPTIONS.limit,
+                },
+            },
+            required: ['url'],
+        },
+        handler: async (args) => {
+            const validatedArgs = GetMozBacklinksSchema.parse(args);
+            const client = clientFactory();
+            try {
+                const response = await client.getMozBacklinks({
+                    url: validatedArgs.url,
+                    scope: validatedArgs.scope,
+                    limit: validatedArgs.limit,
+                });
+                let content = `**MOZ Backlinks for ${validatedArgs.url}**`;
+                if (validatedArgs.scope) {
+                    content += ` (scope: ${validatedArgs.scope})`;
+                }
+                content += '\n\n';
+                if (response.backlinks.length === 0) {
+                    content += 'No backlinks found.\n';
+                }
+                else {
+                    content += `Found ${response.backlinks.length} backlink(s):\n\n`;
+                    for (const [index, backlink] of response.backlinks.entries()) {
+                        content += `${index + 1}. **${backlink.source_page || 'Unknown source'}**\n`;
+                        if (backlink.anchor_text)
+                            content += `   Anchor text: "${backlink.anchor_text}"\n`;
+                        if (backlink.domain_authority !== undefined)
+                            content += `   Domain Authority: ${backlink.domain_authority}\n`;
+                        // Include any additional fields
+                        const knownKeys = ['source_page', 'anchor_text', 'domain_authority'];
+                        const extraKeys = Object.keys(backlink).filter((k) => !knownKeys.includes(k));
+                        for (const key of extraKeys) {
+                            content += `   ${key}: ${JSON.stringify(backlink[key])}\n`;
+                        }
+                        content += '\n';
+                    }
+                }
+                content += `**Processed at:** ${response.processed_at}`;
+                return { content: [{ type: 'text', text: content.trim() }] };
+            }
+            catch (error) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error fetching MOZ backlinks: ${error instanceof Error ? error.message : String(error)}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        },
+    };
+}

package/shared/tools/get-moz-metrics.d.ts

@@ -0,0 +1,35 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import type { ClientFactory } from '../server.js';
+export declare function getMozMetrics(_server: Server, clientFactory: ClientFactory): {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            url: {
+                type: string;
+                description: "The URL to fetch MOZ metrics for. Must be a valid HTTP/HTTPS URL.";
+            };
+            scope: {
+                type: string;
+                enum: string[];
+                description: "Scope of the metrics lookup: \"url\" (exact URL, default), \"domain\" (entire root domain), or \"subdomain\" (specific subdomain)";
+            };
+        };
+        required: string[];
+    };
+    handler: (args: unknown) => Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+        isError?: undefined;
+    } | {
+        content: {
+            type: string;
+            text: string;
+        }[];
+        isError: boolean;
+    }>;
+};
+//# sourceMappingURL=get-moz-metrics.d.ts.map

package/shared/tools/get-moz-metrics.js

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+const PARAM_DESCRIPTIONS = {
+    url: 'The URL to fetch MOZ metrics for. Must be a valid HTTP/HTTPS URL.',
+    scope: 'Scope of the metrics lookup: "url" (exact URL, default), "domain" (entire root domain), or "subdomain" (specific subdomain)',
+};
+const GetMozMetricsSchema = z.object({
+    url: z.string().describe(PARAM_DESCRIPTIONS.url),
+    scope: z.enum(['url', 'domain', 'subdomain']).optional().describe(PARAM_DESCRIPTIONS.scope),
+});
+export function getMozMetrics(_server, clientFactory) {
+    return {
+        name: 'get_moz_metrics',
+        description: `Fetch live URL metrics from the MOZ API. Returns page authority, domain authority, spam score, and link counts for a given URL.
+
+Example response:
+{
+  "metrics": {
+    "page_authority": 88,
+    "domain_authority": 95,
+    "spam_score": 1,
+    "root_domains_to_page": 441855
+  },
+  "raw_response": { ... },
+  "processed_at": "2026-03-15T12:00:00Z"
+}
+
+Use cases:
+- Check the authority and spam score of a URL
+- Compare domain authority across different MCP server websites
+- Evaluate the SEO strength of a page or domain`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                url: { type: 'string', description: PARAM_DESCRIPTIONS.url },
+                scope: {
+                    type: 'string',
+                    enum: ['url', 'domain', 'subdomain'],
+                    description: PARAM_DESCRIPTIONS.scope,
+                },
+            },
+            required: ['url'],
+        },
+        handler: async (args) => {
+            const validatedArgs = GetMozMetricsSchema.parse(args);
+            const client = clientFactory();
+            try {
+                const response = await client.getMozMetrics({
+                    url: validatedArgs.url,
+                    scope: validatedArgs.scope,
+                });
+                let content = `**MOZ Metrics for ${validatedArgs.url}**`;
+                if (validatedArgs.scope) {
+                    content += ` (scope: ${validatedArgs.scope})`;
+                }
+                content += '\n\n';
+                const m = response.metrics;
+                if (m.page_authority !== undefined)
+                    content += `**Page Authority:** ${m.page_authority}\n`;
+                if (m.domain_authority !== undefined)
+                    content += `**Domain Authority:** ${m.domain_authority}\n`;
+                if (m.spam_score !== undefined)
+                    content += `**Spam Score:** ${m.spam_score}\n`;
+                if (m.root_domains_to_page !== undefined)
+                    content += `**Root Domains to Page:** ${m.root_domains_to_page}\n`;
+                content += `\n**Processed at:** ${response.processed_at}\n`;
+                // Include any additional metrics
+                const knownKeys = [
+                    'page_authority',
+                    'domain_authority',
+                    'spam_score',
+                    'root_domains_to_page',
+                ];
+                const extraKeys = Object.keys(m).filter((k) => !knownKeys.includes(k));
+                if (extraKeys.length > 0) {
+                    content += '\n**Additional metrics:**\n';
+                    for (const key of extraKeys) {
+                        content += `- ${key}: ${JSON.stringify(m[key])}\n`;
+                    }
+                }
+                return { content: [{ type: 'text', text: content.trim() }] };
+            }
+            catch (error) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error fetching MOZ metrics: ${error instanceof Error ? error.message : String(error)}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        },
+    };
+}