44reports-mcp 1.0.7

package/dist/api-client.d.ts

@@ -0,0 +1,79 @@
+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 | null;
+    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 | null;
+    file_count: number;
+    total_size_bytes: number;
+    tags: string[];
+}
+export interface FileInfo {
+    path: string;
+    size: number;
+    uploaded: string;
+}
+export interface PulledFile {
+    path: string;
+    content: string;
+    content_type: string;
+    size: number;
+}
+export declare class ApiClient {
+    private readonly 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;
+    }>;
+    pullContextFiles(slug: string, filePaths?: string[]): Promise<{
+        files: PulledFile[];
+    }>;
+}

package/dist/api-client.js

@@ -0,0 +1,59 @@
+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);
+        if (options.body) {
+            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',
+        });
+    }
+    async pullContextFiles(slug, filePaths) {
+        return this.request(`/api/reports/${slug}/pull`, {
+            method: 'POST',
+            body: JSON.stringify({ files: filePaths }),
+        });
+    }
+}

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,46 @@
+import { z } from 'zod';
+const ConfigSchema = z.object({
+    apiKey: z.string().min(1),
+    apiUrl: z.string().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,
+    };
+    const result = ConfigSchema.safeParse(config);
+    if (!result.success) {
+        const missing = [];
+        if (!config.apiKey)
+            missing.push('REPORTER_API_KEY');
+        if (!config.apiUrl)
+            missing.push('REPORTER_API_URL');
+        console.error(`
+╔═══════════════════════════════════════════════════════════════════╗
+║                    Reporter MCP Configuration                      ║
+╠═══════════════════════════════════════════════════════════════════╣
+║  Missing required environment variables:                           ║
+${missing.map(v => `║    - ${v}${' '.repeat(61 - v.length)}║`).join('\n')}
+║                                                                    ║
+║  Add to ~/.claude/settings.json under "mcpServers":               ║
+║                                                                    ║
+║    "reporter": {                                                   ║
+║      "command": "npx",                                             ║
+║      "args": ["reporter-mcp"],                                     ║
+║      "env": {                                                      ║
+║        "REPORTER_API_KEY": "your-api-key",                         ║
+║        "REPORTER_API_URL": "https://reporter.44pixels.workers.dev" ║
+║      }                                                             ║
+║    }                                                               ║
+║                                                                    ║
+║  Get your API key at: https://reporter-directory.pages.dev        ║
+╚═══════════════════════════════════════════════════════════════════╝
+`);
+        process.exit(1);
+    }
+    return result.data;
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,155 @@
+#!/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';
+import { pullContextSchema, createPullTool, } from './tools/pull.js';
+const config = loadConfig();
+const client = new ApiClient(config);
+function prop(type, description, extra = {}) {
+    return { type, description, ...extra };
+}
+const CONTENT_DESC = 'Text content string for single-file deploys. For contexts with multiple files or files larger than a few KB, use folder_path instead.';
+const FOLDER_PATH_DESC = 'RECOMMENDED for most contexts. Uploads all supported files in folder (code, docs, data, images, etc). Supports up to 100MB with 1000 files.';
+const toolDefinitions = [
+    {
+        name: 'deploy_context',
+        description: 'Deploy files to the context repository. Supports any text-based files (code, docs, data, config) and binary files (images, fonts). For simple single-file contexts, use content. For multi-file contexts, use folder_path (recommended). Returns a stable URL for viewing and sharing.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: prop('string', 'Name of the context'),
+                slug: prop('string', 'URL-friendly identifier (auto-generated if not provided)'),
+                description: prop('string', 'Description of the context'),
+                content: prop('string', CONTENT_DESC),
+                content_filename: prop('string', 'Filename for single-content deploys (e.g., "README.md", "data.csv"). Auto-detected if not provided.'),
+                folder_path: prop('string', FOLDER_PATH_DESC),
+                entry_file: prop('string', 'Main file served at the context URL. Auto-detected if not provided (prefers index.html, then README.md). Other files accessible via /r/{slug}/{filename}'),
+                tags: prop('array', 'Tags for categorization', { items: { type: 'string' } }),
+                agent_id: prop('string', 'Unique identifier for the agent deploying this context (e.g., "research-agent", "data-analyzer")'),
+                agent_name: prop('string', 'Human-readable name of the agent (e.g., "Research Agent", "Data Analyzer")'),
+            },
+            required: ['name', 'agent_id', 'agent_name'],
+        },
+        schema: deployReportSchema,
+        handler: createDeployTool(client, config),
+    },
+    {
+        name: 'update_context',
+        description: 'Update an existing context. The URL remains stable. You can update metadata, content, or both.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                slug: prop('string', 'Slug of the context to update'),
+                name: prop('string', 'New name for the context'),
+                description: prop('string', 'New description'),
+                content: prop('string', CONTENT_DESC),
+                content_filename: prop('string', 'Filename for single-content updates (e.g., "README.md"). Auto-detected if not provided.'),
+                folder_path: prop('string', FOLDER_PATH_DESC),
+                tags: prop('array', 'New tags', { items: { type: 'string' } }),
+            },
+            required: ['slug'],
+        },
+        schema: updateReportSchema,
+        handler: createUpdateTool(client),
+    },
+    {
+        name: 'list_contexts',
+        description: 'List all contexts in the repository, optionally filtered by agent ID or search terms.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agent_id: prop('string', 'Filter by agent ID'),
+                search: prop('string', 'Search in name, description, and tags'),
+                limit: prop('number', 'Maximum number of results (default: 50)'),
+                offset: prop('number', 'Offset for pagination'),
+            },
+        },
+        schema: listReportsSchema,
+        handler: createListTool(client),
+    },
+    {
+        name: 'get_context',
+        description: 'Get detailed information about a specific context, including file list.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                slug: prop('string', 'Slug of the context to retrieve'),
+            },
+            required: ['slug'],
+        },
+        schema: getReportSchema,
+        handler: createGetTool(client),
+    },
+    {
+        name: 'delete_context',
+        description: 'Delete a context and all its associated files from the repository.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                slug: prop('string', 'Slug of the context to delete'),
+            },
+            required: ['slug'],
+        },
+        schema: deleteReportSchema,
+        handler: createDeleteTool(client),
+    },
+    {
+        name: 'pull_context',
+        description: 'Pull files from a context repository to a local directory. Accepts a slug or full URL. Writes files to disk preserving directory structure. By default pulls only text files; set include_binary to true for images and other binary files.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                slug: prop('string', 'Slug or full URL of the context (e.g., "my-context" or "https://reporter.44pixels.workers.dev/r/my-context/")'),
+                output_dir: prop('string', 'Local directory to write files to. Will be created if it does not exist.'),
+                files: prop('array', 'Specific files to pull. If omitted, all text files are pulled.', { items: { type: 'string' } }),
+                include_binary: prop('boolean', 'Include binary files (images, fonts, etc). Default: false.'),
+            },
+            required: ['slug', 'output_dir'],
+        },
+        schema: pullContextSchema,
+        handler: createPullTool(client),
+    },
+];
+const toolHandlers = Object.fromEntries(toolDefinitions.map((t) => [t.name, { schema: t.schema, handler: t.handler }]));
+const server = new Server({ name: '44reports', version: '1.0.0' }, { capabilities: { tools: {} } });
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: toolDefinitions.map(({ name, description, inputSchema }) => ({
+        name,
+        description,
+        inputSchema,
+    })),
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        const tool = toolHandlers[name];
+        if (!tool) {
+            throw new Error(`Unknown tool: ${name}`);
+        }
+        const parsedArgs = tool.schema.parse(args ?? {});
+        const result = await tool.handler(parsedArgs);
+        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('44reports MCP server running');
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});

