mcp-image-title-server 1.0.0

package/index.js

@@ -0,0 +1,2105 @@
+#!/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 { Canvas, loadImage, FontLibrary } from 'skia-canvas';
+import sharp from 'sharp';
+import fs from 'fs/promises';
+import { constants as fsConstants } from 'fs';
+import path from 'path';
+import { homedir } from 'os';
+
+// Parse command line arguments
+function parseCommandLineArgs() {
+  const args = process.argv.slice(2);
+  const parsedArgs = {};
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    // Handle --config=<path> format
+    if (arg.startsWith('--config=')) {
+      parsedArgs.config = arg.substring('--config='.length);
+    }
+    // Handle --config <path> format
+    else if (arg === '--config' && i + 1 < args.length) {
+      parsedArgs.config = args[i + 1];
+      i++; // Skip next argument
+    }
+  }
+
+  return parsedArgs;
+}
+
+// Load configuration from file
+let globalConfig = {};
+async function loadConfig() {
+  const cliArgs = parseCommandLineArgs();
+  const configPaths = [];
+
+  // Priority 1: Command line argument
+  if (cliArgs.config) {
+    configPaths.push(cliArgs.config);
+  }
+
+  // Priority 2: Environment variable
+  if (process.env.MCP_IMAGE_TITLE_CONFIG) {
+    configPaths.push(process.env.MCP_IMAGE_TITLE_CONFIG);
+  }
+
+  // Priority 3 & 4: Default locations
+  configPaths.push(
+    path.join(process.cwd(), '.mcp-image-title.json'),
+    path.join(homedir(), '.mcp-image-title.json')
+  );
+
+  for (const configPath of configPaths) {
+    try {
+      const configData = await fs.readFile(configPath, 'utf-8');
+      globalConfig = JSON.parse(configData);
+      console.error(`Loaded configuration from: ${configPath}`);
+      return;
+    } catch (error) {
+      // Config file doesn't exist or is invalid, continue
+    }
+  }
+}
+
+// Load config at startup
+await loadConfig();
+
+// Path resolution helpers
+function resolveWithDefaultDirectory(inputPath, defaultDirectory) {
+  if (!inputPath) return inputPath;
+
+  // If path is absolute or starts with ./ or ../, use it as-is
+  if (path.isAbsolute(inputPath) || inputPath.startsWith('./') || inputPath.startsWith('../')) {
+    return inputPath;
+  }
+
+  // If defaultDirectory is set, prepend it
+  if (defaultDirectory) {
+    return path.join(defaultDirectory, inputPath);
+  }
+
+  return inputPath;
+}
+
+function resolveBackgroundPath(backgroundPath) {
+  const defaults = globalConfig.defaults || {};
+  return resolveWithDefaultDirectory(backgroundPath, defaults.backgroundsDirectory);
+}
+
+function resolveOutputPath(outputPath) {
+  const defaults = globalConfig.defaults || {};
+  return resolveWithDefaultDirectory(outputPath, defaults.outputsDirectory);
+}
+
+function resolveFontPath(fontPath) {
+  const defaults = globalConfig.defaults || {};
+  return resolveWithDefaultDirectory(fontPath, defaults.fontsDirectory);
+}
+
+// Font loading functionality
+const loadedFonts = new Map();
+
+async function loadCustomFont(fontPath, fontFamily) {
+  // Resolve font path with default directory
+  const resolvedPath = resolveFontPath(fontPath);
+
+  // Check cache
+  const cacheKey = `${fontFamily}:${resolvedPath}`;
+  if (loadedFonts.has(cacheKey)) {
+    return true;
+  }
+
+  try {
+    // Check file exists
+    await fs.access(resolvedPath);
+
+    // Check file extension
+    const ext = path.extname(resolvedPath).toLowerCase();
+    if (!['.ttf', '.otf'].includes(ext)) {
+      throw new Error(`Unsupported font format: ${ext}. Supported formats: .ttf, .otf`);
+    }
+
+    // Register font with FontLibrary
+    FontLibrary.use(fontFamily, [resolvedPath]);
+
+    // Add to cache
+    loadedFonts.set(cacheKey, true);
+    console.error(`Loaded custom font: ${fontFamily} from ${resolvedPath}`);
+
+    return true;
+  } catch (error) {
+    throw new Error(`Failed to load custom font: ${error.message}`);
+  }
+}
+
+async function loadCustomFonts(fontPaths, fontFamily) {
+  if (!Array.isArray(fontPaths)) {
+    fontPaths = [fontPaths];
+  }
+
+  // Resolve all font paths with default directory
+  const resolvedPaths = fontPaths.map(fp => resolveFontPath(fp));
+
+  // Check cache
+  const cacheKey = `${fontFamily}:${resolvedPaths.join('|')}`;
+  if (loadedFonts.has(cacheKey)) {
+    return true;
+  }
+
+  try {
+    // Verify all paths exist
+    for (const resolvedPath of resolvedPaths) {
+      await fs.access(resolvedPath);
+
+      const ext = path.extname(resolvedPath).toLowerCase();
+      if (!['.ttf', '.otf'].includes(ext)) {
+        throw new Error(`Unsupported font format: ${ext}. Supported formats: .ttf, .otf`);
+      }
+    }
+
+    // Register font family with FontLibrary
+    FontLibrary.use(fontFamily, resolvedPaths);
+
+    // Add to cache
+    loadedFonts.set(cacheKey, true);
+    console.error(`Loaded custom font family: ${fontFamily} (${resolvedPaths.length} variant${resolvedPaths.length > 1 ? 's' : ''})`);
+
+    return true;
+  } catch (error) {
+    throw new Error(`Failed to load custom fonts: ${error.message}`);
+  }
+}
+
+// Create MCP server
+const server = new Server(
+  {
+    name: 'image-title-server',
+    version: '1.0.0',
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+// Helper function to calculate brightness of an image region
+async function calculateRegionBrightness(imagePath, x, y, width, height, gradientSampling = false) {
+  try {
+    const image = sharp(imagePath);
+    const metadata = await image.metadata();
+
+    // Ensure coordinates are within image bounds
+    x = Math.max(0, Math.min(x, metadata.width - 1));
+    y = Math.max(0, Math.min(y, metadata.height - 1));
+    width = Math.min(width, metadata.width - x);
+    height = Math.min(height, metadata.height - y);
+
+    if (gradientSampling) {
+      // For gradient backgrounds, sample multiple points across the region
+      const samplePoints = [];
+      const gridSize = 5; // 5x5 grid
+
+      for (let row = 0; row < gridSize; row++) {
+        for (let col = 0; col < gridSize; col++) {
+          const sampleX = Math.floor(x + (width / (gridSize - 1)) * col);
+          const sampleY = Math.floor(y + (height / (gridSize - 1)) * row);
+
+          // Extract a small region around each sample point
+          const sampleWidth = Math.min(10, width);
+          const sampleHeight = Math.min(10, height);
+
+          try {
+            const { data } = await sharp(imagePath)
+              .extract({
+                left: Math.min(sampleX, metadata.width - sampleWidth),
+                top: Math.min(sampleY, metadata.height - sampleHeight),
+                width: sampleWidth,
+                height: sampleHeight
+              })
+              .raw()
+              .toBuffer({ resolveWithObject: true });
+
+            let pointBrightness = 0;
+            const channels = metadata.channels || 3;
+
+            for (let i = 0; i < data.length; i += channels) {
+              const r = data[i];
+              const g = data[i + 1];
+              const b = data[i + 2];
+              const brightness = 0.299 * r + 0.587 * g + 0.114 * b;
+              pointBrightness += brightness;
+            }
+
+            samplePoints.push(pointBrightness / (data.length / channels));
+          } catch (err) {
+            // Skip this sample point if extraction fails
+            continue;
+          }
+        }
+      }
+
+      // Return average brightness across all sample points
+      if (samplePoints.length > 0) {
+        return samplePoints.reduce((a, b) => a + b, 0) / samplePoints.length;
+      }
+    }
+
+    // Standard single-region sampling
+    // Extract the region and convert to raw pixel data
+    const { data } = await image
+      .extract({ left: x, top: y, width, height })
+      .raw()
+      .toBuffer({ resolveWithObject: true });
+
+    let totalBrightness = 0;
+    const channels = metadata.channels || 3;
+
+    for (let i = 0; i < data.length; i += channels) {
+      const r = data[i];
+      const g = data[i + 1];
+      const b = data[i + 2];
+
+      // Calculate perceived brightness using luminance formula
+      const brightness = 0.299 * r + 0.587 * g + 0.114 * b;
+      totalBrightness += brightness;
+    }
+
+    return totalBrightness / (data.length / channels);
+  } catch (error) {
+    console.error('Error calculating brightness:', error);
+    return 128; // Default to medium brightness
+  }
+}
+
+// Function to get optimal text color based on background brightness
+function getOptimalTextColor(brightness, enhanceContrast = true) {
+  if (enhanceContrast) {
+    // Enhanced contrast mode
+    if (brightness > 128) {
+      return { color: '#000000', shadow: '#FFFFFF', shadowBlur: 3 };
+    } else {
+      return { color: '#FFFFFF', shadow: '#000000', shadowBlur: 3 };
+    }
+  } else {
+    // Simple mode
+    return brightness > 128 
+      ? { color: '#000000', shadow: null, shadowBlur: 0 }
+      : { color: '#FFFFFF', shadow: null, shadowBlur: 0 };
+  }
+}
+
+function buildFontDescriptor(fontSize, fontFamily, fontWeight = 'normal', fontStyle = 'normal') {
+  return [
+    fontStyle !== 'normal' ? fontStyle : '',
+    fontWeight !== 'normal' ? fontWeight : '',
+    `${fontSize}px`,
+    `"${fontFamily}"`
+  ].filter(Boolean).join(' ');
+}
+
+// Function to calculate optimal font size that fits within image bounds (using binary search)
+function calculateOptimalFontSize(
+  ctx,
+  text,
+  maxWidth,
+  maxHeight,
+  minFontSize = 12,
+  maxFontSize = 200,
+  fontOptions = {}
+) {
+  const {
+    fontFamily = 'Arial',
+    fontWeight = 'normal',
+    fontStyle = 'normal',
+  } = fontOptions;
+
+  let low = minFontSize;
+  let high = maxFontSize;
+  let bestFit = minFontSize;
+
+  while (low <= high) {
+    const mid = Math.floor((low + high) / 2);
+    ctx.font = buildFontDescriptor(mid, fontFamily, fontWeight, fontStyle);
+    const metrics = ctx.measureText(text);
+    const textWidth = metrics.width;
+    const textHeight = mid;
+
+    if (textWidth <= maxWidth && textHeight <= maxHeight) {
+      bestFit = mid;
+      low = mid + 1; // Try larger size
+    } else {
+      high = mid - 1; // Try smaller size
+    }
+  }
+
+  return bestFit;
+}
+
+// Function to wrap text into multiple lines
+function wrapText(ctx, text, maxWidth) {
+  // First, split by explicit line breaks (\n)
+  const explicitLines = text.split('\n');
+  const lines = [];
+
+  // Process each explicit line
+  for (const line of explicitLines) {
+    const words = line.split(' ');
+    let currentLine = '';
+
+    for (let i = 0; i < words.length; i++) {
+      const word = words[i];
+      const testLine = currentLine + (currentLine ? ' ' : '') + word;
+      const metrics = ctx.measureText(testLine);
+
+      if (metrics.width > maxWidth && currentLine) {
+        lines.push(currentLine);
+        currentLine = word;
+      } else {
+        currentLine = testLine;
+      }
+    }
+
+    if (currentLine) {
+      lines.push(currentLine);
+    }
+  }
+
+  return lines;
+}
+
+// Function to wrap text for vertical writing (by character count)
+function wrapVerticalText(text, maxCharsPerLine) {
+  const columns = [];
+  const chars = Array.from(text); // Handle multi-byte characters correctly
+
+  for (let i = 0; i < chars.length; i += maxCharsPerLine) {
+    columns.push(chars.slice(i, i + maxCharsPerLine).join(''));
+  }
+
+  return columns;
+}
+
+// Function to measure vertical text dimensions
+function measureVerticalText(ctx, text, fontSize, characterSpacing = 0) {
+  const chars = Array.from(text);
+  const height = chars.length * fontSize + (chars.length - 1) * characterSpacing;
+  const width = fontSize; // Approximate width as font size
+  return { width, height };
+}
+
+// Function to draw vertical text
+function drawVerticalText(ctx, text, x, y, fontSize, characterSpacing = 0, textStyle, textEffect = null, effectOptions = {}) {
+  const chars = Array.from(text);
+  let currentY = y;
+
+  const {
+    outlineWidth = 3,
+    outlineColor = null,
+    glowRadius = 10,
+    glowIntensity = 0.8
+  } = effectOptions;
+
+  // Apply text effects
+  if (textEffect === 'outline') {
+    const finalOutlineColor = outlineColor || (textStyle.color === '#FFFFFF' ? '#000000' : '#FFFFFF');
+    ctx.strokeStyle = finalOutlineColor;
+    ctx.lineWidth = outlineWidth;
+    ctx.lineJoin = 'round';
+    ctx.miterLimit = 2;
+
+    // Draw outline for each character
+    for (let i = 0; i < chars.length; i++) {
+      ctx.strokeText(chars[i], x, currentY);
+      currentY += fontSize + characterSpacing;
+    }
+
+    // Reset and draw filled text
+    currentY = y;
+    ctx.fillStyle = textStyle.color;
+    for (let i = 0; i < chars.length; i++) {
+      ctx.fillText(chars[i], x, currentY);
+      currentY += fontSize + characterSpacing;
+    }
+  } else if (textEffect === 'glow') {
+    const glowColor = outlineColor || textStyle.color;
+    ctx.shadowColor = glowColor;
+    ctx.shadowBlur = glowRadius;
+    ctx.globalAlpha = glowIntensity;
+
+    // Draw glow multiple times
+    for (let j = 0; j < 3; j++) {
+      currentY = y;
+      ctx.fillStyle = glowColor;
+      for (let i = 0; i < chars.length; i++) {
+        ctx.fillText(chars[i], x, currentY);
+        currentY += fontSize + characterSpacing;
+      }
+    }
+
+    // Draw main text
+    ctx.shadowBlur = 0;
+    ctx.globalAlpha = 1;
+    ctx.fillStyle = textStyle.color;
+    currentY = y;
+    for (let i = 0; i < chars.length; i++) {
+      ctx.fillText(chars[i], x, currentY);
+      currentY += fontSize + characterSpacing;
+    }
+  } else if (textEffect === 'emboss') {
+    const embossColor = outlineColor || (textStyle.color === '#FFFFFF' ? '#666666' : '#FFFFFF');
+
+    // Bottom-right shadow
+    ctx.fillStyle = '#00000033';
+    currentY = y;
+    for (let i = 0; i < chars.length; i++) {
+      ctx.fillText(chars[i], x + 2, currentY + 2);
+      currentY += fontSize + characterSpacing;
+    }
+
+    // Top-left highlight
+    ctx.fillStyle = embossColor;
+    currentY = y;
+    for (let i = 0; i < chars.length; i++) {
+      ctx.fillText(chars[i], x - 1, currentY - 1);
+      currentY += fontSize + characterSpacing;
+    }
+
+    // Main text
+    ctx.fillStyle = textStyle.color;
+    currentY = y;
+    for (let i = 0; i < chars.length; i++) {
+      ctx.fillText(chars[i], x, currentY);
+      currentY += fontSize + characterSpacing;
+    }
+  } else {
+    // Default rendering with optional shadow
+    if (textStyle.shadow && textStyle.shadowBlur > 0) {
+      ctx.shadowColor = textStyle.shadow;
+      ctx.shadowBlur = textStyle.shadowBlur;
+      ctx.shadowOffsetX = 1;
+      ctx.shadowOffsetY = 1;
+    }
+
+    ctx.fillStyle = textStyle.color;
+    for (let i = 0; i < chars.length; i++) {
+      ctx.fillText(chars[i], x, currentY);
+      currentY += fontSize + characterSpacing;
+    }
+  }
+}
+
+
+// Function to calculate optimal font size for multi-line text (using binary search)
+function calculateOptimalFontSizeForLines(
+  ctx,
+  lines,
+  maxWidth,
+  maxHeight,
+  minFontSize = 12,
+  maxFontSize = 200,
+  fontOptions = {}
+) {
+  const {
+    fontFamily = 'Arial',
+    fontWeight = 'normal',
+    fontStyle = 'normal',
+    lineHeight = 1.2,
+  } = fontOptions;
+
+  let low = minFontSize;
+  let high = maxFontSize;
+  let bestFit = minFontSize;
+
+  while (low <= high) {
+    const mid = Math.floor((low + high) / 2);
+    ctx.font = buildFontDescriptor(mid, fontFamily, fontWeight, fontStyle);
+
+    const lineHeightPixels = mid * lineHeight;
+    const totalHeight = lines.length * lineHeightPixels;
+
+    if (totalHeight <= maxHeight) {
+      let allLinesFit = true;
+      for (const line of lines) {
+        const metrics = ctx.measureText(line);
+        if (metrics.width > maxWidth) {
+          allLinesFit = false;
+          break;
+        }
+      }
+
+      if (allLinesFit) {
+        bestFit = mid;
+        low = mid + 1; // Try larger size
+      } else {
+        high = mid - 1; // Try smaller size
+      }
+    } else {
+      high = mid - 1; // Try smaller size
+    }
+  }
+
+  return bestFit;
+}
+
+// Validation helper functions
+function validateParameters(backgroundPath, title, options) {
+  const errors = [];
+
+  // Validate required parameters
+  if (!backgroundPath || typeof backgroundPath !== 'string') {
+    errors.push('backgroundPath is required and must be a string');
+  }
+  if (!title || typeof title !== 'string') {
+    errors.push('title is required and must be a string');
+  }
+
+  // Validate fontSize
+  if (options.fontSize !== undefined) {
+    const fontSize = options.fontSize;
+    if (typeof fontSize !== 'number' || fontSize < 6 || fontSize > 500) {
+      errors.push('fontSize must be a number between 6 and 500');
+    }
+  }
+
+  // Validate position
+  if (options.position !== undefined) {
+    const validPositions = ['top', 'center', 'bottom'];
+    if (!validPositions.includes(options.position)) {
+      errors.push(`position must be one of: ${validPositions.join(', ')}`);
+    }
+  }
+
+  // Validate borderOpacity
+  if (options.borderOpacity !== undefined) {
+    const opacity = options.borderOpacity;
+    if (typeof opacity !== 'number' || opacity < 0 || opacity > 1) {
+      errors.push('borderOpacity must be a number between 0 and 1');
+    }
+  }
+
+  // Validate border type
+  if (options.border !== undefined && options.border !== null) {
+    const validBorders = ['rectangle', 'rounded', 'filled', 'outline'];
+    if (!validBorders.includes(options.border)) {
+      errors.push(`border must be one of: ${validBorders.join(', ')}`);
+    }
+  }
+
+  // Validate maxWidthPercent and maxHeightPercent
+  if (options.maxWidthPercent !== undefined) {
+    const val = options.maxWidthPercent;
+    if (typeof val !== 'number' || val < 0.1 || val > 1.0) {
+      errors.push('maxWidthPercent must be a number between 0.1 and 1.0');
+    }
+  }
+  if (options.maxHeightPercent !== undefined) {
+    const val = options.maxHeightPercent;
+    if (typeof val !== 'number' || val < 0.1 || val > 1.0) {
+      errors.push('maxHeightPercent must be a number between 0.1 and 1.0');
+    }
+  }
+
+  // Validate minFontSize and maxFontSize
+  if (options.minFontSize !== undefined) {
+    const val = options.minFontSize;
+    if (typeof val !== 'number' || val < 8) {
+      errors.push('minFontSize must be a number >= 8');
+    }
+  }
+  if (options.maxFontSize !== undefined) {
+    const val = options.maxFontSize;
+    if (typeof val !== 'number' || val < 12) {
+      errors.push('maxFontSize must be a number >= 12');
+    }
+  }
+
+  // Validate lineHeight
+  if (options.lineHeight !== undefined) {
+    const val = options.lineHeight;
+    if (typeof val !== 'number' || val < 0.8 || val > 3.0) {
+      errors.push('lineHeight must be a number between 0.8 and 3.0');
+    }
+  }
+
+  // Validate custom font parameters
+  if (options.customFontPath !== undefined && options.customFontPath !== null) {
+    if (typeof options.customFontPath !== 'string') {
+      errors.push('customFontPath must be a string');
+    }
+  }
+
+  if (options.customFontPaths !== undefined && options.customFontPaths !== null) {
+    if (!Array.isArray(options.customFontPaths)) {
+      errors.push('customFontPaths must be an array');
+    } else if (options.customFontPaths.length === 0) {
+      errors.push('customFontPaths must not be empty');
+    } else if (!options.customFontPaths.every(p => typeof p === 'string')) {
+      errors.push('All items in customFontPaths must be strings');
+    }
+  }
+
+  if (options.fontWeight !== undefined) {
+    const validWeights = ['normal', 'bold', '100', '200', '300', '400', '500', '600', '700', '800', '900'];
+    if (!validWeights.includes(String(options.fontWeight))) {
+      errors.push(`fontWeight must be one of: ${validWeights.join(', ')}`);
+    }
+  }
+
+  if (options.fontStyle !== undefined) {
+    const validStyles = ['normal', 'italic', 'oblique'];
+    if (!validStyles.includes(options.fontStyle)) {
+      errors.push(`fontStyle must be one of: ${validStyles.join(', ')}`);
+    }
+  }
+
+  if (errors.length > 0) {
+    throw new Error(`Validation failed:\n${errors.join('\n')}`);
+  }
+}
+
+// Function to composite title on image
+async function compositeTitle(backgroundPath, title, options = {}) {
+  // Validate parameters first
+  validateParameters(backgroundPath, title, options);
+
+  // Resolve paths with default directories
+  const resolvedBackgroundPath = resolveBackgroundPath(backgroundPath);
+
+  // Merge global config defaults with options
+  const defaults = globalConfig.defaults || {};
+  const {
+    outputPath = 'output.png',
+    fontSize = defaults.fontSize || 48,
+    fontFamily = defaults.fontFamily || 'Arial',
+    fontWeight = defaults.fontWeight || 'normal',
+    fontStyle = defaults.fontStyle || 'normal',
+    position = defaults.position || 'center',
+    offsetX = defaults.offsetX || 0,
+    offsetY = defaults.offsetY || 0,
+    enhanceContrast = defaults.enhanceContrast !== undefined ? defaults.enhanceContrast : true,
+    customColor = defaults.customColor || null,
+    customFontPath = defaults.customFontPath || null,
+    customFontPaths = defaults.customFontPaths || null,
+    border = defaults.border || null,
+    borderWidth = defaults.borderWidth || 2,
+    borderColor = defaults.borderColor || null,
+    borderRadius = defaults.borderRadius || 8,
+    borderPadding = defaults.borderPadding || 16,
+    borderOpacity = defaults.borderOpacity !== undefined ? defaults.borderOpacity : 0.8,
+    autoSize = defaults.autoSize !== undefined ? defaults.autoSize : false,
+    autoWrap = defaults.autoWrap !== undefined ? defaults.autoWrap : false,
+    maxWidthPercent = defaults.maxWidthPercent || 0.8,
+    maxHeightPercent = defaults.maxHeightPercent || 0.8,
+    minFontSize = defaults.minFontSize || 12,
+    maxFontSize = defaults.maxFontSize || 200,
+    lineHeight = defaults.lineHeight || 1.2,
+    textEffect = defaults.textEffect || null,
+    outlineWidth = defaults.outlineWidth || 3,
+    outlineColor = defaults.outlineColor || null,
+    glowRadius = defaults.glowRadius || 10,
+    glowIntensity = defaults.glowIntensity || 0.8,
+    gradientSampling = defaults.gradientSampling !== undefined ? defaults.gradientSampling : false,
+    writingMode = defaults.writingMode || 'horizontal',
+    characterSpacing = defaults.characterSpacing || 0,
+    verticalAlign = defaults.verticalAlign || 'center'
+  } = options;
+
+  // Resolve output path with default directory
+  const resolvedOutputPath = resolveOutputPath(outputPath);
+
+  try {
+    // Check if background file exists
+    try {
+      await fs.access(resolvedBackgroundPath);
+    } catch (error) {
+      throw new Error(`Background image not found: ${resolvedBackgroundPath}`);
+    }
+
+    // Validate image format
+    let metadata;
+    try {
+      const image = sharp(resolvedBackgroundPath);
+      metadata = await image.metadata();
+    } catch (error) {
+      throw new Error(`Failed to read image: ${error.message}`);
+    }
+
+    const supportedFormats = ['jpeg', 'png', 'webp', 'tiff', 'gif'];
+    if (!supportedFormats.includes(metadata.format)) {
+      throw new Error(`Unsupported image format: ${metadata.format}. Supported formats: ${supportedFormats.join(', ')}`);
+    }
+
+    // Check if output directory exists and is writable
+    const outputDir = path.dirname(path.resolve(resolvedOutputPath));
+    try {
+      await fs.access(outputDir, fsConstants.W_OK);
+    } catch (error) {
+      throw new Error(`Output directory is not writable: ${outputDir}`);
+    }
+
+    // Load custom fonts if specified
+    if (customFontPaths) {
+      // Multiple font variants
+      await loadCustomFonts(customFontPaths, fontFamily);
+    } else if (customFontPath) {
+      // Single font file
+      await loadCustomFont(customFontPath, fontFamily);
+    } else if (globalConfig.fonts && globalConfig.fonts[fontFamily]) {
+      // Auto-load font from config mapping
+      const fontPaths = globalConfig.fonts[fontFamily];
+      if (Array.isArray(fontPaths)) {
+        await loadCustomFonts(fontPaths, fontFamily);
+      } else {
+        await loadCustomFont(fontPaths, fontFamily);
+      }
+    }
+
+    // Load background image
+    const background = await loadImage(resolvedBackgroundPath);
+    const canvas = new Canvas(background.width, background.height);
+    const ctx = canvas.getContext('2d');
+    
+    // Draw background
+    ctx.drawImage(background, 0, 0);
+    
+    // Calculate available space for text
+    const maxWidth = background.width * maxWidthPercent;
+    const maxHeight = background.height * maxHeightPercent;
+    
+    // Process text based on options
+    let finalFontSize = fontSize;
+    let textLines = title.split('\n');
+    let totalTextHeight = fontSize;
+    let maxLineWidth = 0;
+    
+    if (autoWrap || autoSize) {
+      // Set initial font for measurement
+      ctx.font = buildFontDescriptor(fontSize, fontFamily, fontWeight, fontStyle);
+      
+      if (autoWrap) {
+        // Wrap text first
+        textLines = wrapText(ctx, title, maxWidth);
+        
+        if (autoSize) {
+          // Calculate optimal font size for wrapped text
+          finalFontSize = calculateOptimalFontSizeForLines(
+            ctx,
+            textLines,
+            maxWidth,
+            maxHeight,
+            minFontSize, 
+            autoSize ? maxFontSize : fontSize,
+            { fontFamily, fontWeight, fontStyle, lineHeight }
+          );
+        }
+      } else if (autoSize) {
+        // Just auto-size without wrapping
+        finalFontSize = calculateOptimalFontSize(
+          ctx,
+          title,
+          maxWidth,
+          maxHeight,
+          minFontSize,
+          maxFontSize,
+          { fontFamily, fontWeight, fontStyle }
+        );
+      }
+    }
+    
+    // Set final font with weight and style support
+    const fontDescriptor = buildFontDescriptor(finalFontSize, fontFamily, fontWeight, fontStyle);
+
+    ctx.font = fontDescriptor;
+    ctx.textAlign = 'center';
+    ctx.textBaseline = 'middle';
+    
+    // If we wrapped text, recalculate lines with final font size
+    if (autoWrap && textLines.length > 1) {
+      textLines = wrapText(ctx, title, maxWidth);
+    }
+    
+    // Calculate text dimensions
+    totalTextHeight = textLines.length * finalFontSize * lineHeight;
+    for (const line of textLines) {
+      const lineMetrics = ctx.measureText(line);
+      maxLineWidth = Math.max(maxLineWidth, lineMetrics.width);
+    }
+    
+    const textWidth = maxLineWidth;
+    const textHeight = totalTextHeight;
+    
+    // Calculate position
+    let x, y;
+    switch (position) {
+      case 'top':
+        x = background.width / 2 + offsetX;
+        y = textHeight + 20 + offsetY;
+        break;
+      case 'bottom':
+        x = background.width / 2 + offsetX;
+        y = background.height - textHeight - 20 + offsetY;
+        break;
+      case 'center':
+      default:
+        x = background.width / 2 + offsetX;
+        y = background.height / 2 + offsetY;
+        break;
+    }
+    
+    // Calculate brightness of text area if no custom color is specified
+    let textStyle;
+    if (customColor) {
+      textStyle = { color: customColor, shadow: null, shadowBlur: 0 };
+    } else {
+      const regionX = Math.max(0, x - textWidth / 2 - 10);
+      const regionY = Math.max(0, y - textHeight / 2 - 10);
+      const regionWidth = Math.min(textWidth + 20, background.width - regionX);
+      const regionHeight = Math.min(textHeight + 20, background.height - regionY);
+      
+      const brightness = await calculateRegionBrightness(
+        resolvedBackgroundPath,
+        Math.floor(regionX),
+        Math.floor(regionY),
+        Math.floor(regionWidth),
+        Math.floor(regionHeight),
+        gradientSampling
+      );
+      
+      textStyle = getOptimalTextColor(brightness, enhanceContrast);
+    }
+    
+    // Draw border/frame if specified
+    if (border) {
+      const borderX = x - textWidth / 2 - borderPadding;
+      const borderY = y - textHeight / 2 - borderPadding;
+      const borderWidthTotal = textWidth + (borderPadding * 2);
+      const borderHeightTotal = textHeight + (borderPadding * 2);
+      
+      // Set border style
+      const finalBorderColor = borderColor || (textStyle.color === '#FFFFFF' ? '#000000' : '#FFFFFF');
+      
+      ctx.save();
+      ctx.globalAlpha = borderOpacity;
+      
+      switch (border) {
+        case 'rectangle':
+          ctx.strokeStyle = finalBorderColor;
+          ctx.lineWidth = borderWidth;
+          ctx.strokeRect(borderX, borderY, borderWidthTotal, borderHeightTotal);
+          break;
+          
+        case 'rounded':
+          ctx.strokeStyle = finalBorderColor;
+          ctx.lineWidth = borderWidth;
+          ctx.beginPath();
+          ctx.roundRect(borderX, borderY, borderWidthTotal, borderHeightTotal, borderRadius);
+          ctx.stroke();
+          break;
+          
+        case 'filled':
+          ctx.fillStyle = finalBorderColor;
+          ctx.globalAlpha = borderOpacity * 0.7; // More transparent for filled
+          if (borderRadius > 0) {
+            ctx.beginPath();
+            ctx.roundRect(borderX, borderY, borderWidthTotal, borderHeightTotal, borderRadius);
+            ctx.fill();
+          } else {
+            ctx.fillRect(borderX, borderY, borderWidthTotal, borderHeightTotal);
+          }
+          break;
+          
+        case 'outline':
+          // Double border effect
+          ctx.strokeStyle = finalBorderColor;
+          ctx.lineWidth = borderWidth + 2;
+          ctx.globalAlpha = borderOpacity * 0.5;
+          ctx.beginPath();
+          ctx.roundRect(borderX - 1, borderY - 1, borderWidthTotal + 2, borderHeightTotal + 2, borderRadius + 1);
+          ctx.stroke();
+          
+          ctx.strokeStyle = textStyle.color;
+          ctx.lineWidth = borderWidth;
+          ctx.globalAlpha = borderOpacity;
+          ctx.beginPath();
+          ctx.roundRect(borderX, borderY, borderWidthTotal, borderHeightTotal, borderRadius);
+          ctx.stroke();
+          break;
+      }
+      
+      ctx.restore();
+    }
+    
+    // Draw text with effects
+    ctx.save();
+
+    // Apply text effect based on selected type
+    if (textEffect === 'outline') {
+      // Outline effect: stroke around text
+      const finalOutlineColor = outlineColor || (textStyle.color === '#FFFFFF' ? '#000000' : '#FFFFFF');
+      ctx.strokeStyle = finalOutlineColor;
+      ctx.lineWidth = outlineWidth;
+      ctx.lineJoin = 'round';
+      ctx.miterLimit = 2;
+
+      if (textLines.length === 1) {
+        ctx.strokeText(title, x, y);
+        ctx.fillStyle = textStyle.color;
+        ctx.fillText(title, x, y);
+      } else {
+        const lineSpacing = finalFontSize * lineHeight;
+        const startY = y - ((textLines.length - 1) * lineSpacing) / 2;
+
+        for (let i = 0; i < textLines.length; i++) {
+          const lineY = startY + (i * lineSpacing);
+          ctx.strokeText(textLines[i], x, lineY);
+        }
+
+        ctx.fillStyle = textStyle.color;
+        for (let i = 0; i < textLines.length; i++) {
+          const lineY = startY + (i * lineSpacing);
+          ctx.fillText(textLines[i], x, lineY);
+        }
+      }
+    } else if (textEffect === 'glow') {
+      // Glow effect: multiple shadows with blur
+      const glowColor = outlineColor || textStyle.color;
+      ctx.shadowColor = glowColor;
+      ctx.shadowBlur = glowRadius;
+      ctx.globalAlpha = glowIntensity;
+
+      // Draw glow multiple times for intensity
+      for (let i = 0; i < 3; i++) {
+        if (textLines.length === 1) {
+          ctx.fillStyle = glowColor;
+          ctx.fillText(title, x, y);
+        } else {
+          const lineSpacing = finalFontSize * lineHeight;
+          const startY = y - ((textLines.length - 1) * lineSpacing) / 2;
+
+          for (let j = 0; j < textLines.length; j++) {
+            const lineY = startY + (j * lineSpacing);
+            ctx.fillStyle = glowColor;
+            ctx.fillText(textLines[j], x, lineY);
+          }
+        }
+      }
+
+      // Draw main text on top
+      ctx.shadowBlur = 0;
+      ctx.globalAlpha = 1;
+      ctx.fillStyle = textStyle.color;
+
+      if (textLines.length === 1) {
+        ctx.fillText(title, x, y);
+      } else {
+        const lineSpacing = finalFontSize * lineHeight;
+        const startY = y - ((textLines.length - 1) * lineSpacing) / 2;
+
+        for (let i = 0; i < textLines.length; i++) {
+          const lineY = startY + (i * lineSpacing);
+          ctx.fillText(textLines[i], x, lineY);
+        }
+      }
+    } else if (textEffect === 'emboss') {
+      // Emboss effect: shadow offset to create 3D look
+      const embossColor = outlineColor || (textStyle.color === '#FFFFFF' ? '#666666' : '#FFFFFF');
+
+      // Bottom-right shadow (darker)
+      ctx.fillStyle = '#00000033';
+      if (textLines.length === 1) {
+        ctx.fillText(title, x + 2, y + 2);
+      } else {
+        const lineSpacing = finalFontSize * lineHeight;
+        const startY = y - ((textLines.length - 1) * lineSpacing) / 2;
+        for (let i = 0; i < textLines.length; i++) {
+          const lineY = startY + (i * lineSpacing);
+          ctx.fillText(textLines[i], x + 2, lineY + 2);
+        }
+      }
+
+      // Top-left highlight
+      ctx.fillStyle = embossColor;
+      if (textLines.length === 1) {
+        ctx.fillText(title, x - 1, y - 1);
+      } else {
+        const lineSpacing = finalFontSize * lineHeight;
+        const startY = y - ((textLines.length - 1) * lineSpacing) / 2;
+        for (let i = 0; i < textLines.length; i++) {
+          const lineY = startY + (i * lineSpacing);
+          ctx.fillText(textLines[i], x - 1, lineY - 1);
+        }
+      }
+
+      // Main text
+      ctx.fillStyle = textStyle.color;
+      if (textLines.length === 1) {
+        ctx.fillText(title, x, y);
+      } else {
+        const lineSpacing = finalFontSize * lineHeight;
+        const startY = y - ((textLines.length - 1) * lineSpacing) / 2;
+        for (let i = 0; i < textLines.length; i++) {
+          const lineY = startY + (i * lineSpacing);
+          ctx.fillText(textLines[i], x, lineY);
+        }
+      }
+    } else {
+      // Default: shadow if specified
+      if (textStyle.shadow && textStyle.shadowBlur > 0) {
+        ctx.shadowColor = textStyle.shadow;
+        ctx.shadowBlur = textStyle.shadowBlur;
+        ctx.shadowOffsetX = 1;
+        ctx.shadowOffsetY = 1;
+      }
+
+      ctx.fillStyle = textStyle.color;
+
+      // Draw multiple lines if text was wrapped
+      if (textLines.length === 1) {
+        ctx.fillText(title, x, y);
+      } else {
+        const lineSpacing = finalFontSize * lineHeight;
+        const startY = y - ((textLines.length - 1) * lineSpacing) / 2;
+
+        for (let i = 0; i < textLines.length; i++) {
+          const lineY = startY + (i * lineSpacing);
+          ctx.fillText(textLines[i], x, lineY);
+        }
+      }
+    }
+
+    ctx.restore();
+    
+    // Save the result
+    const buffer = await canvas.toBuffer('image/png');
+    await fs.writeFile(resolvedOutputPath, buffer);
+    
+    return {
+      success: true,
+      outputPath: resolvedOutputPath,
+      dimensions: { width: background.width, height: background.height },
+      textPosition: { x, y },
+      textStyle,
+      textInfo: {
+        originalText: title,
+        lines: textLines,
+        fontSize: finalFontSize,
+        fontFamily: fontFamily,
+        lineHeight: lineHeight,
+        textWidth: textWidth,
+        textHeight: textHeight,
+        autoSized: autoSize && finalFontSize !== fontSize,
+        autoWrapped: autoWrap && textLines.length > 1
+      },
+      borderInfo: border ? {
+        type: border,
+        color: borderColor || (textStyle.color === '#FFFFFF' ? '#000000' : '#FFFFFF'),
+        width: borderWidth,
+        radius: borderRadius,
+        padding: borderPadding,
+        opacity: borderOpacity
+      } : null,
+      brightness: customColor ? null : await calculateRegionBrightness(
+        resolvedBackgroundPath, 
+        Math.floor(x - textWidth / 2), 
+        Math.floor(y - textHeight / 2), 
+        Math.floor(textWidth), 
+        Math.floor(textHeight)
+      )
+    };
+    
+  } catch (error) {
+    throw new Error(`Failed to composite title: ${error.message}`);
+  }
+}
+
+// Function to composite multiple text layers on image
+async function compositeTitleMulti(backgroundPath, layers, options = {}) {
+  if (!backgroundPath || typeof backgroundPath !== 'string') {
+    throw new Error('backgroundPath is required and must be a string');
+  }
+  if (!Array.isArray(layers) || layers.length === 0) {
+    throw new Error('layers must be a non-empty array');
+  }
+
+  // Resolve paths with default directories
+  const resolvedBackgroundPath = resolveBackgroundPath(backgroundPath);
+  const defaults = globalConfig.defaults || {};
+  const { outputPath = 'output.png' } = options;
+  const resolvedOutputPath = resolveOutputPath(outputPath);
+
+  try {
+    // Check if background file exists
+    try {
+      await fs.access(resolvedBackgroundPath);
+    } catch (error) {
+      throw new Error(`Background image not found: ${resolvedBackgroundPath}`);
+    }
+
+    // Validate image format
+    let metadata;
+    try {
+      const image = sharp(resolvedBackgroundPath);
+      metadata = await image.metadata();
+    } catch (error) {
+      throw new Error(`Failed to read image: ${error.message}`);
+    }
+
+    const supportedFormats = ['jpeg', 'png', 'webp', 'tiff', 'gif'];
+    if (!supportedFormats.includes(metadata.format)) {
+      throw new Error(`Unsupported image format: ${metadata.format}. Supported formats: ${supportedFormats.join(', ')}`);
+    }
+
+    // Check if output directory exists and is writable
+    const outputDir = path.dirname(path.resolve(resolvedOutputPath));
+    try {
+      await fs.access(outputDir, fsConstants.W_OK);
+    } catch (error) {
+      throw new Error(`Output directory is not writable: ${outputDir}`);
+    }
+
+    // Load background image
+    const background = await loadImage(resolvedBackgroundPath);
+    const canvas = new Canvas(background.width, background.height);
+    const ctx = canvas.getContext('2d');
+
+    // Draw background
+    ctx.drawImage(background, 0, 0);
+
+    // Process each layer
+    const layerResults = [];
+
+    for (let layerIndex = 0; layerIndex < layers.length; layerIndex++) {
+      const layer = layers[layerIndex];
+
+      // Validate layer has text
+      if (!layer.text || typeof layer.text !== 'string') {
+        throw new Error(`Layer ${layerIndex}: text is required and must be a string`);
+      }
+
+      // Merge layer options with defaults
+      const {
+        text,
+        fontSize = defaults.fontSize || 48,
+        fontFamily = defaults.fontFamily || 'Arial',
+        fontWeight = defaults.fontWeight || 'normal',
+        fontStyle = defaults.fontStyle || 'normal',
+        position = defaults.position || 'center',
+        offsetX = defaults.offsetX || 0,
+        offsetY = defaults.offsetY || 0,
+        x = null,
+        y = null,
+        enhanceContrast = defaults.enhanceContrast !== undefined ? defaults.enhanceContrast : true,
+        customColor = defaults.customColor || null,
+        customFontPath = defaults.customFontPath || null,
+        customFontPaths = defaults.customFontPaths || null,
+        border = defaults.border || null,
+        borderWidth = defaults.borderWidth || 2,
+        borderColor = defaults.borderColor || null,
+        borderRadius = defaults.borderRadius || 8,
+        borderPadding = defaults.borderPadding || 16,
+        borderOpacity = defaults.borderOpacity !== undefined ? defaults.borderOpacity : 0.8,
+        autoSize = defaults.autoSize !== undefined ? defaults.autoSize : false,
+        autoWrap = defaults.autoWrap !== undefined ? defaults.autoWrap : false,
+        maxWidthPercent = defaults.maxWidthPercent || 0.8,
+        maxHeightPercent = defaults.maxHeightPercent || 0.8,
+        minFontSize = defaults.minFontSize || 12,
+        maxFontSize = defaults.maxFontSize || 200,
+        lineHeight = defaults.lineHeight || 1.2,
+        textEffect = defaults.textEffect || null,
+        outlineWidth = defaults.outlineWidth || 3,
+        outlineColor = defaults.outlineColor || null,
+        glowRadius = defaults.glowRadius || 10,
+        glowIntensity = defaults.glowIntensity || 0.8,
+        gradientSampling = defaults.gradientSampling !== undefined ? defaults.gradientSampling : false,
+        writingMode = defaults.writingMode || 'horizontal',
+        characterSpacing = defaults.characterSpacing || 0,
+        verticalAlign = defaults.verticalAlign || 'center'
+      } = layer;
+
+      // Load custom fonts if specified
+      if (customFontPaths) {
+        await loadCustomFonts(customFontPaths, fontFamily);
+      } else if (customFontPath) {
+        await loadCustomFont(customFontPath, fontFamily);
+      } else if (globalConfig.fonts && globalConfig.fonts[fontFamily]) {
+        const fontPaths = globalConfig.fonts[fontFamily];
+        if (Array.isArray(fontPaths)) {
+          await loadCustomFonts(fontPaths, fontFamily);
+        } else {
+          await loadCustomFont(fontPaths, fontFamily);
+        }
+      }
+
+      // Calculate available space for text
+      const maxWidth = background.width * maxWidthPercent;
+      const maxHeight = background.height * maxHeightPercent;
+
+      // Process text based on options
+      let finalFontSize = fontSize;
+      let textLines = text.split('\n');
+      let totalTextHeight = fontSize;
+      let maxLineWidth = 0;
+
+      if (autoWrap || autoSize) {
+        ctx.font = buildFontDescriptor(fontSize, fontFamily, fontWeight, fontStyle);
+
+        if (autoWrap) {
+          textLines = wrapText(ctx, text, maxWidth);
+
+          if (autoSize) {
+            finalFontSize = calculateOptimalFontSizeForLines(
+              ctx,
+              textLines,
+              maxWidth,
+              maxHeight,
+              minFontSize,
+              autoSize ? maxFontSize : fontSize,
+              { fontFamily, fontWeight, fontStyle, lineHeight }
+            );
+          }
+        } else if (autoSize) {
+          finalFontSize = calculateOptimalFontSize(
+            ctx,
+            text,
+            maxWidth,
+            maxHeight,
+            minFontSize,
+            maxFontSize,
+            { fontFamily, fontWeight, fontStyle }
+          );
+        }
+      }
+
+      // Set final font
+      const fontDescriptor = buildFontDescriptor(finalFontSize, fontFamily, fontWeight, fontStyle);
+      ctx.font = fontDescriptor;
+      ctx.textAlign = 'center';
+      ctx.textBaseline = 'middle';
+
+      // If we wrapped text, recalculate lines with final font size
+      if (autoWrap && textLines.length > 1) {
+        textLines = wrapText(ctx, text, maxWidth);
+      }
+
+      // Calculate text dimensions
+      totalTextHeight = textLines.length * finalFontSize * lineHeight;
+      for (const line of textLines) {
+        const lineMetrics = ctx.measureText(line);
+        maxLineWidth = Math.max(maxLineWidth, lineMetrics.width);
+      }
+
+      const textWidth = maxLineWidth;
+      const textHeight = totalTextHeight;
+
+      // Calculate position
+      let posX, posY;
+
+      // If absolute coordinates are provided, use them
+      if (x !== null && y !== null) {
+        posX = x;
+        posY = y;
+      } else {
+        // Use position presets
+        switch (position) {
+          case 'top':
+            posX = background.width / 2 + offsetX;
+            posY = textHeight / 2 + 20 + offsetY;
+            break;
+          case 'bottom':
+            posX = background.width / 2 + offsetX;
+            posY = background.height - textHeight / 2 - 20 + offsetY;
+            break;
+          case 'center':
+          default:
+            posX = background.width / 2 + offsetX;
+            posY = background.height / 2 + offsetY;
+            break;
+        }
+      }
+
+      // Calculate brightness of text area if no custom color is specified
+      let textStyle;
+      if (customColor) {
+        textStyle = { color: customColor, shadow: null, shadowBlur: 0 };
+      } else {
+        const regionX = Math.max(0, posX - textWidth / 2 - 10);
+        const regionY = Math.max(0, posY - textHeight / 2 - 10);
+        const regionWidth = Math.min(textWidth + 20, background.width - regionX);
+        const regionHeight = Math.min(textHeight + 20, background.height - regionY);
+
+        const brightness = await calculateRegionBrightness(
+          resolvedBackgroundPath,
+          Math.floor(regionX),
+          Math.floor(regionY),
+          Math.floor(regionWidth),
+          Math.floor(regionHeight),
+          gradientSampling
+        );
+
+        textStyle = getOptimalTextColor(brightness, enhanceContrast);
+      }
+
+      // Draw border/frame if specified
+      if (border) {
+        const borderX = posX - textWidth / 2 - borderPadding;
+        const borderY = posY - textHeight / 2 - borderPadding;
+        const borderWidthTotal = textWidth + (borderPadding * 2);
+        const borderHeightTotal = textHeight + (borderPadding * 2);
+
+        const finalBorderColor = borderColor || (textStyle.color === '#FFFFFF' ? '#000000' : '#FFFFFF');
+
+        ctx.save();
+        ctx.globalAlpha = borderOpacity;
+
+        switch (border) {
+          case 'rectangle':
+            ctx.strokeStyle = finalBorderColor;
+            ctx.lineWidth = borderWidth;
+            ctx.strokeRect(borderX, borderY, borderWidthTotal, borderHeightTotal);
+            break;
+
+          case 'rounded':
+            ctx.strokeStyle = finalBorderColor;
+            ctx.lineWidth = borderWidth;
+            ctx.beginPath();
+            ctx.roundRect(borderX, borderY, borderWidthTotal, borderHeightTotal, borderRadius);
+            ctx.stroke();
+            break;
+
+          case 'filled':
+            ctx.fillStyle = finalBorderColor;
+            ctx.globalAlpha = borderOpacity * 0.7;
+            if (borderRadius > 0) {
+              ctx.beginPath();
+              ctx.roundRect(borderX, borderY, borderWidthTotal, borderHeightTotal, borderRadius);
+              ctx.fill();
+            } else {
+              ctx.fillRect(borderX, borderY, borderWidthTotal, borderHeightTotal);
+            }
+            break;
+
+          case 'outline':
+            ctx.strokeStyle = finalBorderColor;
+            ctx.lineWidth = borderWidth + 2;
+            ctx.globalAlpha = borderOpacity * 0.5;
+            ctx.beginPath();
+            ctx.roundRect(borderX - 1, borderY - 1, borderWidthTotal + 2, borderHeightTotal + 2, borderRadius + 1);
+            ctx.stroke();
+
+            ctx.strokeStyle = textStyle.color;
+            ctx.lineWidth = borderWidth;
+            ctx.globalAlpha = borderOpacity;
+            ctx.beginPath();
+            ctx.roundRect(borderX, borderY, borderWidthTotal, borderHeightTotal, borderRadius);
+            ctx.stroke();
+            break;
+        }
+
+        ctx.restore();
+      }
+
+      // Draw text with effects (same logic as compositeTitle)
+      ctx.save();
+
+      if (textEffect === 'outline') {
+        const finalOutlineColor = outlineColor || (textStyle.color === '#FFFFFF' ? '#000000' : '#FFFFFF');
+        ctx.strokeStyle = finalOutlineColor;
+        ctx.lineWidth = outlineWidth;
+        ctx.lineJoin = 'round';
+        ctx.miterLimit = 2;
+
+        if (textLines.length === 1) {
+          ctx.strokeText(text, posX, posY);
+          ctx.fillStyle = textStyle.color;
+          ctx.fillText(text, posX, posY);
+        } else {
+          const lineSpacing = finalFontSize * lineHeight;
+          const startY = posY - ((textLines.length - 1) * lineSpacing) / 2;
+
+          for (let i = 0; i < textLines.length; i++) {
+            const lineY = startY + (i * lineSpacing);
+            ctx.strokeText(textLines[i], posX, lineY);
+          }
+
+          ctx.fillStyle = textStyle.color;
+          for (let i = 0; i < textLines.length; i++) {
+            const lineY = startY + (i * lineSpacing);
+            ctx.fillText(textLines[i], posX, lineY);
+          }
+        }
+      } else if (textEffect === 'glow') {
+        const glowColor = outlineColor || textStyle.color;
+        ctx.shadowColor = glowColor;
+        ctx.shadowBlur = glowRadius;
+        ctx.globalAlpha = glowIntensity;
+
+        for (let i = 0; i < 3; i++) {
+          if (textLines.length === 1) {
+            ctx.fillStyle = glowColor;
+            ctx.fillText(text, posX, posY);
+          } else {
+            const lineSpacing = finalFontSize * lineHeight;
+            const startY = posY - ((textLines.length - 1) * lineSpacing) / 2;
+
+            for (let j = 0; j < textLines.length; j++) {
+              const lineY = startY + (j * lineSpacing);
+              ctx.fillStyle = glowColor;
+              ctx.fillText(textLines[j], posX, lineY);
+            }
+          }
+        }
+
+        ctx.shadowBlur = 0;
+        ctx.globalAlpha = 1;
+        ctx.fillStyle = textStyle.color;
+
+        if (textLines.length === 1) {
+          ctx.fillText(text, posX, posY);
+        } else {
+          const lineSpacing = finalFontSize * lineHeight;
+          const startY = posY - ((textLines.length - 1) * lineSpacing) / 2;
+
+          for (let i = 0; i < textLines.length; i++) {
+            const lineY = startY + (i * lineSpacing);
+            ctx.fillText(textLines[i], posX, lineY);
+          }
+        }
+      } else if (textEffect === 'emboss') {
+        const embossColor = outlineColor || (textStyle.color === '#FFFFFF' ? '#666666' : '#FFFFFF');
+
+        ctx.fillStyle = '#00000033';
+        if (textLines.length === 1) {
+          ctx.fillText(text, posX + 2, posY + 2);
+        } else {
+          const lineSpacing = finalFontSize * lineHeight;
+          const startY = posY - ((textLines.length - 1) * lineSpacing) / 2;
+          for (let i = 0; i < textLines.length; i++) {
+            const lineY = startY + (i * lineSpacing);
+            ctx.fillText(textLines[i], posX + 2, lineY + 2);
+          }
+        }
+
+        ctx.fillStyle = embossColor;
+        if (textLines.length === 1) {
+          ctx.fillText(text, posX - 1, posY - 1);
+        } else {
+          const lineSpacing = finalFontSize * lineHeight;
+          const startY = posY - ((textLines.length - 1) * lineSpacing) / 2;
+          for (let i = 0; i < textLines.length; i++) {
+            const lineY = startY + (i * lineSpacing);
+            ctx.fillText(textLines[i], posX - 1, lineY - 1);
+          }
+        }
+
+        ctx.fillStyle = textStyle.color;
+        if (textLines.length === 1) {
+          ctx.fillText(text, posX, posY);
+        } else {
+          const lineSpacing = finalFontSize * lineHeight;
+          const startY = posY - ((textLines.length - 1) * lineSpacing) / 2;
+          for (let i = 0; i < textLines.length; i++) {
+            const lineY = startY + (i * lineSpacing);
+            ctx.fillText(textLines[i], posX, lineY);
+          }
+        }
+      } else {
+        if (textStyle.shadow && textStyle.shadowBlur > 0) {
+          ctx.shadowColor = textStyle.shadow;
+          ctx.shadowBlur = textStyle.shadowBlur;
+          ctx.shadowOffsetX = 1;
+          ctx.shadowOffsetY = 1;
+        }
+
+        ctx.fillStyle = textStyle.color;
+
+        if (textLines.length === 1) {
+          ctx.fillText(text, posX, posY);
+        } else {
+          const lineSpacing = finalFontSize * lineHeight;
+          const startY = posY - ((textLines.length - 1) * lineSpacing) / 2;
+
+          for (let i = 0; i < textLines.length; i++) {
+            const lineY = startY + (i * lineSpacing);
+            ctx.fillText(textLines[i], posX, lineY);
+          }
+        }
+      }
+
+      ctx.restore();
+
+      // Store layer result
+      layerResults.push({
+        text,
+        lines: textLines,
+        position: { x: posX, y: posY },
+        fontSize: finalFontSize,
+        fontFamily,
+        textWidth,
+        textHeight,
+        textStyle,
+        autoSized: autoSize && finalFontSize !== fontSize,
+        autoWrapped: autoWrap && textLines.length > 1
+      });
+    }
+
+    // Save the result
+    const buffer = await canvas.toBuffer('image/png');
+    await fs.writeFile(resolvedOutputPath, buffer);
+
+    return {
+      success: true,
+      outputPath: resolvedOutputPath,
+      dimensions: { width: background.width, height: background.height },
+      layers: layerResults,
+      layerCount: layers.length
+    };
+
+  } catch (error) {
+    throw new Error(`Failed to composite multi-layer title: ${error.message}`);
+  }
+}
+
+// List available tools
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [
+      {
+        name: 'composite_title',
+        description: 'Composite title text on a background image with automatic brightness adjustment',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            backgroundPath: {
+              type: 'string',
+              description: 'Path to the background image file'
+            },
+            title: {
+              type: 'string',
+              description: 'Title text to composite on the image'
+            },
+            outputPath: {
+              type: 'string',
+              description: 'Output file path (default: output.png)',
+              default: 'output.png'
+            },
+            fontSize: {
+              type: 'number',
+              description: 'Font size in pixels (default: 48)',
+              default: 48
+            },
+            fontFamily: {
+              type: 'string',
+              description: 'Font family (default: Arial)',
+              default: 'Arial'
+            },
+            position: {
+              type: 'string',
+              enum: ['top', 'center', 'bottom'],
+              description: 'Text position (default: center)',
+              default: 'center'
+            },
+            offsetX: {
+              type: 'number',
+              description: 'Horizontal offset in pixels (default: 0)',
+              default: 0
+            },
+            offsetY: {
+              type: 'number',
+              description: 'Vertical offset in pixels (default: 0)',
+              default: 0
+            },
+            enhanceContrast: {
+              type: 'boolean',
+              description: 'Add shadow for better contrast (default: true)',
+              default: true
+            },
+            customColor: {
+              type: 'string',
+              description: 'Custom text color (hex format, overrides auto-detection)',
+              default: null
+            },
+            border: {
+              type: 'string',
+              enum: ['rectangle', 'rounded', 'filled', 'outline'],
+              description: 'Border type around text (default: none)',
+              default: null
+            },
+            borderWidth: {
+              type: 'number',
+              description: 'Border width in pixels (default: 2)',
+              default: 2
+            },
+            borderColor: {
+              type: 'string',
+              description: 'Border color (hex format, auto-detected if not specified)',
+              default: null
+            },
+            borderRadius: {
+              type: 'number',
+              description: 'Border radius for rounded borders (default: 8)',
+              default: 8
+            },
+            borderPadding: {
+              type: 'number',
+              description: 'Padding around text inside border (default: 16)',
+              default: 16
+            },
+            borderOpacity: {
+              type: 'number',
+              description: 'Border opacity (0-1, default: 0.8)',
+              default: 0.8,
+              minimum: 0,
+              maximum: 1
+            },
+            autoSize: {
+              type: 'boolean',
+              description: 'Automatically calculate font size to fit within image bounds (default: false)',
+              default: false
+            },
+            autoWrap: {
+              type: 'boolean',
+              description: 'Automatically wrap long text into multiple lines (default: false)',
+              default: false
+            },
+            maxWidthPercent: {
+              type: 'number',
+              description: 'Maximum width as percentage of image width for auto-sizing/wrapping (default: 0.8)',
+              default: 0.8,
+              minimum: 0.1,
+              maximum: 1.0
+            },
+            maxHeightPercent: {
+              type: 'number',
+              description: 'Maximum height as percentage of image height for auto-sizing/wrapping (default: 0.8)',
+              default: 0.8,
+              minimum: 0.1,
+              maximum: 1.0
+            },
+            minFontSize: {
+              type: 'number',
+              description: 'Minimum font size when auto-sizing (default: 12)',
+              default: 12,
+              minimum: 8
+            },
+            maxFontSize: {
+              type: 'number',
+              description: 'Maximum font size when auto-sizing (default: 200)',
+              default: 200,
+              minimum: 12
+            },
+            lineHeight: {
+              type: 'number',
+              description: 'Line height multiplier for multi-line text (default: 1.2)',
+              default: 1.2,
+              minimum: 0.8,
+              maximum: 3.0
+            },
+            textEffect: {
+              type: 'string',
+              enum: ['outline', 'glow', 'emboss'],
+              description: 'Text effect type (default: none)',
+              default: null
+            },
+            outlineWidth: {
+              type: 'number',
+              description: 'Outline width in pixels for outline effect (default: 3)',
+              default: 3
+            },
+            outlineColor: {
+              type: 'string',
+              description: 'Outline/glow color (hex format, auto-detected if not specified)',
+              default: null
+            },
+            glowRadius: {
+              type: 'number',
+              description: 'Glow radius for glow effect (default: 10)',
+              default: 10
+            },
+            glowIntensity: {
+              type: 'number',
+              description: 'Glow intensity (0-1, default: 0.8)',
+              default: 0.8,
+              minimum: 0,
+              maximum: 1
+            },
+            gradientSampling: {
+              type: 'boolean',
+              description: 'Use multi-point sampling for gradient backgrounds (default: false)',
+              default: false
+            },
+            customFontPath: {
+              type: 'string',
+              description: 'Path to custom font file (.ttf or .otf)',
+              default: null
+            },
+            customFontPaths: {
+              type: 'array',
+              items: { type: 'string' },
+              description: 'Array of paths to font variant files (regular, bold, italic, etc.)',
+              default: null
+            },
+            fontWeight: {
+              type: 'string',
+              enum: ['normal', 'bold', '100', '200', '300', '400', '500', '600', '700', '800', '900'],
+              description: 'Font weight (default: normal)',
+              default: 'normal'
+            },
+            fontStyle: {
+              type: 'string',
+              enum: ['normal', 'italic', 'oblique'],
+              description: 'Font style (default: normal)',
+              default: 'normal'
+            }
+          },
+          required: ['backgroundPath', 'title']
+        }
+      },
+      {
+        name: 'analyze_brightness',
+        description: 'Analyze brightness of an image region',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            imagePath: {
+              type: 'string',
+              description: 'Path to the image file'
+            },
+            x: {
+              type: 'number',
+              description: 'X coordinate of the region (default: 0)',
+              default: 0
+            },
+            y: {
+              type: 'number',
+              description: 'Y coordinate of the region (default: 0)',
+              default: 0
+            },
+            width: {
+              type: 'number',
+              description: 'Width of the region (default: entire image width)',
+              default: null
+            },
+            height: {
+              type: 'number',
+              description: 'Height of the region (default: entire image height)',
+              default: null
+            }
+          },
+          required: ['imagePath']
+        }
+      },
+      {
+        name: 'get_config',
+        description: 'Get current configuration and path resolution information for debugging',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            testPath: {
+              type: 'string',
+              description: 'Optional test path to see how it would be resolved',
+              default: null
+            }
+          }
+        }
+      },
+      {
+        name: 'composite_title_multi',
+        description: 'Composite multiple text layers on a background image with individual font/size/position control for each layer. Perfect for creating complex layouts with main title, subtitle, date, etc. Each layer can have different fonts, sizes, positions, and effects.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            backgroundPath: {
+              type: 'string',
+              description: 'Path to the background image file'
+            },
+            outputPath: {
+              type: 'string',
+              description: 'Output file path (default: output.png)',
+              default: 'output.png'
+            },
+            layers: {
+              type: 'array',
+              description: 'Array of text layers to composite. Each layer is rendered in order (later layers appear on top)',
+              items: {
+                type: 'object',
+                properties: {
+                  text: {
+                    type: 'string',
+                    description: 'Text content for this layer (required)'
+                  },
+                  fontSize: {
+                    type: 'number',
+                    description: 'Font size in pixels (inherits from defaults if not specified)'
+                  },
+                  fontFamily: {
+                    type: 'string',
+                    description: 'Font family (inherits from defaults if not specified)'
+                  },
+                  fontWeight: {
+                    type: 'string',
+                    enum: ['normal', 'bold', '100', '200', '300', '400', '500', '600', '700', '800', '900'],
+                    description: 'Font weight'
+                  },
+                  fontStyle: {
+                    type: 'string',
+                    enum: ['normal', 'italic', 'oblique'],
+                    description: 'Font style'
+                  },
+                  position: {
+                    type: 'string',
+                    enum: ['top', 'center', 'bottom'],
+                    description: 'Text position preset (can be combined with offsetX/offsetY)'
+                  },
+                  x: {
+                    type: 'number',
+                    description: 'Absolute X coordinate (overrides position preset)'
+                  },
+                  y: {
+                    type: 'number',
+                    description: 'Absolute Y coordinate (overrides position preset)'
+                  },
+                  offsetX: {
+                    type: 'number',
+                    description: 'Horizontal offset in pixels from position preset'
+                  },
+                  offsetY: {
+                    type: 'number',
+                    description: 'Vertical offset in pixels from position preset'
+                  },
+                  enhanceContrast: {
+                    type: 'boolean',
+                    description: 'Add shadow for better contrast'
+                  },
+                  customColor: {
+                    type: 'string',
+                    description: 'Custom text color (hex format, overrides auto-detection)'
+                  },
+                  border: {
+                    type: 'string',
+                    enum: ['rectangle', 'rounded', 'filled', 'outline'],
+                    description: 'Border type around text'
+                  },
+                  borderWidth: {
+                    type: 'number',
+                    description: 'Border width in pixels'
+                  },
+                  borderColor: {
+                    type: 'string',
+                    description: 'Border color (hex format)'
+                  },
+                  borderRadius: {
+                    type: 'number',
+                    description: 'Border radius for rounded borders'
+                  },
+                  borderPadding: {
+                    type: 'number',
+                    description: 'Padding around text inside border'
+                  },
+                  borderOpacity: {
+                    type: 'number',
+                    description: 'Border opacity (0-1)',
+                    minimum: 0,
+                    maximum: 1
+                  },
+                  autoSize: {
+                    type: 'boolean',
+                    description: 'Automatically calculate font size to fit within bounds'
+                  },
+                  autoWrap: {
+                    type: 'boolean',
+                    description: 'Automatically wrap long text into multiple lines'
+                  },
+                  maxWidthPercent: {
+                    type: 'number',
+                    description: 'Maximum width as percentage of image width',
+                    minimum: 0.1,
+                    maximum: 1.0
+                  },
+                  maxHeightPercent: {
+                    type: 'number',
+                    description: 'Maximum height as percentage of image height',
+                    minimum: 0.1,
+                    maximum: 1.0
+                  },
+                  textEffect: {
+                    type: 'string',
+                    enum: ['outline', 'glow', 'emboss'],
+                    description: 'Text effect type'
+                  },
+                  outlineWidth: {
+                    type: 'number',
+                    description: 'Outline width in pixels for outline effect'
+                  },
+                  outlineColor: {
+                    type: 'string',
+                    description: 'Outline/glow color (hex format)'
+                  },
+                  customFontPath: {
+                    type: 'string',
+                    description: 'Path to custom font file (.ttf or .otf)'
+                  },
+                  customFontPaths: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Array of paths to font variant files'
+                  }
+                },
+                required: ['text']
+              }
+            }
+          },
+          required: ['backgroundPath', 'layers']
+        }
+      }
+    ]
+  };
+});
+
+// Handle tool calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  
+  try {
+    switch (name) {
+      case 'composite_title':
+        const result = await compositeTitle(args.backgroundPath, args.title, args);
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+        
+      case 'analyze_brightness':
+        const image = sharp(args.imagePath);
+        const metadata = await image.metadata();
+
+        const width = args.width || metadata.width;
+        const height = args.height || metadata.height;
+
+        const brightness = await calculateRegionBrightness(
+          args.imagePath,
+          args.x || 0,
+          args.y || 0,
+          width,
+          height
+        );
+
+        const recommendedColor = getOptimalTextColor(brightness, true);
+
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify({
+                brightness,
+                recommendedTextColor: recommendedColor.color,
+                recommendedShadow: recommendedColor.shadow,
+                isLightBackground: brightness > 128,
+                region: {
+                  x: args.x || 0,
+                  y: args.y || 0,
+                  width,
+                  height
+                }
+              }, null, 2)
+            }
+          ]
+        };
+
+      case 'get_config':
+        const configInfo = {
+          configLoaded: Object.keys(globalConfig).length > 0,
+          globalConfig: globalConfig,
+          environment: {
+            platform: process.platform,
+            cwd: process.cwd(),
+            homeDir: homedir(),
+            nodeVersion: process.version
+          },
+          configSearchPaths: [
+            process.env.MCP_IMAGE_TITLE_CONFIG || '(not set)',
+            path.join(process.cwd(), '.mcp-image-title.json'),
+            path.join(homedir(), '.mcp-image-title.json')
+          ]
+        };
+
+        // Test path resolution if provided
+        if (args.testPath) {
+          configInfo.pathResolution = {
+            input: args.testPath,
+            resolvedAsBackground: resolveBackgroundPath(args.testPath),
+            resolvedAsOutput: resolveOutputPath(args.testPath),
+            resolvedAsFont: resolveFontPath(args.testPath),
+            isAbsolute: path.isAbsolute(args.testPath),
+            startsWithDotSlash: args.testPath.startsWith('./') || args.testPath.startsWith('../')
+          };
+
+          // Check if resolved path exists
+          try {
+            await fs.access(resolveBackgroundPath(args.testPath));
+            configInfo.pathResolution.backgroundPathExists = true;
+          } catch {
+            configInfo.pathResolution.backgroundPathExists = false;
+          }
+        }
+
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(configInfo, null, 2)
+            }
+          ]
+        };
+
+      case 'composite_title_multi':
+        const multiResult = await compositeTitleMulti(args.backgroundPath, args.layers, args);
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(multiResult, null, 2)
+            }
+          ]
+        };
+
+
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Error: ${error.message}`
+        }
+      ],
+      isError: true
+    };
+  }
+});
+
+// Start the server
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('MCP Image Title Server running on stdio');
+}
+
+main().catch((error) => {
+  console.error('Server error:', error);
+  process.exit(1);
+});