reporter-mcp 1.0.1

package/dist/api-client.d.ts

@@ -0,0 +1,70 @@
+import type { Config } from './config.js';
+export interface ReportFile {
+    path: string;
+    content: string;
+    content_type?: string;
+}
+export interface DeployRequest {
+    name: string;
+    slug?: string;
+    description?: string;
+    agent_id: string;
+    agent_name?: string;
+    entry_file?: string;
+    tags?: string[];
+    files: ReportFile[];
+}
+export interface UpdateRequest {
+    name?: string;
+    description?: string;
+    tags?: string[];
+    files?: ReportFile[];
+}
+export interface Report {
+    id: string;
+    slug: string;
+    name: string;
+    description: string | null;
+    agent_id: string;
+    agent_name: string | null;
+    created_at: string;
+    updated_at: string;
+    version: number;
+    entry_file: string;
+    file_count: number;
+    total_size_bytes: number;
+    tags: string[];
+}
+export interface FileInfo {
+    path: string;
+    size: number;
+    uploaded: string;
+}
+export declare class ApiClient {
+    private config;
+    constructor(config: Config);
+    private request;
+    deployReport(request: DeployRequest): Promise<{
+        report: Report;
+        url: string;
+    }>;
+    updateReport(slug: string, request: UpdateRequest): Promise<{
+        report: Report;
+        url: string;
+    }>;
+    listReports(options?: {
+        agent_id?: string;
+        search?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        reports: Report[];
+    }>;
+    getReport(slug: string): Promise<{
+        report: Report;
+        files: FileInfo[];
+    }>;
+    deleteReport(slug: string): Promise<{
+        success: boolean;
+    }>;
+}

package/dist/api-client.js

@@ -0,0 +1,51 @@
+export class ApiClient {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async request(path, options = {}) {
+        const url = `${this.config.apiUrl}${path}`;
+        const headers = new Headers(options.headers);
+        headers.set('X-API-Key', this.config.apiKey);
+        headers.set('Content-Type', 'application/json');
+        const response = await fetch(url, {
+            ...options,
+            headers,
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: response.statusText }));
+            throw new Error(error.error || `HTTP ${response.status}`);
+        }
+        return response.json();
+    }
+    async deployReport(request) {
+        return this.request('/api/deploy', {
+            method: 'POST',
+            body: JSON.stringify(request),
+        });
+    }
+    async updateReport(slug, request) {
+        return this.request(`/api/deploy/${slug}`, {
+            method: 'PUT',
+            body: JSON.stringify(request),
+        });
+    }
+    async listReports(options) {
+        const params = new URLSearchParams();
+        for (const [key, value] of Object.entries(options ?? {})) {
+            if (value !== undefined) {
+                params.set(key, String(value));
+            }
+        }
+        const query = params.toString();
+        return this.request(`/api/reports${query ? `?${query}` : ''}`);
+    }
+    async getReport(slug) {
+        return this.request(`/api/reports/${slug}`);
+    }
+    async deleteReport(slug) {
+        return this.request(`/api/reports/${slug}`, {
+            method: 'DELETE',
+        });
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+declare const ConfigSchema: z.ZodObject<{
+    apiKey: z.ZodString;
+    apiUrl: z.ZodString;
+    agentId: z.ZodOptional<z.ZodString>;
+    agentName: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    apiKey: string;
+    apiUrl: string;
+    agentId?: string | undefined;
+    agentName?: string | undefined;
+}, {
+    apiKey: string;
+    apiUrl: string;
+    agentId?: string | undefined;
+    agentName?: string | undefined;
+}>;
+export type Config = z.infer<typeof ConfigSchema>;
+export declare function loadConfig(): Config;
+export {};

package/dist/config.js

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+const ConfigSchema = z.object({
+    apiKey: z.string().min(1, 'REPORTER_API_KEY is required'),
+    apiUrl: z.string().url('REPORTER_API_URL must be a valid URL'),
+    agentId: z.string().optional(),
+    agentName: z.string().optional(),
+});
+export function loadConfig() {
+    const config = {
+        apiKey: process.env.REPORTER_API_KEY || '',
+        apiUrl: process.env.REPORTER_API_URL || '',
+        agentId: process.env.AGENT_ID || '',
+        agentName: process.env.AGENT_NAME,
+    };
+    return ConfigSchema.parse(config);
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,218 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { loadConfig } from './config.js';
+import { ApiClient } from './api-client.js';
+import { deployReportSchema, updateReportSchema, createDeployTool, createUpdateTool, } from './tools/deploy.js';
+import { listReportsSchema, getReportSchema, deleteReportSchema, createListTool, createGetTool, createDeleteTool, } from './tools/reports.js';
+const config = loadConfig();
+const client = new ApiClient(config);
+const deployTool = createDeployTool(client, config);
+const updateTool = createUpdateTool(client);
+const listTool = createListTool(client);
+const getTool = createGetTool(client);
+const deleteTool = createDeleteTool(client);
+const server = new Server({
+    name: 'reporter',
+    version: '1.0.0',
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: 'deploy_report',
+                description: 'Deploy an HTML report to the Reporter hosting system. Provide either HTML content directly or a folder path containing report files. Returns a stable URL for viewing.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        name: {
+                            type: 'string',
+                            description: 'Name of the report',
+                        },
+                        slug: {
+                            type: 'string',
+                            description: 'URL-friendly identifier (auto-generated if not provided)',
+                        },
+                        description: {
+                            type: 'string',
+                            description: 'Description of the report',
+                        },
+                        content: {
+                            type: 'string',
+                            description: 'HTML content string (for single-file reports)',
+                        },
+                        folder_path: {
+                            type: 'string',
+                            description: 'Path to folder containing report files (HTML, CSS, JS, images)',
+                        },
+                        entry_file: {
+                            type: 'string',
+                            description: 'Entry file name (default: index.html)',
+                        },
+                        tags: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Tags for categorization',
+                        },
+                        agent_id: {
+                            type: 'string',
+                            description: 'Unique identifier for the agent deploying this report (e.g., "research-agent", "data-analyzer")',
+                        },
+                        agent_name: {
+                            type: 'string',
+                            description: 'Human-readable name of the agent (e.g., "Research Agent", "Data Analyzer")',
+                        },
+                    },
+                    required: ['name', 'agent_id', 'agent_name'],
+                },
+            },
+            {
+                name: 'update_report',
+                description: 'Update an existing report. The URL remains stable. You can update metadata, content, or both.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        slug: {
+                            type: 'string',
+                            description: 'Slug of the report to update',
+                        },
+                        name: {
+                            type: 'string',
+                            description: 'New name for the report',
+                        },
+                        description: {
+                            type: 'string',
+                            description: 'New description',
+                        },
+                        content: {
+                            type: 'string',
+                            description: 'New HTML content (for single-file update)',
+                        },
+                        folder_path: {
+                            type: 'string',
+                            description: 'Path to folder with new files',
+                        },
+                        tags: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'New tags',
+                        },
+                    },
+                    required: ['slug'],
+                },
+            },
+            {
+                name: 'list_reports',
+                description: 'List all reports, optionally filtered by agent ID or search terms.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        agent_id: {
+                            type: 'string',
+                            description: 'Filter by agent ID',
+                        },
+                        search: {
+                            type: 'string',
+                            description: 'Search in name, description, and tags',
+                        },
+                        limit: {
+                            type: 'number',
+                            description: 'Maximum number of results (default: 50)',
+                        },
+                        offset: {
+                            type: 'number',
+                            description: 'Offset for pagination',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'get_report',
+                description: 'Get detailed information about a specific report, including file list.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        slug: {
+                            type: 'string',
+                            description: 'Slug of the report to retrieve',
+                        },
+                    },
+                    required: ['slug'],
+                },
+            },
+            {
+                name: 'delete_report',
+                description: 'Delete a report and all its associated files.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        slug: {
+                            type: 'string',
+                            description: 'Slug of the report to delete',
+                        },
+                    },
+                    required: ['slug'],
+                },
+            },
+        ],
+    };
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        let result;
+        switch (name) {
+            case 'deploy_report':
+                result = await deployTool(deployReportSchema.parse(args));
+                break;
+            case 'update_report':
+                result = await updateTool(updateReportSchema.parse(args));
+                break;
+            case 'list_reports':
+                result = await listTool(listReportsSchema.parse(args || {}));
+                break;
+            case 'get_report':
+                result = await getTool(getReportSchema.parse(args));
+                break;
+            case 'delete_report':
+                result = await deleteTool(deleteReportSchema.parse(args));
+                break;
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({ error: message }),
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('Reporter MCP server running');
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});

