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

package/README.md

@@ -95,6 +95,14 @@ This server is built and tested on macOS with Claude Desktop. It should work wit
 | `run_exam_for_mirror`                  | proctor            | write      | Run proctor exams against unofficial mirrors via Fly Machines. Returns truncated summary with `result_id`. |
 | `get_exam_result`                      | proctor            | read       | Retrieve full untruncated exam results by `result_id`, with optional section/mirror filtering.             |
 | `save_results_for_mirror`              | proctor            | write      | Save proctor exam results via `result_id` from `run_exam_for_mirror`.                                      |
+| `list_proctor_runs`                    | proctor            | read       | List proctor runs with filtering by name, recommended status, and tenant IDs.                              |
+| `get_proctor_metadata`                 | proctor            | read       | Get available proctor runtimes and exam types.                                                             |
+| `list_discovered_urls`                 | discovered_urls    | read       | List discovered URLs with status filtering and pagination.                                                 |
+| `mark_discovered_url_processed`        | discovered_urls    | write      | Mark a discovered URL as processed with a result status.                                                   |
+| `get_discovered_url_stats`             | discovered_urls    | read       | Get summary statistics for discovered URLs pipeline.                                                       |
+| `get_moz_metrics`                      | moz                | read       | Fetch live URL metrics from the MOZ API (page authority, domain authority, spam score, link counts).       |
+| `get_moz_backlinks`                    | moz                | read       | Fetch live backlink data from the MOZ API (source pages, anchor text, domain authority).                   |
+| `get_moz_stored_metrics`               | moz                | read       | List stored/historical MOZ data for a server's canonicals with pagination.                                 |
 
 # Tool Groups
 
@@ -127,8 +135,12 @@ This server organizes tools into groups that can be selectively enabled or disab
 | `redirects_readonly`          | 2     | URL redirects read-only (list, get)                                                                                                                                         |
 | `good_jobs`                   | 10    | Full GoodJob background job management (read + write)                                                                                                                       |
 | `good_jobs_readonly`          | 5     | GoodJob read-only (list, get, stats, processes, cron)                                                                                                                       |
-| `proctor`                     | 3     | Proctor exam execution, result retrieval, and result storage (read + write)                                                                                                 |
-| `proctor_readonly`            | 1     | Proctor results read-only (`get_exam_result`)                                                                                                                               |
+| `proctor`                     | 5     | Proctor exam execution, result retrieval, and result storage (read + write)                                                                                                 |
+| `proctor_readonly`            | 3     | Proctor results read-only (`get_exam_result`, `list_proctor_runs`, `get_proctor_metadata`)                                                                                  |
+| `discovered_urls`             | 3     | Discovered URL management (read + write)                                                                                                                                    |
+| `discovered_urls_readonly`    | 2     | Discovered URL tools read-only (list, stats)                                                                                                                                |
+| `moz`                         | 3     | MOZ SEO metrics — live URL metrics, backlinks, and stored historical data (all read-only)                                                                                   |
+| `moz_readonly`                | 3     | MOZ tools read-only (alias — all MOZ tools are read-only)                                                                                                                   |
 
 ### Tools by Group
 
@@ -161,14 +173,19 @@ This server organizes tools into groups that can be selectively enabled or disab
   - Read-only: `list_good_jobs`, `get_good_job`, `list_good_job_cron_schedules`, `list_good_job_processes`, `get_good_job_queue_statistics`
   - Write: `retry_good_job`, `discard_good_job`, `reschedule_good_job`, `force_trigger_good_job_cron`, `cleanup_good_jobs`
 - **proctor** / **proctor_readonly**:
-  - Read-only: `get_exam_result`
+  - Read-only: `get_exam_result`, `list_proctor_runs`, `get_proctor_metadata`
   - Write: `run_exam_for_mirror`, `save_results_for_mirror`
+- **discovered_urls** / **discovered_urls_readonly**:
+  - Read-only: `list_discovered_urls`, `get_discovered_url_stats`
+  - Write: `mark_discovered_url_processed`
+- **moz** / **moz_readonly**:
+  - Read-only: `get_moz_metrics`, `get_moz_backlinks`, `get_moz_stored_metrics`
 
 ## Environment Variables
 
