44reports-mcp 1.2.0 → 1.3.0

package/dist/api-client.js

@@ -16,7 +16,11 @@ export class ApiClient {
         });
         if (!response.ok) {
             const error = await response.json().catch(() => ({ error: response.statusText }));
-            throw new Error(error.error || `HTTP ${response.status}`);
+            const message = error.error || `HTTP ${response.status}`;
+            if (response.status === 401) {
+                throw new Error(`${message}. Reporter token rejected. Generate or rotate yours at ${this.config.apiUrl.replace('reporter.44pixels.workers.dev', 'reporter-directory.pages.dev')} → Settings, then update REPORTER_API_KEY in your Claude config and restart Claude Code.`);
+            }
+            throw new Error(message);
         }
         return response.json();
     }

package/dist/index.js

@@ -9,6 +9,7 @@ import { listReportsSchema, getReportSchema, deleteReportSchema, createListTool,
 import { pullContextSchema, createPullTool, } from './tools/pull.js';
 import { manageFoldersSchema, createManageFoldersTool, } from './tools/folders.js';
 import { listProductsSchema, getProductSchema, readProductFileSchema, updateProductKnowledgeSchema, uploadProductFilesSchema, pullProductFilesSchema, createProductSchema, deleteProductSchema, deleteProductFileSchema, getProductHealthSchema, getProductIndexSchema, createListProductsTool, createGetProductTool, createReadProductFileTool, createUpdateProductKnowledgeTool, createUploadProductFilesTool, createPullProductFilesTool, createGetProductHealthTool, createGetProductIndexTool, createCreateProductTool, createDeleteProductTool, createDeleteProductFileTool, } from './tools/products.js';
+import { createUploadProductDirectoryTool, uploadProductDirectorySchema, UPLOAD_DIRECTORY_DESCRIPTION, } from './tools/upload-directory.js';
 import { addToBacklogSchema, listBacklogSchema, processBacklogSchema, createAddToBacklogTool, createListBacklogTool, createProcessBacklogTool, } from './tools/backlog.js';
 const config = loadConfig();
 const client = new ApiClient(config);
@@ -196,7 +197,12 @@ const toolDefinitions = [
     },
     {
         name: 'upload_product_files',
-        description: 'Upload files to a product — binary assets or Markdown knowledge docs. Files are organized into sections:\n\nBinary assets:\n- brand-assets/ — logos, brand book PDFs, color swatches\n- store-listings/ — App Store / Play Store screenshots and preview videos\n- assets/ — ad creatives, icons, campaign videos\n\nMarkdown docs (use these prefixes for knowledge documents):\n- docs/research/ — user research, competitive analysis, hypotheses, GTM strategy, roadmap\n- docs/brand/ — brand voice, positioning\n- docs/copy/ — copy guidelines, messaging\n- docs/advertising/ — campaign briefs, ad copy\n- docs/app-store/ — store listing copy, metadata',
+        description: 'Upload one or more files to a product. For multiple files in a directory, prefer ' +
+            'upload_product_directory.\n\n' +
+            'Place files at media/<domain>/ for binaries, docs/<domain>/ for markdown:\n' +
+            '  media/brand/, media/product-research/, media/copy/, media/advertising/, media/app-store/\n' +
+            '  docs/brand/, docs/research/, docs/copy/, docs/advertising/, docs/app-store/\n\n' +
+            'Pass content as a LOCAL PATH (preferred), a base64 data URI, or plain text.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -218,6 +224,31 @@ const toolDefinitions = [
         schema: uploadProductFilesSchema,
         handler: createUploadProductFilesTool(client),
     },
+    {
+        name: 'upload_product_directory',
+        description: UPLOAD_DIRECTORY_DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                slug: prop('string', 'Product slug'),
+                local_dir: prop('string', 'Absolute or relative path to the local directory to upload'),
+                domain: {
+                    type: 'string',
+                    enum: ['product-research', 'brand', 'copy', 'advertising', 'app-store'],
+                    description: 'Product domain — determines target folder (media/<domain>/)',
+                },
+                dest_prefix: prop('string', 'Subpath under media/<domain>/. Defaults to basename of local_dir.'),
+                glob: prop('string', 'Include filter, e.g. "**/*.{png,jpg,mp4}". Default: "**/*".'),
+                exclude: prop('array', 'Exclude patterns. Default: [".*", "**/.*", "node_modules/**"].', {
+                    items: { type: 'string' },
+                }),
+                dry_run: prop('boolean', 'If true, returns the planned uploads without sending. Default: false.'),
+            },
+            required: ['slug', 'local_dir', 'domain'],
+        },
+        schema: uploadProductDirectorySchema,
+        handler: createUploadProductDirectoryTool(client),
+    },
     {
         name: 'pull_product_files',
         description: 'Download files from a product to a local directory. By default pulls binary assets (logos, screenshots, videos). Set include_knowledge to also pull JSON config files. To pull markdown docs, specify their paths in the files array (e.g., ["docs/research/user-research.md"]).',

package/dist/tools/domains.d.ts

@@ -0,0 +1,2 @@
+export declare const DOMAIN_VALUES: readonly ["product-research", "brand", "copy", "advertising", "app-store"];
+export type Domain = (typeof DOMAIN_VALUES)[number];

package/dist/tools/domains.js

@@ -0,0 +1 @@
+export const DOMAIN_VALUES = ['product-research', 'brand', 'copy', 'advertising', 'app-store'];

package/dist/tools/products.js

@@ -2,11 +2,11 @@ import { z } from 'zod';
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import { getMimeType } from './deploy.js';
+import { DOMAIN_VALUES } from './domains.js';
 // --- Schemas ---
 export const listProductsSchema = z.object({
     search: z.string().optional().describe('Search term to filter products by name or description'),
 });
-const DOMAIN_VALUES = ['product-research', 'brand', 'copy', 'advertising', 'app-store'];
 export const getProductSchema = z.object({
     slug: z.string().describe('Product slug'),
     domain: z.enum(DOMAIN_VALUES).optional().describe('Filter files by domain'),
@@ -25,7 +25,13 @@ export const uploadProductFilesSchema = z.object({
     slug: z.string().describe('Product slug'),
     files: z.array(z.object({
         path: z.string().describe('File path within the product (e.g., "docs/research/user-research.md", "brand-assets/logo.png")'),
-        content: z.string().describe('File content as text or base64 data URI (e.g., "data:image/png;base64,...")'),
+        content: z
+            .string()
+            .describe('File content. Three input modes:\n' +
+            '  • LOCAL PATH (preferred): "/abs/path/to/logo.png" or "./relative/path"\n' +
+            '  • Base64 data URI: "data:image/png;base64,..."\n' +
+            '  • Plain text (for small text files)\n' +
+            'Use a local path whenever possible — base64 inline blows up your context for any non-tiny file.'),
         content_type: z.string().optional().describe('MIME type (auto-detected if not provided)'),
     })).describe('Files to upload'),
 });

package/dist/tools/upload-directory.d.ts

@@ -0,0 +1,91 @@
+import { z } from 'zod';
+import type { ApiClient } from '../api-client.js';
+export declare const uploadProductDirectorySchema: z.ZodObject<{
+    slug: z.ZodString;
+    local_dir: z.ZodString;
+    domain: z.ZodEnum<["product-research", "brand", "copy", "advertising", "app-store"]>;
+    dest_prefix: z.ZodOptional<z.ZodString>;
+    glob: z.ZodOptional<z.ZodString>;
+    exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    dry_run: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    slug: string;
+    domain: "product-research" | "brand" | "copy" | "advertising" | "app-store";
+    local_dir: string;
+    dry_run?: boolean | undefined;
+    dest_prefix?: string | undefined;
+    glob?: string | undefined;
+    exclude?: string[] | undefined;
+}, {
+    slug: string;
+    domain: "product-research" | "brand" | "copy" | "advertising" | "app-store";
+    local_dir: string;
+    dry_run?: boolean | undefined;
+    dest_prefix?: string | undefined;
+    glob?: string | undefined;
+    exclude?: string[] | undefined;
+}>;
+export declare const UPLOAD_DIRECTORY_DESCRIPTION: string;
+export interface FileEntry {
+    localPath: string;
+    relativePath: string;
+    size: number;
+}
+export interface DestinationEntry extends FileEntry {
+    destPath: string;
+    contentType: string;
+}
+export interface WalkOptions {
+    glob: string;
+    exclude: string[];
+}
+export declare const DEFAULT_EXCLUDES: string[];
+export declare function walkDirectory(absDir: string, options: WalkOptions): Promise<FileEntry[]>;
+export interface DestinationOptions {
+    domain: string;
+    destPrefix: string;
+}
+export declare function computeDestinations(entries: FileEntry[], options: DestinationOptions): DestinationEntry[];
+export interface Sized {
+    size: number;
+}
+export interface BatchLimits {
+    maxFiles: number;
+    maxBytes: number;
+}
+export declare function batchByLimits<T extends Sized>(items: T[], limits: BatchLimits): T[][];
+export declare function createUploadProductDirectoryTool(client: ApiClient): (input: z.infer<typeof uploadProductDirectorySchema>) => Promise<{
+    dry_run: boolean;
+    total_files: number;
+    total_bytes: number;
+    files: {
+        local_path: string;
+        dest_path: string;
+        size: number;
+        content_type: string;
+    }[];
+    skipped_too_large: {
+        local_path: string;
+        size: number;
+        limit: number;
+    }[];
+    uploaded?: undefined;
+    failed?: undefined;
+} | {
+    dry_run: boolean;
+    total_files: number;
+    total_bytes: number;
+    uploaded: {
+        local_path: string;
+        dest_path: string;
+        size: number;
+        content_type: string;
+    }[];
+    failed: {
+        local_path: string;
+        dest_path: string;
+        error: string;
+    }[];
+    files?: undefined;
+    skipped_too_large?: undefined;
+}>;

package/dist/tools/upload-directory.js

@@ -0,0 +1,191 @@
+import { z } from 'zod';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+import { minimatch } from 'minimatch';
+import { getMimeType } from './deploy.js';
+import { DOMAIN_VALUES } from './domains.js';
+function expandHome(p) {
+    if (p === '~')
+        return os.homedir();
+    if (p.startsWith('~/'))
+        return path.join(os.homedir(), p.slice(2));
+    return p;
+}
+export const uploadProductDirectorySchema = z.object({
+    slug: z.string().describe('Product slug, e.g. "clara"'),
+    local_dir: z.string().describe('Absolute or relative path to the local directory to upload. ~/ is expanded to the home directory.'),
+    domain: z.enum(DOMAIN_VALUES).describe('Product domain — determines target folder (media/<domain>/)'),
+    dest_prefix: z
+        .string()
+        .optional()
+        .describe('Subpath under media/<domain>/. Defaults to the basename of local_dir.'),
+    glob: z.string().optional().describe('Include filter, e.g. "**/*.{png,jpg,mp4}". Default: "**/*".'),
+    exclude: z
+        .array(z.string())
+        .optional()
+        .describe('Exclude patterns. Default: [".*", "**/.*", "node_modules/**"].'),
+    dry_run: z.boolean().optional().describe('If true, return the planned uploads without sending. Default: false.'),
+});
+export const UPLOAD_DIRECTORY_DESCRIPTION = 'Upload an entire directory of files (images, videos, PDFs) into a product\'s media folder. ' +
+    'Preferred over upload_product_files when you have multiple files on disk.\n\n' +
+    'Files land at media/<domain>/<dest_prefix>/<relative-path>. dest_prefix defaults to the basename of local_dir.\n\n' +
+    'Example: upload_product_directory({slug:"clara", local_dir:"./screenshots", domain:"product-research", dest_prefix:"ux-screenshots"}) ' +
+    '→ files at clara/media/product-research/ux-screenshots/*\n\n' +
+    'Limits: 10MB per file (oversized files are reported as failed, not blocking). Auto-batches into chunks ≤90MB to stay under server limits. Total upload size is unbounded.';
+export const DEFAULT_EXCLUDES = ['.*', '**/.*', 'node_modules/**'];
+export async function walkDirectory(absDir, options) {
+    const entries = [];
+    async function recurse(currentAbs, currentRel) {
+        const items = await fs.readdir(currentAbs, { withFileTypes: true });
+        for (const item of items) {
+            const itemAbs = path.join(currentAbs, item.name);
+            const itemRel = currentRel ? `${currentRel}/${item.name}` : item.name;
+            if (options.exclude.some((pattern) => minimatch(itemRel, pattern, { dot: true })))
+                continue;
+            if (item.isDirectory()) {
+                await recurse(itemAbs, itemRel);
+            }
+            else if (item.isFile()) {
+                if (!minimatch(itemRel, options.glob, { dot: true }))
+                    continue;
+                const stat = await fs.stat(itemAbs);
+                entries.push({ localPath: itemAbs, relativePath: itemRel, size: stat.size });
+            }
+        }
+    }
+    await recurse(absDir, '');
+    return entries.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+}
+export function computeDestinations(entries, options) {
+    const prefix = options.destPrefix
+        ? `media/${options.domain}/${options.destPrefix}`
+        : `media/${options.domain}`;
+    return entries.map((e) => {
+        if (e.relativePath.split('/').includes('..')) {
+            throw new Error(`refusing to compute destination for path containing "..": ${e.relativePath}`);
+        }
+        return {
+            ...e,
+            destPath: `${prefix}/${e.relativePath}`,
+            contentType: getMimeType(e.localPath),
+        };
+    });
+}
+export function batchByLimits(items, limits) {
+    const batches = [];
+    let currentBatch = [];
+    let currentBytes = 0;
+    for (const item of items) {
+        if (currentBatch.length >= limits.maxFiles ||
+            (currentBatch.length > 0 && currentBytes + item.size > limits.maxBytes)) {
+            batches.push(currentBatch);
+            currentBatch = [];
+            currentBytes = 0;
+        }
+        currentBatch.push(item);
+        currentBytes += item.size;
+    }
+    if (currentBatch.length > 0)
+        batches.push(currentBatch);
+    return batches;
+}
+const PER_FILE_LIMIT = 10 * 1024 * 1024;
+const BATCH_BYTES = 90 * 1024 * 1024;
+const BATCH_FILES = 95;
+export function createUploadProductDirectoryTool(client) {
+    return async (input) => {
+        const absDir = path.resolve(expandHome(input.local_dir));
+        const stat = await fs.stat(absDir).catch(() => null);
+        if (!stat || !stat.isDirectory()) {
+            throw new Error(`local_dir not found or not a directory: ${absDir}`);
+        }
+        const destPrefix = input.dest_prefix ?? path.basename(absDir);
+        const glob = input.glob ?? '**/*';
+        const exclude = input.exclude ?? DEFAULT_EXCLUDES;
+        const entries = await walkDirectory(absDir, { glob, exclude });
+        const destinations = computeDestinations(entries, { domain: input.domain, destPrefix });
+        const oversized = destinations.filter((d) => d.size > PER_FILE_LIMIT);
+        const sized = destinations.filter((d) => d.size <= PER_FILE_LIMIT);
+        const totalBytes = sized.reduce((sum, d) => sum + d.size, 0);
+        if (input.dry_run) {
+            return {
+                dry_run: true,
+                total_files: destinations.length,
+                total_bytes: totalBytes,
+                files: sized.map((d) => ({
+                    local_path: d.localPath,
+                    dest_path: d.destPath,
+                    size: d.size,
+                    content_type: d.contentType,
+                })),
+                skipped_too_large: oversized.map((d) => ({
+                    local_path: d.localPath,
+                    size: d.size,
+                    limit: PER_FILE_LIMIT,
+                })),
+            };
+        }
+        const batches = batchByLimits(sized, { maxFiles: BATCH_FILES, maxBytes: BATCH_BYTES });
+        const uploaded = [];
+        const failed = oversized.map((d) => ({
+            local_path: d.localPath,
+            dest_path: d.destPath,
+            error: `exceeds per-file limit (${(d.size / 1024 / 1024).toFixed(1)}MB > ${PER_FILE_LIMIT / 1024 / 1024}MB)`,
+        }));
+        for (const batch of batches) {
+            const reads = await Promise.all(batch.map(async (d) => {
+                try {
+                    const base64 = await fs.readFile(d.localPath, { encoding: 'base64' });
+                    return {
+                        ok: true,
+                        dest: d,
+                        file: {
+                            path: d.destPath,
+                            content: `data:${d.contentType};base64,${base64}`,
+                            content_type: d.contentType,
+                        },
+                    };
+                }
+                catch (e) {
+                    return {
+                        ok: false,
+                        dest: d,
+                        error: e instanceof Error ? e.message : String(e),
+                    };
+                }
+            }));
+            for (const r of reads) {
+                if (!r.ok)
+                    failed.push({ local_path: r.dest.localPath, dest_path: r.dest.destPath, error: r.error });
+            }
+            const successfulReads = reads.filter((r) => r.ok);
+            if (successfulReads.length === 0)
+                continue;
+            try {
+                await client.uploadProductFiles(input.slug, successfulReads.map((r) => r.file));
+                for (const r of successfulReads) {
+                    uploaded.push({
+                        local_path: r.dest.localPath,
+                        dest_path: r.dest.destPath,
+                        size: r.dest.size,
+                        content_type: r.dest.contentType,
+                    });
+                }
+            }
+            catch (e) {
+                const error = e instanceof Error ? e.message : String(e);
+                for (const r of successfulReads) {
+                    failed.push({ local_path: r.dest.localPath, dest_path: r.dest.destPath, error });
+                }
+            }
+        }
+        return {
+            dry_run: false,
+            total_files: destinations.length,
+            total_bytes: totalBytes,
+            uploaded,
+            failed,
+        };
+    };
+}

package/dist/tools/upload-directory.test.d.ts

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

package/dist/tools/upload-directory.test.js

@@ -0,0 +1,173 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+import { walkDirectory, computeDestinations, batchByLimits, } from './upload-directory.js';
+async function makeTempDir(structure) {
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'upload-test-'));
+    for (const [rel, content] of Object.entries(structure)) {
+        const abs = path.join(dir, rel);
+        await fs.mkdir(path.dirname(abs), { recursive: true });
+        await fs.writeFile(abs, content);
+    }
+    return dir;
+}
+describe('walkDirectory', () => {
+    it('returns absolute paths and sizes for regular files', async () => {
+        const dir = await makeTempDir({
+            'a.txt': 'hello',
+            'sub/b.png': Buffer.alloc(10),
+        });
+        const entries = await walkDirectory(dir, { glob: '**/*', exclude: [] });
+        expect(entries).toHaveLength(2);
+        const a = entries.find((e) => e.localPath.endsWith('a.txt'));
+        expect(a.size).toBe(5);
+        expect(a.relativePath).toBe('a.txt');
+        const b = entries.find((e) => e.localPath.endsWith('b.png'));
+        expect(b.size).toBe(10);
+        expect(b.relativePath).toBe('sub/b.png');
+    });
+    it('applies glob filtering', async () => {
+        const dir = await makeTempDir({
+            'logo.png': Buffer.alloc(1),
+            'README.md': 'doc',
+            'sub/icon.svg': '<svg/>',
+        });
+        const entries = await walkDirectory(dir, { glob: '**/*.{png,svg}', exclude: [] });
+        expect(entries.map((e) => e.relativePath).sort()).toEqual(['logo.png', 'sub/icon.svg']);
+    });
+    it('applies excludes', async () => {
+        const dir = await makeTempDir({
+            'logo.png': Buffer.alloc(1),
+            '.DS_Store': Buffer.alloc(1),
+            'node_modules/x.js': '',
+        });
+        const entries = await walkDirectory(dir, {
+            glob: '**/*',
+            exclude: ['.*', '**/.*', 'node_modules/**'],
+        });
+        expect(entries.map((e) => e.relativePath)).toEqual(['logo.png']);
+    });
+});
+describe('computeDestinations', () => {
+    const entry = (relativePath, size = 1) => ({
+        localPath: '/tmp/x/' + relativePath,
+        relativePath,
+        size,
+    });
+    it('places files under media/<domain>/<destPrefix>/', () => {
+        const dest = computeDestinations([entry('logo.png'), entry('sub/icon.svg')], { domain: 'brand', destPrefix: 'logos' });
+        expect(dest.map((d) => d.destPath)).toEqual([
+            'media/brand/logos/logo.png',
+            'media/brand/logos/sub/icon.svg',
+        ]);
+    });
+    it('omits destPrefix when empty', () => {
+        const dest = computeDestinations([entry('logo.png')], { domain: 'brand', destPrefix: '' });
+        expect(dest[0].destPath).toBe('media/brand/logo.png');
+    });
+    it('attaches mime type via getMimeType', () => {
+        const dest = computeDestinations([entry('logo.png')], { domain: 'brand', destPrefix: '' });
+        expect(dest[0].contentType).toBe('image/png');
+    });
+    it('rejects relative paths containing ..', () => {
+        expect(() => computeDestinations([entry('../escape.png')], { domain: 'brand', destPrefix: '' })).toThrow(/containing ".."/);
+    });
+});
+describe('batchByLimits', () => {
+    const item = (size) => ({ size, dummy: true });
+    it('groups items so each batch is <= maxFiles and <= maxBytes', () => {
+        const items = [item(40 * 1024 * 1024), item(40 * 1024 * 1024), item(20 * 1024 * 1024)];
+        const batches = batchByLimits(items, { maxFiles: 100, maxBytes: 90 * 1024 * 1024 });
+        expect(batches.length).toBe(2);
+        expect(batches[0].length).toBe(2);
+        expect(batches[1].length).toBe(1);
+    });
+    it('starts a new batch when adding the next file would exceed maxBytes', () => {
+        const items = [item(80 * 1024 * 1024), item(20 * 1024 * 1024)];
+        const batches = batchByLimits(items, { maxFiles: 100, maxBytes: 90 * 1024 * 1024 });
+        expect(batches.length).toBe(2);
+    });
+    it('respects maxFiles even with small files', () => {
+        const items = Array.from({ length: 200 }, () => item(1024));
+        const batches = batchByLimits(items, { maxFiles: 95, maxBytes: 90 * 1024 * 1024 });
+        expect(batches.length).toBe(3);
+        expect(batches[0].length).toBe(95);
+        expect(batches[1].length).toBe(95);
+        expect(batches[2].length).toBe(10);
+    });
+});
+import { createUploadProductDirectoryTool } from './upload-directory.js';
+function makeClient(shouldFail = false) {
+    const calls = [];
+    return {
+        calls,
+        shouldFail,
+        uploadProductFiles: async (slug, files) => {
+            calls.push({ slug, files: files.map((f) => ({ path: f.path, content_type: f.content_type })) });
+            if (shouldFail)
+                throw new Error('simulated server failure');
+            return { uploaded: files.map((f) => f.path) };
+        },
+    };
+}
+describe('createUploadProductDirectoryTool — dry_run', () => {
+    it('returns plan without invoking the client', async () => {
+        const dir = await makeTempDir({ 'a.png': Buffer.alloc(100), 'sub/b.png': Buffer.alloc(50) });
+        const client = makeClient();
+        const tool = createUploadProductDirectoryTool(client);
+        const result = await tool({
+            slug: 'clara',
+            local_dir: dir,
+            domain: 'brand',
+            dest_prefix: 'logos',
+            dry_run: true,
+        });
+        expect(result.dry_run).toBe(true);
+        expect(result.total_files).toBe(2);
+        expect(client.calls).toEqual([]);
+    });
+});
+describe('createUploadProductDirectoryTool — oversized', () => {
+    it('reports oversized files as failed and continues with the rest', async () => {
+        const dir = await makeTempDir({
+            'small.png': Buffer.alloc(100),
+            'huge.png': Buffer.alloc(11 * 1024 * 1024), // 11MB > 10MB limit
+        });
+        const client = makeClient();
+        const tool = createUploadProductDirectoryTool(client);
+        const result = await tool({
+            slug: 'clara',
+            local_dir: dir,
+            domain: 'brand',
+            dry_run: false,
+        });
+        expect(result.dry_run).toBe(false);
+        expect(result.uploaded.length).toBe(1);
+        expect(result.uploaded[0].dest_path).toMatch(/small\.png$/);
+        expect(result.failed.length).toBe(1);
+        expect(result.failed[0].error).toMatch(/exceeds per-file limit/);
+    });
+});
+describe('createUploadProductDirectoryTool — missing dir', () => {
+    it('throws a clear error when local_dir does not exist', async () => {
+        const client = makeClient();
+        const tool = createUploadProductDirectoryTool(client);
+        await expect(tool({ slug: 'clara', local_dir: '/nonexistent/path/zxqwrt', domain: 'brand' })).rejects.toThrow(/local_dir not found/);
+    });
+});
+describe('createUploadProductDirectoryTool — client failure', () => {
+    it('marks every file in the failing batch as failed', async () => {
+        const dir = await makeTempDir({ 'a.png': Buffer.alloc(100), 'b.png': Buffer.alloc(100) });
+        const client = makeClient(true);
+        const tool = createUploadProductDirectoryTool(client);
+        const result = await tool({
+            slug: 'clara',
+            local_dir: dir,
+            domain: 'brand',
+            dry_run: false,
+        });
+        expect(result.uploaded.length).toBe(0);
+        expect(result.failed.length).toBe(2);
+        expect(result.failed.every((f) => f.error.includes('simulated server failure'))).toBe(true);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "44reports-mcp",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "type": "module",
   "description": "MCP server for deploying and pulling context files (code, docs, data) to/from 44reports",
   "main": "dist/index.js",
@@ -33,6 +33,7 @@
   "license": "MIT",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
+    "minimatch": "^10.2.5",
     "zod": "^3.23.8"
   },
   "devDependencies": {