package/dist/tools/deploy.d.ts

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+import type { ApiClient } from '../api-client.js';
+import type { Config } from '../config.js';
+export declare const deployReportSchema: z.ZodObject<{
+    name: z.ZodString;
+    slug: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    content: z.ZodOptional<z.ZodString>;
+    folder_path: z.ZodOptional<z.ZodString>;
+    entry_file: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    agent_id: z.ZodOptional<z.ZodString>;
+    agent_name: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    agent_id?: string | undefined;
+    slug?: string | undefined;
+    description?: string | undefined;
+    content?: string | undefined;
+    folder_path?: string | undefined;
+    entry_file?: string | undefined;
+    tags?: string[] | undefined;
+    agent_name?: string | undefined;
+}, {
+    name: string;
+    agent_id?: string | undefined;
+    slug?: string | undefined;
+    description?: string | undefined;
+    content?: string | undefined;
+    folder_path?: string | undefined;
+    entry_file?: string | undefined;
+    tags?: string[] | undefined;
+    agent_name?: string | undefined;
+}>;
+export declare const updateReportSchema: z.ZodObject<{
+    slug: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    content: z.ZodOptional<z.ZodString>;
+    folder_path: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    slug: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    content?: string | undefined;
+    folder_path?: string | undefined;
+    tags?: string[] | undefined;
+}, {
+    slug: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    content?: string | undefined;
+    folder_path?: string | undefined;
+    tags?: string[] | undefined;
+}>;
+export declare function createDeployTool(client: ApiClient, config: Config): (input: z.infer<typeof deployReportSchema>) => Promise<{
+    success: boolean;
+    report: import("../api-client.js").Report;
+    url: string;
+    message: string;
+}>;
+export declare function createUpdateTool(client: ApiClient): (input: z.infer<typeof updateReportSchema>) => Promise<{
+    success: boolean;
+    report: import("../api-client.js").Report;
+    url: string;
+    message: string;
+}>;