-| Variable      | Description                                 | Default                                                                                                                                                      |
-| ------------- | ------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `TOOL_GROUPS` | Comma-separated list of enabled tool groups | `newsletter,server_directory,official_queue,unofficial_mirrors,official_mirrors,tenants,mcp_jsons,mcp_servers,redirects,good_jobs,proctor` (all base groups) |
+| Variable      | Description                                 | Default                                                                                                                                                                          |
+| ------------- | ------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `TOOL_GROUPS` | Comma-separated list of enabled tool groups | `newsletter,server_directory,official_queue,unofficial_mirrors,official_mirrors,tenants,mcp_jsons,mcp_servers,redirects,good_jobs,proctor,discovered_urls,moz` (all base groups) |
 
 ## Examples
 
@@ -193,7 +210,7 @@ TOOL_GROUPS=server_directory_readonly
 Enable all groups with read-only access:
 
 ```bash
-TOOL_GROUPS=newsletter_readonly,server_directory_readonly,official_queue_readonly,unofficial_mirrors_readonly,official_mirrors_readonly,tenants_readonly,mcp_jsons_readonly,mcp_servers_readonly,redirects_readonly,good_jobs_readonly,proctor_readonly
+TOOL_GROUPS=newsletter_readonly,server_directory_readonly,official_queue_readonly,unofficial_mirrors_readonly,official_mirrors_readonly,tenants_readonly,mcp_jsons_readonly,mcp_servers_readonly,redirects_readonly,good_jobs_readonly,proctor_readonly,discovered_urls_readonly,moz_readonly
 ```
 
 Note: `proctor_readonly` includes only `get_exam_result` for retrieving stored results. `notifications` has no readonly variant since sending emails is always a write operation.

package/build/shared/src/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/build/shared/src/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/build/shared/src/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/build/shared/src/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/build/shared/src/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/build/shared/src/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/build/shared/src/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/build/shared/src/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/build/shared/src/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/build/shared/src/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,
+                };
+            }
+        },
+    };
+}

package/build/shared/src/tools/get-moz-stored-metrics.js