package/dist/tools/deploy.d.ts

@@ -0,0 +1,85 @@
+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>;
+    content_filename: 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;
+    content_filename?: 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;
+    content_filename?: 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>;
+    content_filename: 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;
+    content_filename?: string | undefined;
+    folder_path?: string | undefined;
+    tags?: string[] | undefined;
+}, {
+    slug: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    content?: string | undefined;
+    content_filename?: string | undefined;
+    folder_path?: string | undefined;
+    tags?: string[] | undefined;
+}>;
+export declare function getMimeType(filePath: string): string;
+export declare function shouldIgnoreFile(name: string): boolean;
+export declare function autoDetectEntryFile(files: {
+    path: string;
+}[]): string | null;
+export declare function createDeployTool(client: ApiClient, config: Config): (input: z.infer<typeof deployReportSchema>) => Promise<{
+    success: boolean;
+    report: import("../api-client.js").Report;
+    url: string;
+    files_uploaded: number;
+    total_size_bytes: number;
+    total_size_formatted: 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;
+    files_uploaded: number;
+    total_size_bytes: number;
+    total_size_formatted: string;
+    message: string;
+}>;

package/dist/tools/deploy.js

@@ -0,0 +1,285 @@
+import { z } from 'zod';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+// Limits (must match server-side limits)
+const MAX_FILES = 1000;
+const MAX_TOTAL_SIZE = 100 * 1024 * 1024; // 100MB
+const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10MB per file
+// Non-hidden system files to ignore when reading folders
+const IGNORED_FILES = new Set([
+    'Thumbs.db',
+    'desktop.ini',
+]);
+// Extension-to-MIME mapping (also serves as the set of allowed extensions)
+const MIME_TYPES = {
+    // Web
+    '.html': 'text/html',
+    '.htm': 'text/html',
+    '.css': 'text/css',
+    '.js': 'application/javascript',
+    '.json': 'application/json',
+    // Images & fonts
+    '.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',
+    // Text & documentation
+    '.md': 'text/markdown',
+    '.txt': 'text/plain',
+    '.rst': 'text/x-rst',
+    '.log': 'text/plain',
+    // Code
+    '.ts': 'text/typescript',
+    '.tsx': 'text/typescript',
+    '.jsx': 'text/javascript',
+    '.py': 'text/x-python',
+    '.sh': 'text/x-shellscript',
+    '.bash': 'text/x-shellscript',
+    '.mjs': 'application/javascript',
+    '.cjs': 'application/javascript',
+    '.r': 'text/x-r',
+    '.rb': 'text/x-ruby',
+    '.go': 'text/x-go',
+    '.rs': 'text/x-rust',
+    '.java': 'text/x-java',
+    '.c': 'text/x-c',
+    '.cpp': 'text/x-c++',
+    '.h': 'text/x-c',
+    // Config & data
+    '.yaml': 'text/yaml',
+    '.yml': 'text/yaml',
+    '.toml': 'text/toml',
+    '.csv': 'text/csv',
+    '.tsv': 'text/tab-separated-values',
+    '.xml': 'application/xml',
+    '.sql': 'text/x-sql',
+    '.ini': 'text/plain',
+    '.cfg': 'text/plain',
+    '.conf': 'text/plain',
+    // Notebooks
+    '.ipynb': 'application/x-ipynb+json',
+};
+export const deployReportSchema = z.object({
+    name: z.string().describe('Name of the context'),
+    slug: z.string().optional().describe('URL-friendly identifier (auto-generated if not provided)'),
+    description: z.string().optional().describe('Description of the context'),
+    content: z.string().optional().describe('Text content string for single-file deploys. Use folder_path for multi-file contexts or files larger than a few KB.'),
+    content_filename: z.string().optional().describe('Filename for single-content deploys (e.g., "README.md", "data.csv"). Auto-detected if not provided.'),
+    folder_path: z.string().optional().describe('Absolute path to folder containing context files. All supported files in the folder will be uploaded. Recommended for most contexts.'),
+    entry_file: z.string().optional().describe('The main file to serve at the context URL. Auto-detected if not provided (prefers index.html, then README.md).'),
+    tags: z.array(z.string()).optional().describe('Tags for categorization'),
+    agent_id: z.string().optional().describe('Unique identifier for the agent deploying this context'),
+    agent_name: z.string().optional().describe('Human-readable name of the agent'),
+});
+export const updateReportSchema = z.object({
+    slug: z.string().describe('Slug of the context to update'),
+    name: z.string().optional().describe('New name for the context'),
+    description: z.string().optional().describe('New description'),
+    content: z.string().optional().describe('New content (for single-file update)'),
+    content_filename: z.string().optional().describe('Filename for single-content updates (e.g., "README.md"). Auto-detected if not provided.'),
+    folder_path: z.string().optional().describe('Path to folder with new files'),
+    tags: z.array(z.string()).optional().describe('New tags'),
+});
+export function getMimeType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return MIME_TYPES[ext] || 'application/octet-stream';
+}
+const BINARY_EXTENSIONS = new Set([
+    '.png', '.jpg', '.jpeg', '.gif', '.webp', '.ico',
+    '.woff', '.woff2', '.ttf', '.eot', '.pdf',
+]);
+function isBinaryFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return BINARY_EXTENSIONS.has(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}`);
+    }
+}
+export function shouldIgnoreFile(name) {
+    if (IGNORED_FILES.has(name))
+        return true;
+    if (name.startsWith('.'))
+        return true;
+    if (name.endsWith('~'))
+        return true;
+    const ext = path.extname(name).toLowerCase();
+    return ext !== '' && !(ext in MIME_TYPES);
+}
+function formatSize(bytes) {
+    if (bytes > 1024 * 1024) {
+        return `${(bytes / 1024 / 1024).toFixed(2)}MB`;
+    }
+    return `${(bytes / 1024).toFixed(1)}KB`;
+}
+function validateContentSize(content) {
+    const size = Buffer.byteLength(content, 'utf-8');
+    if (size > MAX_FILE_SIZE) {
+        throw new Error(`Content too large (${formatSize(size)}). Use folder_path instead for large files.`);
+    }
+    return size;
+}
+function detectContentFilename(content, explicitFilename) {
+    if (explicitFilename)
+        return explicitFilename;
+    const trimmed = content.trimStart();
+    if (trimmed.startsWith('<'))
+        return 'index.html';
+    return 'content.md';
+}
+function createSingleFileReport(content, filename) {
+    return [{
+            path: filename,
+            content,
+            content_type: getMimeType(filename),
+        }];
+}
+async function readFolderFiles(folderPath) {
+    const files = [];
+    let totalSize = 0;
+    async function readDir(dir, basePath = '') {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (shouldIgnoreFile(entry.name))
+                continue;
+            const fullPath = path.join(dir, entry.name);
+            const relativePath = path.join(basePath, entry.name);
+            if (entry.isDirectory()) {
+                await readDir(fullPath, relativePath);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            if (files.length >= MAX_FILES) {
+                throw new Error(`Too many files in folder (max ${MAX_FILES})`);
+            }
+            const stat = await fs.stat(fullPath);
+            if (stat.size > MAX_FILE_SIZE) {
+                throw new Error(`File too large: ${relativePath} (${formatSize(stat.size)}, max ${formatSize(MAX_FILE_SIZE)})`);
+            }
+            totalSize += stat.size;
+            if (totalSize > MAX_TOTAL_SIZE) {
+                throw new Error(`Total size exceeds limit (max ${formatSize(MAX_TOTAL_SIZE)})`);
+            }
+            const isBinary = isBinaryFile(fullPath);
+            const content = await fs.readFile(fullPath, isBinary ? 'base64' : 'utf-8');
+            const mimeType = getMimeType(fullPath);
+            files.push({
+                path: relativePath.replace(/\\/g, '/'),
+                content: isBinary ? `data:${mimeType};base64,${content}` : content,
+                content_type: mimeType,
+            });
+        }
+    }
+    await readDir(folderPath);
+    return { files, totalSize };
+}
+export function autoDetectEntryFile(files) {
+    const paths = files.map(f => f.path);
+    if (paths.includes('index.html'))
+        return 'index.html';
+    const htmlFiles = paths.filter(p => p.endsWith('.html') || p.endsWith('.htm'));
+    if (htmlFiles.length === 1)
+        return htmlFiles[0];
+    if (paths.includes('README.md'))
+        return 'README.md';
+    return null;
+}
+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. Use folder_path for multi-file contexts or files larger than a few KB.');
+        }
+        let entryFile;
+        let files;
+        let totalSize;
+        if (input.folder_path) {
+            const resolvedPath = await verifyFolderExists(input.folder_path);
+            const result = await readFolderFiles(resolvedPath);
+            files = result.files;
+            totalSize = result.totalSize;
+            if (files.length === 0) {
+                throw new Error('No supported files found in folder.');
+            }
+            entryFile = input.entry_file || autoDetectEntryFile(files);
+            if (entryFile && !files.some(f => f.path === entryFile)) {
+                throw new Error(`Entry file "${entryFile}" not found in folder. Available files: ${files.map(f => f.path).join(', ')}`);
+            }
+        }
+        else {
+            totalSize = validateContentSize(input.content);
+            const filename = detectContentFilename(input.content, input.content_filename);
+            files = createSingleFileReport(input.content, filename);
+            entryFile = input.entry_file || filename;
+        }
+        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,
+            files_uploaded: files.length,
+            total_size_bytes: totalSize,
+            total_size_formatted: formatSize(totalSize),
+            message: `Context "${result.report.name}" deployed successfully. View at: ${result.url}`,
+        };
+    };
+}
+export function createUpdateTool(client) {
+    return async (input) => {
+        let files;
+        let totalSize = 0;
+        if (input.folder_path) {
+            const resolvedPath = await verifyFolderExists(input.folder_path);
+            const result = await readFolderFiles(resolvedPath);
+            files = result.files;
+            totalSize = result.totalSize;
+        }
+        else if (input.content) {
+            totalSize = validateContentSize(input.content);
+            const filename = detectContentFilename(input.content, input.content_filename);
+            files = createSingleFileReport(input.content, filename);
+        }
+        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,
+            files_uploaded: files?.length ?? 0,
+            total_size_bytes: totalSize,
+            total_size_formatted: formatSize(totalSize),
+            message: `Context "${result.report.name}" updated successfully (version ${result.report.version}). View at: ${result.url}`,
+        };
+    };
+}

package/dist/tools/deploy.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/deploy.test.js

@@ -0,0 +1,182 @@
+import { deployReportSchema, updateReportSchema, shouldIgnoreFile, autoDetectEntryFile } from './deploy.js';
+describe('deployReportSchema', () => {
+    it('requires name field', () => {
+        const result = deployReportSchema.safeParse({});
+        expect(result.success).toBe(false);
+    });
+    it('accepts valid input with content', () => {
+        const result = deployReportSchema.safeParse({
+            name: 'Test Report',
+            content: '<html><body>Hello</body></html>',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts valid input with folder_path', () => {
+        const result = deployReportSchema.safeParse({
+            name: 'Test Report',
+            folder_path: '/path/to/folder',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts optional fields', () => {
+        const result = deployReportSchema.safeParse({
+            name: 'Test Report',
+            content: '<html></html>',
+            slug: 'test-report',
+            description: 'A test report',
+            tags: ['test', 'demo'],
+            agent_id: 'agent-123',
+            agent_name: 'Test Agent',
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.slug).toBe('test-report');
+            expect(result.data.tags).toEqual(['test', 'demo']);
+        }
+    });
+    it('accepts content_filename parameter', () => {
+        const result = deployReportSchema.safeParse({
+            name: 'My Notes',
+            content: '# Hello World',
+            content_filename: 'README.md',
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.content_filename).toBe('README.md');
+        }
+    });
+    it('accepts non-HTML content', () => {
+        const result = deployReportSchema.safeParse({
+            name: 'Python Script',
+            content: 'print("hello")',
+            content_filename: 'main.py',
+        });
+        expect(result.success).toBe(true);
+    });
+});
+describe('updateReportSchema', () => {
+    it('requires slug field', () => {
+        const result = updateReportSchema.safeParse({});
+        expect(result.success).toBe(false);
+    });
+    it('accepts valid update with content', () => {
+        const result = updateReportSchema.safeParse({
+            slug: 'test-report',
+            content: '<html><body>Updated</body></html>',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts partial updates', () => {
+        const result = updateReportSchema.safeParse({
+            slug: 'test-report',
+            name: 'Updated Name',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts content_filename parameter', () => {
+        const result = updateReportSchema.safeParse({
+            slug: 'test-report',
+            content: '# Updated notes',
+            content_filename: 'notes.md',
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.content_filename).toBe('notes.md');
+        }
+    });
+});
+describe('shouldIgnoreFile', () => {
+    it('ignores .DS_Store', () => {
+        expect(shouldIgnoreFile('.DS_Store')).toBe(true);
+    });
+    it('ignores hidden files starting with dot', () => {
+        expect(shouldIgnoreFile('.gitignore')).toBe(true);
+        expect(shouldIgnoreFile('.env')).toBe(true);
+        expect(shouldIgnoreFile('.hidden')).toBe(true);
+    });
+    it('ignores backup files ending with ~', () => {
+        expect(shouldIgnoreFile('file.html~')).toBe(true);
+        expect(shouldIgnoreFile('backup~')).toBe(true);
+    });
+    it('allows text and documentation files', () => {
+        expect(shouldIgnoreFile('readme.md')).toBe(false);
+        expect(shouldIgnoreFile('data.txt')).toBe(false);
+        expect(shouldIgnoreFile('notes.rst')).toBe(false);
+        expect(shouldIgnoreFile('output.log')).toBe(false);
+    });
+    it('allows code files', () => {
+        expect(shouldIgnoreFile('script.py')).toBe(false);
+        expect(shouldIgnoreFile('app.ts')).toBe(false);
+        expect(shouldIgnoreFile('component.tsx')).toBe(false);
+        expect(shouldIgnoreFile('component.jsx')).toBe(false);
+        expect(shouldIgnoreFile('main.go')).toBe(false);
+        expect(shouldIgnoreFile('lib.rs')).toBe(false);
+        expect(shouldIgnoreFile('App.java')).toBe(false);
+        expect(shouldIgnoreFile('main.c')).toBe(false);
+        expect(shouldIgnoreFile('main.cpp')).toBe(false);
+        expect(shouldIgnoreFile('header.h')).toBe(false);
+        expect(shouldIgnoreFile('script.rb')).toBe(false);
+        expect(shouldIgnoreFile('analysis.r')).toBe(false);
+        expect(shouldIgnoreFile('setup.sh')).toBe(false);
+        expect(shouldIgnoreFile('deploy.bash')).toBe(false);
+        expect(shouldIgnoreFile('utils.mjs')).toBe(false);
+        expect(shouldIgnoreFile('config.cjs')).toBe(false);
+    });
+    it('allows config and data files', () => {
+        expect(shouldIgnoreFile('config.yaml')).toBe(false);
+        expect(shouldIgnoreFile('config.yml')).toBe(false);
+        expect(shouldIgnoreFile('settings.toml')).toBe(false);
+        expect(shouldIgnoreFile('data.csv')).toBe(false);
+        expect(shouldIgnoreFile('data.tsv')).toBe(false);
+        expect(shouldIgnoreFile('feed.xml')).toBe(false);
+        expect(shouldIgnoreFile('query.sql')).toBe(false);
+        expect(shouldIgnoreFile('settings.ini')).toBe(false);
+        expect(shouldIgnoreFile('app.cfg')).toBe(false);
+        expect(shouldIgnoreFile('nginx.conf')).toBe(false);
+    });
+    it('allows notebook files', () => {
+        expect(shouldIgnoreFile('analysis.ipynb')).toBe(false);
+    });
+    it('allows web files', () => {
+        expect(shouldIgnoreFile('index.html')).toBe(false);
+        expect(shouldIgnoreFile('styles.css')).toBe(false);
+        expect(shouldIgnoreFile('app.js')).toBe(false);
+        expect(shouldIgnoreFile('logo.png')).toBe(false);
+        expect(shouldIgnoreFile('data.json')).toBe(false);
+    });
+    it('ignores system files', () => {
+        expect(shouldIgnoreFile('Thumbs.db')).toBe(true);
+        expect(shouldIgnoreFile('desktop.ini')).toBe(true);
+    });
+    it('ignores unsupported file types', () => {
+        expect(shouldIgnoreFile('archive.zip')).toBe(true);
+        expect(shouldIgnoreFile('binary.exe')).toBe(true);
+        expect(shouldIgnoreFile('movie.mp4')).toBe(true);
+    });
+});
+describe('autoDetectEntryFile', () => {
+    it('returns index.html if present', () => {
+        const files = [{ path: 'README.md' }, { path: 'index.html' }, { path: 'style.css' }];
+        expect(autoDetectEntryFile(files)).toBe('index.html');
+    });
+    it('returns single HTML file if only one exists', () => {
+        const files = [{ path: 'report.html' }, { path: 'data.csv' }];
+        expect(autoDetectEntryFile(files)).toBe('report.html');
+    });
+    it('returns README.md if no HTML files', () => {
+        const files = [{ path: 'README.md' }, { path: 'main.py' }, { path: 'data.csv' }];
+        expect(autoDetectEntryFile(files)).toBe('README.md');
+    });
+    it('returns null if no suitable entry file', () => {
+        const files = [{ path: 'main.py' }, { path: 'data.csv' }];
+        expect(autoDetectEntryFile(files)).toBeNull();
+    });
+    it('returns null if multiple HTML files and no index.html', () => {
+        const files = [{ path: 'page1.html' }, { path: 'page2.html' }];
+        expect(autoDetectEntryFile(files)).toBeNull();
+    });
+    it('prefers index.html over README.md', () => {
+        const files = [{ path: 'README.md' }, { path: 'index.html' }];
+        expect(autoDetectEntryFile(files)).toBe('index.html');
+    });
+});

package/dist/tools/pull.d.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import type { ApiClient } from '../api-client.js';
+export declare const pullContextSchema: z.ZodObject<{
+    slug: z.ZodString;
+    output_dir: z.ZodString;
+    files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    include_binary: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    slug: string;
+    output_dir: string;
+    files?: string[] | undefined;
+    include_binary?: boolean | undefined;
+}, {
+    slug: string;
+    output_dir: string;
+    files?: string[] | undefined;
+    include_binary?: boolean | undefined;
+}>;
+export declare function extractSlug(slugOrUrl: string): string;
+export declare function isTextContentType(contentType: string): boolean;
+export declare function createPullTool(client: ApiClient): (input: z.infer<typeof pullContextSchema>) => Promise<{
+    context: {
+        name: string;
+        slug: string;
+        description: string | null;
+        version: number;
+    };
+    files_pulled: number;
+    output_dir: string;
+    files: {
+        path: string;
+        size: number;
+    }[];
+}>;

package/dist/tools/pull.js

@@ -0,0 +1,77 @@
+import { z } from 'zod';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+export const pullContextSchema = z.object({
+    slug: z.string().describe('Slug or full URL of the context to pull (e.g., "my-context" or "https://reporter.44pixels.workers.dev/r/my-context/")'),
+    output_dir: z.string().describe('Local directory to write files to. Will be created if it does not exist.'),
+    files: z.array(z.string()).optional().describe('Specific files to pull. If omitted, all text files are pulled.'),
+    include_binary: z.boolean().optional().describe('Include binary files (images, fonts, etc). Default: false.'),
+});
+export function extractSlug(slugOrUrl) {
+    const match = slugOrUrl.match(/\/r\/([^/]+)/);
+    if (match)
+        return match[1];
+    return slugOrUrl;
+}
+const BINARY_CONTENT_TYPES = new Set([
+    'image/png', 'image/jpeg', 'image/gif', 'image/webp', 'image/x-icon',
+    'font/woff', 'font/woff2', 'font/ttf', 'application/vnd.ms-fontobject',
+    'application/pdf', 'application/octet-stream',
+]);
+export function isTextContentType(contentType) {
+    return !BINARY_CONTENT_TYPES.has(contentType);
+}
+export function createPullTool(client) {
+    return async (input) => {
+        const slug = extractSlug(input.slug);
+        const outputDir = path.resolve(input.output_dir);
+        const { report, files: fileList } = await client.getReport(slug);
+        let filePaths = fileList.map(f => f.path);
+        if (input.files && input.files.length > 0) {
+            const available = new Set(filePaths);
+            const missing = input.files.filter(f => !available.has(f));
+            if (missing.length > 0) {
+                throw new Error(`Files not found in context: ${missing.join(', ')}`);
+            }
+            filePaths = input.files;
+        }
+        const { files: pulledFiles } = await client.pullContextFiles(slug, filePaths);
+        const filesToWrite = input.include_binary
+            ? pulledFiles
+            : pulledFiles.filter(f => isTextContentType(f.content_type));
+        await fs.mkdir(outputDir, { recursive: true });
+        const writtenFiles = [];
+        const resolvedOutputDir = path.resolve(outputDir);
+        for (const file of filesToWrite) {
+            const filePath = path.join(outputDir, file.path);
+            const resolvedFilePath = path.resolve(filePath);
+            if (!resolvedFilePath.startsWith(resolvedOutputDir + path.sep) && resolvedFilePath !== resolvedOutputDir) {
+                throw new Error(`Unsafe file path rejected: ${file.path}`);
+            }
+            await fs.mkdir(path.dirname(filePath), { recursive: true });
+            if (file.content.startsWith('data:')) {
+                const commaIndex = file.content.indexOf(',');
+                if (commaIndex === -1) {
+                    throw new Error(`Invalid data URI format for file: ${file.path}`);
+                }
+                const base64Data = file.content.slice(commaIndex + 1);
+                await fs.writeFile(filePath, Buffer.from(base64Data, 'base64'));
+            }
+            else {
+                await fs.writeFile(filePath, file.content, 'utf-8');
+            }
+            writtenFiles.push({ path: file.path, size: file.size });
+        }
+        return {
+            context: {
+                name: report.name,
+                slug: report.slug,
+                description: report.description,
+                version: report.version,
+            },
+            files_pulled: writtenFiles.length,
+            output_dir: outputDir,
+            files: writtenFiles,
+        };
+    };
+}

package/dist/tools/pull.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/pull.test.js

@@ -0,0 +1,108 @@
+import * as path from 'path';
+import { pullContextSchema, extractSlug, isTextContentType } from './pull.js';
+describe('pullContextSchema', () => {
+    it('requires slug and output_dir', () => {
+        const result = pullContextSchema.safeParse({});
+        expect(result.success).toBe(false);
+    });
+    it('accepts valid input with slug and output_dir', () => {
+        const result = pullContextSchema.safeParse({
+            slug: 'my-context',
+            output_dir: '/tmp/output',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts optional files array', () => {
+        const result = pullContextSchema.safeParse({
+            slug: 'my-context',
+            output_dir: '/tmp/output',
+            files: ['README.md', 'src/main.py'],
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.files).toEqual(['README.md', 'src/main.py']);
+        }
+    });
+    it('accepts optional include_binary flag', () => {
+        const result = pullContextSchema.safeParse({
+            slug: 'my-context',
+            output_dir: '/tmp/output',
+            include_binary: true,
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.include_binary).toBe(true);
+        }
+    });
+    it('accepts full URL as slug', () => {
+        const result = pullContextSchema.safeParse({
+            slug: 'https://reporter.44pixels.workers.dev/r/my-context/',
+            output_dir: '/tmp/output',
+        });
+        expect(result.success).toBe(true);
+    });
+});
+describe('extractSlug', () => {
+    it('extracts slug from full URL', () => {
+        expect(extractSlug('https://reporter.44pixels.workers.dev/r/my-context/')).toBe('my-context');
+    });
+    it('extracts slug from URL without trailing slash', () => {
+        expect(extractSlug('https://reporter.44pixels.workers.dev/r/my-context')).toBe('my-context');
+    });
+    it('extracts slug from URL with subpath', () => {
+        expect(extractSlug('https://reporter.44pixels.workers.dev/r/my-context/index.html')).toBe('my-context');
+    });
+    it('returns bare slug as-is', () => {
+        expect(extractSlug('my-context')).toBe('my-context');
+    });
+    it('returns slug with hyphens and numbers', () => {
+        expect(extractSlug('report-2024-01')).toBe('report-2024-01');
+    });
+});
+describe('path traversal safety', () => {
+    it('rejects paths with directory traversal', () => {
+        const outputDir = '/tmp/test-output';
+        const maliciousPath = '../../etc/passwd';
+        const resolved = path.resolve(path.join(outputDir, maliciousPath));
+        const resolvedOutput = path.resolve(outputDir);
+        expect(resolved.startsWith(resolvedOutput + path.sep)).toBe(false);
+    });
+    it('allows safe nested paths', () => {
+        const outputDir = '/tmp/test-output';
+        const safePath = 'src/lib/utils.ts';
+        const resolved = path.resolve(path.join(outputDir, safePath));
+        const resolvedOutput = path.resolve(outputDir);
+        expect(resolved.startsWith(resolvedOutput + path.sep)).toBe(true);
+    });
+    it('rejects paths with encoded traversal', () => {
+        const outputDir = '/tmp/test-output';
+        // Even sneaky traversal like 'foo/../../etc/passwd' is caught
+        const maliciousPath = 'foo/../../etc/passwd';
+        const resolved = path.resolve(path.join(outputDir, maliciousPath));
+        const resolvedOutput = path.resolve(outputDir);
+        expect(resolved.startsWith(resolvedOutput + path.sep)).toBe(false);
+    });
+});
+describe('isTextContentType', () => {
+    it('returns true for text content types', () => {
+        expect(isTextContentType('text/html')).toBe(true);
+        expect(isTextContentType('text/markdown')).toBe(true);
+        expect(isTextContentType('text/plain')).toBe(true);
+        expect(isTextContentType('text/css')).toBe(true);
+        expect(isTextContentType('text/yaml')).toBe(true);
+        expect(isTextContentType('text/x-python')).toBe(true);
+        expect(isTextContentType('application/javascript')).toBe(true);
+        expect(isTextContentType('application/json')).toBe(true);
+        expect(isTextContentType('application/xml')).toBe(true);
+        expect(isTextContentType('text/typescript')).toBe(true);
+    });
+    it('returns false for binary content types', () => {
+        expect(isTextContentType('image/png')).toBe(false);
+        expect(isTextContentType('image/jpeg')).toBe(false);
+        expect(isTextContentType('image/gif')).toBe(false);
+        expect(isTextContentType('font/woff')).toBe(false);
+        expect(isTextContentType('font/woff2')).toBe(false);
+        expect(isTextContentType('application/pdf')).toBe(false);
+        expect(isTextContentType('application/octet-stream')).toBe(false);
+    });
+});

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,28 @@
+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 { reports } = await client.listReports(input);
+        return { count: reports.length, reports };
+    };
+}
+export function createGetTool(client) {
+    return async (input) => 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/dist/tools/reports.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/reports.test.js

@@ -0,0 +1,40 @@
+import { listReportsSchema, getReportSchema, deleteReportSchema } from './reports.js';
+describe('listReportsSchema', () => {
+    it('accepts empty input', () => {
+        const result = listReportsSchema.safeParse({});
+        expect(result.success).toBe(true);
+    });
+    it('accepts all optional filters', () => {
+        const result = listReportsSchema.safeParse({
+            agent_id: 'agent-123',
+            search: 'test query',
+            limit: 10,
+            offset: 20,
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.limit).toBe(10);
+            expect(result.data.offset).toBe(20);
+        }
+    });
+});
+describe('getReportSchema', () => {
+    it('requires slug', () => {
+        const result = getReportSchema.safeParse({});
+        expect(result.success).toBe(false);
+    });
+    it('accepts valid slug', () => {
+        const result = getReportSchema.safeParse({ slug: 'my-report' });
+        expect(result.success).toBe(true);
+    });
+});
+describe('deleteReportSchema', () => {
+    it('requires slug', () => {
+        const result = deleteReportSchema.safeParse({});
+        expect(result.success).toBe(false);
+    });
+    it('accepts valid slug', () => {
+        const result = deleteReportSchema.safeParse({ slug: 'my-report' });
+        expect(result.success).toBe(true);
+    });
+});

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "44reports-mcp",
+  "version": "1.0.7",
+  "type": "module",
+  "description": "MCP server for deploying and pulling context files (code, docs, data) to/from 44reports",
+  "main": "dist/index.js",
+  "bin": {
+    "44reports-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",
+    "test": "NODE_OPTIONS='--experimental-vm-modules' npx jest",
+    "test:watch": "NODE_OPTIONS='--experimental-vm-modules' npx jest --watch"
+  },
+  "keywords": [
+    "mcp",
+    "reporter",
+    "context-repository",
+    "claude",
+    "ai-agents",
+    "cross-session-memory"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@types/node": "^20.11.0",
+    "jest": "^30.2.0",
+    "ts-jest": "^29.4.6",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.3"
+  }
+}