package/dist/tools/deploy.js

@@ -0,0 +1,158 @@
+import { z } from 'zod';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+export const deployReportSchema = z.object({
+    name: z.string().describe('Name of the report'),
+    slug: z.string().optional().describe('URL-friendly identifier (auto-generated if not provided)'),
+    description: z.string().optional().describe('Description of the report'),
+    content: z.string().optional().describe('HTML content string (for single-file reports)'),
+    folder_path: z.string().optional().describe('Path to folder containing report files'),
+    entry_file: z.string().optional().describe('Entry file name (default: index.html)'),
+    tags: z.array(z.string()).optional().describe('Tags for categorization'),
+    agent_id: z.string().optional().describe('Unique identifier for the agent deploying this report'),
+    agent_name: z.string().optional().describe('Human-readable name of the agent'),
+});
+export const updateReportSchema = z.object({
+    slug: z.string().describe('Slug of the report to update'),
+    name: z.string().optional().describe('New name for the report'),
+    description: z.string().optional().describe('New description'),
+    content: z.string().optional().describe('New HTML content (for single-file update)'),
+    folder_path: z.string().optional().describe('Path to folder with new files'),
+    tags: z.array(z.string()).optional().describe('New tags'),
+});
+function getMimeType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const mimeTypes = {
+        '.html': 'text/html',
+        '.css': 'text/css',
+        '.js': 'application/javascript',
+        '.json': 'application/json',
+        '.png': 'image/png',
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.gif': 'image/gif',
+        '.svg': 'image/svg+xml',
+        '.webp': 'image/webp',
+        '.ico': 'image/x-icon',
+        '.woff': 'font/woff',
+        '.woff2': 'font/woff2',
+        '.ttf': 'font/ttf',
+        '.eot': 'application/vnd.ms-fontobject',
+        '.pdf': 'application/pdf',
+    };
+    return mimeTypes[ext] || 'application/octet-stream';
+}
+function isBinaryFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const binaryExtensions = [
+        '.png', '.jpg', '.jpeg', '.gif', '.webp', '.ico',
+        '.woff', '.woff2', '.ttf', '.eot', '.pdf',
+    ];
+    return binaryExtensions.includes(ext);
+}
+async function verifyFolderExists(folderPath) {
+    const resolvedPath = path.resolve(folderPath);
+    try {
+        await fs.access(resolvedPath);
+        return resolvedPath;
+    }
+    catch {
+        throw new Error(`Folder not found: ${resolvedPath}`);
+    }
+}
+async function readFolderFiles(folderPath) {
+    const files = [];
+    async function readDir(dir, basePath = '') {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            const relativePath = path.join(basePath, entry.name);
+            if (entry.isDirectory()) {
+                await readDir(fullPath, relativePath);
+            }
+            else if (entry.isFile()) {
+                const isBinary = isBinaryFile(fullPath);
+                const content = await fs.readFile(fullPath, isBinary ? 'base64' : 'utf-8');
+                files.push({
+                    path: relativePath.replace(/\\/g, '/'),
+                    content: isBinary ? `data:${getMimeType(fullPath)};base64,${content}` : content,
+                    content_type: getMimeType(fullPath),
+                });
+            }
+        }
+    }
+    await readDir(folderPath);
+    return files;
+}
+export function createDeployTool(client, config) {
+    return async (input) => {
+        if (!input.content && !input.folder_path) {
+            throw new Error('Either content or folder_path must be provided');
+        }
+        const entryFile = input.entry_file || 'index.html';
+        let files;
+        if (input.folder_path) {
+            const resolvedPath = await verifyFolderExists(input.folder_path);
+            files = await readFolderFiles(resolvedPath);
+        }
+        else {
+            files = [
+                {
+                    path: entryFile,
+                    content: input.content,
+                    content_type: 'text/html',
+                },
+            ];
+        }
+        const agentId = input.agent_id || config.agentId;
+        if (!agentId) {
+            throw new Error('agent_id is required - provide it as a parameter or set AGENT_ID env var');
+        }
+        const result = await client.deployReport({
+            name: input.name,
+            slug: input.slug,
+            description: input.description,
+            agent_id: agentId,
+            agent_name: input.agent_name || config.agentName,
+            entry_file: entryFile,
+            tags: input.tags,
+            files,
+        });
+        return {
+            success: true,
+            report: result.report,
+            url: result.url,
+            message: `Report "${result.report.name}" deployed successfully. View at: ${result.url}`,
+        };
+    };
+}
+export function createUpdateTool(client) {
+    return async (input) => {
+        let files;
+        if (input.folder_path) {
+            const resolvedPath = await verifyFolderExists(input.folder_path);
+            files = await readFolderFiles(resolvedPath);
+        }
+        else if (input.content) {
+            files = [
+                {
+                    path: 'index.html',
+                    content: input.content,
+                    content_type: 'text/html',
+                },
+            ];
+        }
+        const result = await client.updateReport(input.slug, {
+            name: input.name,
+            description: input.description,
+            tags: input.tags,
+            files,
+        });
+        return {
+            success: true,
+            report: result.report,
+            url: result.url,
+            message: `Report "${result.report.name}" updated successfully (version ${result.report.version}). View at: ${result.url}`,
+        };
+    };
+}

