read-metadata

Instructions

Implementation Reference

• src/tools/index.ts:69-84 (handler)

  The core handler function for the 'read-metadata' tool. Loads image buffer using loadImage, builds exifr options from segments using buildOptions, parses metadata with exifr.parse, returns success response with metadata JSON or error.

  async (args, extra) => {
    try {
      const { image, segments } = args;
      const buf = await loadImage(image);
      const opts = buildOptions(segments as any);
      const meta = await exifr.parse(buf, opts);
      
      if (!meta || Object.keys(meta).length === 0) {
        return createErrorResponse('No metadata found in image');
      }
      
      return createSuccessResponse(meta);
    } catch (error) {
      return createErrorResponse(`Error reading metadata: ${error instanceof Error ? error.message : String(error)}`);
    }
  }

• src/tools/index.ts:54-68 (schema)

  Input schema definition: ImageSourceSchema (zod object for image source kinds) and segments (optional array of specific metadata segments enum). Used in server.tool call.

  const ImageSourceSchema = z.object({
    kind: z.enum(['path', 'url', 'base64', 'buffer']),
    path: z.string().optional(),
    url: z.string().optional(),
    data: z.string().optional(),
    buffer: z.string().optional()
  });
  
  // Tool 1: read-metadata - reads all or specified metadata segments from an image
  const readMetadataTool = server.tool('read-metadata', 
    "Read all or specified metadata segments from an image",
    {
      image: ImageSourceSchema,
      segments: z.array(z.enum(['EXIF', 'GPS', 'XMP', 'ICC', 'IPTC', 'JFIF', 'IHDR'])).optional()
    },

• src/tools/index.ts:63-86 (registration)

  Registration of the 'read-metadata' tool via server.tool() with name, description, input schema, and handler function. Reference stored in tools object.

  const readMetadataTool = server.tool('read-metadata', 
    "Read all or specified metadata segments from an image",
    {
      image: ImageSourceSchema,
      segments: z.array(z.enum(['EXIF', 'GPS', 'XMP', 'ICC', 'IPTC', 'JFIF', 'IHDR'])).optional()
    },
    async (args, extra) => {
      try {
        const { image, segments } = args;
        const buf = await loadImage(image);
        const opts = buildOptions(segments as any);
        const meta = await exifr.parse(buf, opts);
        
        if (!meta || Object.keys(meta).length === 0) {
          return createErrorResponse('No metadata found in image');
        }
        
        return createSuccessResponse(meta);
      } catch (error) {
        return createErrorResponse(`Error reading metadata: ${error instanceof Error ? error.message : String(error)}`);
      }
    }
  );
  tools['read-metadata'] = readMetadataTool;

• src/tools/loaders.ts:11-72 (helper)

  loadImage helper: asynchronously loads image data from path, URL (http/file), base64 data URI or raw, or base64 buffer into Buffer/Uint8Array. Handles errors and size limits.

  export async function loadImage(src: ImageSourceType): Promise<Buffer | Uint8Array> {
    try {
      switch (src.kind) {
        case 'path':
          if (!src.path) {
            throw new Error('Path is required for kind="path"');
          }
          return await fs.promises.readFile(src.path);
        
        case 'url':
          if (!src.url) {
            throw new Error('URL is required for kind="url"');
          }
          
          if (src.url.startsWith('file://')) {
            // Handle file:// URLs by converting to filesystem path
            const filePath = fileURLToPath(src.url);
            return await fs.promises.readFile(filePath);
          } else {
            // Handle HTTP/HTTPS URLs
            const response = await fetch(src.url);
            if (!response.ok) {
              throw new Error(`Failed to fetch URL: ${response.status} ${response.statusText}`);
            }
            return new Uint8Array(await response.arrayBuffer());
          }
        
        case 'base64':
          if (!src.data) {
            throw new Error('Data is required for kind="base64"');
          }
          
          // Check for potential oversized base64 string (>30MB)
          if (src.data.length > 40000000) { // ~30MB in base64
            throw new Error('PayloadTooLarge: Base64 data exceeds 30MB limit');
          }
          
          // Handle data URIs or raw base64
          if (src.data.startsWith('data:')) {
            const base64Data = src.data.split(',')[1];
            return Buffer.from(base64Data, 'base64');
          } else {
            return Buffer.from(src.data, 'base64');
          }
        
        case 'buffer':
          if (!src.buffer) {
            throw new Error('Buffer is required for kind="buffer"');
          }
          return Buffer.from(src.buffer, 'base64');
        
        default:
          // This should never happen due to type constraints, but TypeScript needs it
          throw new Error(`Unsupported image source kind: ${(src as any).kind}`);
      }
    } catch (error) {
      if (error instanceof Error) {
        throw new Error(`Failed to load image: ${error.message}`);
      }
      throw error;
    }
  }

• src/tools/segments.ts:24-73 (helper)

  buildOptions helper: creates exifr.parse options enabling all segments by default or only specified ones (EXIF/GPS via 'tiff', XMP, ICC, IPTC, JFIF, IHDR).

  export function buildOptions(segments?: SegmentType[]): ExifrOptions {
    // Default options - include everything if segments not specified
    if (!segments || segments.length === 0) {
      return {
        tiff: true,    // Includes EXIF and GPS
        xmp: true,
        icc: true,
        iptc: true,
        jfif: true,
        ihdr: true,
      };
    }
  
    // Start with all segments disabled
    const options: ExifrOptions = {
      tiff: false,
      xmp: false,
      icc: false,
      iptc: false,
      jfif: false,
      ihdr: false,
    };
  
    // Enable requested segments
    segments.forEach(segment => {
      switch (segment) {
        case 'EXIF':
        case 'GPS':
          options.tiff = true;
          break;
        case 'XMP':
          options.xmp = true;
          break;
        case 'ICC':
          options.icc = true;
          break;
        case 'IPTC':
          options.iptc = true;
          break;
        case 'JFIF':
          options.jfif = true;
          break;
        case 'IHDR':
          options.ihdr = true;
          break;
      }
    });
  
    return options;
  }