@@ -0,0 +1,119 @@
+import { z } from 'zod';
+const PARAM_DESCRIPTIONS = {
+    server_id: 'MCP server ID (numeric) or slug to fetch stored MOZ data for',
+    canonical_id: 'Optional canonical ID to filter results to a specific canonical URL',
+    limit: 'Results per page, range 1-100. Default: 30',
+    offset: 'Pagination offset. Default: 0',
+};
+const GetMozStoredMetricsSchema = z.object({
+    server_id: z.string().describe(PARAM_DESCRIPTIONS.server_id),
+    canonical_id: z.number().optional().describe(PARAM_DESCRIPTIONS.canonical_id),
+    limit: z.number().min(1).max(100).optional().describe(PARAM_DESCRIPTIONS.limit),
+    offset: z.number().min(0).optional().describe(PARAM_DESCRIPTIONS.offset),
+});
+export function getMozStoredMetrics(_server, clientFactory) {
+    return {
+        name: 'get_moz_stored_metrics',
+        description: `List stored/historical MOZ data for a server's canonicals. Returns MOZ metrics that were previously collected and stored, ordered by timestamp descending (newest first).
+
+Example response:
+{
+  "data": [
+    {
+      "id": 123,
+      "canonical_id": 456,
+      "canonical_url": "https://example.com/mcp",
+      "scope": "url",
+      "timestamp": "2026-03-01T00:00:00Z",
+      "triggered_by": "weekly_collection",
+      "page_authority": 42,
+      "root_domains_to_page": 100,
+      "site_metrics": { ... },
+      "created_at": "2026-03-01T00:05:00Z"
+    }
+  ],
+  "meta": {
+    "current_page": 1,
+    "total_pages": 3,
+    "total_count": 75,
+    "has_next": true,
+    "limit": 30
+  }
+}
+
+Use cases:
+- View historical MOZ metrics for an MCP server over time
+- Track page authority changes for a server's canonical URLs
+- Compare metrics across different canonicals for the same server`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                server_id: { type: 'string', description: PARAM_DESCRIPTIONS.server_id },
+                canonical_id: { type: 'number', description: PARAM_DESCRIPTIONS.canonical_id },
+                limit: {
+                    type: 'number',
+                    minimum: 1,
+                    maximum: 100,
+                    description: PARAM_DESCRIPTIONS.limit,
+                },
+                offset: { type: 'number', minimum: 0, description: PARAM_DESCRIPTIONS.offset },
+            },
+            required: ['server_id'],
+        },
+        handler: async (args) => {
+            const validatedArgs = GetMozStoredMetricsSchema.parse(args);
+            const client = clientFactory();
+            try {
+                const response = await client.getMozStoredMetrics({
+                    server_id: validatedArgs.server_id,
+                    canonical_id: validatedArgs.canonical_id,
+                    limit: validatedArgs.limit,
+                    offset: validatedArgs.offset,
+                });
+                let content = `**Stored MOZ Metrics for server "${validatedArgs.server_id}"**`;
+                if (validatedArgs.canonical_id !== undefined) {
+                    content += ` (canonical ID: ${validatedArgs.canonical_id})`;
+                }
+                content += '\n\n';
+                const { meta } = response;
+                content += `Page ${meta.current_page} of ${meta.total_pages} (${meta.total_count} total records)\n\n`;
+                if (response.data.length === 0) {
+                    content += 'No stored MOZ data found.\n';
+                }
+                else {
+                    for (const [index, record] of response.data.entries()) {
+                        content += `${index + 1}. **${record.canonical_url}** (ID: ${record.id})\n`;
+                        content += `   Canonical ID: ${record.canonical_id}`;
+                        if (record.scope)
+                            content += ` | Scope: ${record.scope}`;
+                        content += '\n';
+                        content += `   Timestamp: ${record.timestamp} | Triggered by: ${record.triggered_by}\n`;
+                        if (record.page_authority !== undefined)
+                            content += `   Page Authority: ${record.page_authority}\n`;
+                        if (record.root_domains_to_page !== undefined)
+                            content += `   Root Domains to Page: ${record.root_domains_to_page}\n`;
+                        if (record.site_metrics && Object.keys(record.site_metrics).length > 0) {
+                            content += `   Site Metrics: ${JSON.stringify(record.site_metrics)}\n`;
+                        }
+                        content += '\n';
+                    }
+                }
+                if (meta.has_next) {
+                    content += `_More results available. Use offset=${meta.current_page * meta.limit} to get the next page._`;
+                }
+                return { content: [{ type: 'text', text: content.trim() }] };
+            }
+            catch (error) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error fetching stored MOZ metrics: ${error instanceof Error ? error.message : String(error)}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        },
+    };
+}

package/build/shared/src/tools/run-exam-for-mirror.js

@@ -131,13 +131,15 @@ Use cases:
                             }
                             break;
                         }
-                        case 'summary':
+                        case 'summary': {
+                            const summaryData = line.data;
                             content += `\n**Summary**\n`;
-                            content += `  Total: ${line.total || 0}\n`;
-                            content += `  Passed: ${line.passed || 0}\n`;
-                            content += `  Failed: ${line.failed || 0}\n`;
-                            content += `  Skipped: ${line.skipped || 0}\n`;
+                            content += `  Total: ${summaryData?.total_exams ?? line.total ?? 0}\n`;
+                            content += `  Passed: ${summaryData?.successful ?? line.passed ?? 0}\n`;
+                            content += `  Failed: ${summaryData?.failed ?? line.failed ?? 0}\n`;
+                            content += `  Skipped: ${summaryData?.skipped ?? line.skipped ?? 0}\n`;
                             break;
+                        }
                         case 'error':
                             content += `\n**Error**: ${line.message || line.error || JSON.stringify(line)}\n`;
                             break;