package/dist/tools/reports.d.ts

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import type { ApiClient } from '../api-client.js';
+export declare const listReportsSchema: z.ZodObject<{
+    agent_id: z.ZodOptional<z.ZodString>;
+    search: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    agent_id?: string | undefined;
+    search?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}, {
+    agent_id?: string | undefined;
+    search?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}>;
+export declare const getReportSchema: z.ZodObject<{
+    slug: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    slug: string;
+}, {
+    slug: string;
+}>;
+export declare const deleteReportSchema: z.ZodObject<{
+    slug: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    slug: string;
+}, {
+    slug: string;
+}>;
+export declare function createListTool(client: ApiClient): (input: z.infer<typeof listReportsSchema>) => Promise<{
+    count: number;
+    reports: import("../api-client.js").Report[];
+}>;
+export declare function createGetTool(client: ApiClient): (input: z.infer<typeof getReportSchema>) => Promise<{
+    report: import("../api-client.js").Report;
+    files: import("../api-client.js").FileInfo[];
+}>;
+export declare function createDeleteTool(client: ApiClient): (input: z.infer<typeof deleteReportSchema>) => Promise<{
+    success: boolean;
+    message: string;
+}>;

package/dist/tools/reports.js

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+export const listReportsSchema = z.object({
+    agent_id: z.string().optional().describe('Filter by agent ID'),
+    search: z.string().optional().describe('Search in name, description, and tags'),
+    limit: z.number().optional().describe('Maximum number of results (default: 50)'),
+    offset: z.number().optional().describe('Offset for pagination'),
+});
+export const getReportSchema = z.object({
+    slug: z.string().describe('Slug of the report to retrieve'),
+});
+export const deleteReportSchema = z.object({
+    slug: z.string().describe('Slug of the report to delete'),
+});
+export function createListTool(client) {
+    return async (input) => {
+        const result = await client.listReports(input);
+        return {
+            count: result.reports.length,
+            reports: result.reports,
+        };
+    };
+}
+export function createGetTool(client) {
+    return async (input) => {
+        return client.getReport(input.slug);
+    };
+}
+export function createDeleteTool(client) {
+    return async (input) => {
+        await client.deleteReport(input.slug);
+        return {
+            success: true,
+            message: `Report "${input.slug}" deleted successfully`,
+        };
+    };
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "reporter-mcp",
+  "version": "1.0.1",
+  "type": "module",
+  "description": "MCP server for deploying HTML reports to Reporter hosting system",
+  "main": "dist/index.js",
+  "bin": {
+    "reporter-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/44-pixels/agent-reporter.git"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "start": "node dist/index.js",
+    "dev": "tsx watch src/index.ts"
+  },
+  "keywords": [
+    "mcp",
+    "reporter",
+    "html-reports",
+    "claude",
+    "ai-agents"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.3"
+  }
+}