psd-mcp-server 1.0.0

package/dist/index.js

@@ -0,0 +1,2098 @@
+#!/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 "ag-psd/initialize-canvas.js";
+import { readPsd } from "ag-psd";
+import * as fs from "fs";
+import * as path from "path";
+import { createCanvas } from "canvas";
+// Helper: Color to hex (ag-psd uses different color formats)
+function colorToHex(color) {
+    if (!color)
+        return undefined;
+    // Handle FRGB format (0-1 range)
+    if (typeof color.fr === "number") {
+        const r = Math.round(color.fr * 255)
+            .toString(16)
+            .padStart(2, "0");
+        const g = Math.round(color.fg * 255)
+            .toString(16)
+            .padStart(2, "0");
+        const b = Math.round(color.fb * 255)
+            .toString(16)
+            .padStart(2, "0");
+        return `#${r}${g}${b}`;
+    }
+    // Handle RGB format (0-255 range)
+    if (typeof color.r === "number") {
+        const r = Math.round(color.r).toString(16).padStart(2, "0");
+        const g = Math.round(color.g).toString(16).padStart(2, "0");
+        const b = Math.round(color.b).toString(16).padStart(2, "0");
+        return `#${r}${g}${b}`;
+    }
+    return undefined;
+}
+// Extract layer info recursively
+function extractLayerInfo(layer) {
+    const bounds = {
+        left: layer.left ?? 0,
+        top: layer.top ?? 0,
+        width: (layer.right ?? 0) - (layer.left ?? 0),
+        height: (layer.bottom ?? 0) - (layer.top ?? 0),
+    };
+    let type = "unknown";
+    let textInfo;
+    // Determine layer type
+    if (layer.text) {
+        type = "text";
+        const style = layer.text.style;
+        textInfo = {
+            content: layer.text.text || "",
+            font: style?.font?.name,
+            fontSize: style?.fontSize,
+            color: colorToHex(style?.fillColor),
+            lineHeight: style?.leading,
+            letterSpacing: style?.tracking,
+        };
+    }
+    else if (layer.children && layer.children.length > 0) {
+        type = "group";
+    }
+    else if (layer.canvas) {
+        type = "image";
+    }
+    else if (layer.vectorMask || layer.vectorStroke) {
+        type = "shape";
+    }
+    const info = {
+        name: layer.name || "Unnamed",
+        type,
+        visible: !layer.hidden,
+        opacity: layer.opacity !== undefined ? layer.opacity / 255 : 1,
+        bounds,
+    };
+    if (textInfo) {
+        info.text = textInfo;
+    }
+    if (layer.children && layer.children.length > 0) {
+        info.children = layer.children.map(extractLayerInfo);
+    }
+    return info;
+}
+// Parse PSD file
+function parsePsdFile(filePath) {
+    const absolutePath = path.resolve(filePath);
+    if (!fs.existsSync(absolutePath)) {
+        throw new Error(`File not found: ${absolutePath}`);
+    }
+    const buffer = fs.readFileSync(absolutePath);
+    const psd = readPsd(buffer, {
+        skipCompositeImageData: true,
+        skipLayerImageData: true,
+        skipThumbnail: true,
+    });
+    const colorModes = {
+        0: "Bitmap",
+        1: "Grayscale",
+        2: "Indexed",
+        3: "RGB",
+        4: "CMYK",
+        7: "Multichannel",
+        8: "Duotone",
+        9: "Lab",
+    };
+    return {
+        width: psd.width,
+        height: psd.height,
+        colorMode: colorModes[psd.colorMode ?? 3] || "Unknown",
+        bitsPerChannel: psd.bitsPerChannel ?? 8,
+        layers: psd.children?.map(extractLayerInfo) || [],
+    };
+}
+// Convert VectorContent color to CSS color string
+function vectorContentToColor(content) {
+    if (!content)
+        return undefined;
+    if (content.type === "color") {
+        const color = content.color;
+        if ("r" in color) {
+            return `rgb(${Math.round(color.r)}, ${Math.round(color.g)}, ${Math.round(color.b)})`;
+        }
+    }
+    return undefined;
+}
+// Convert Bezier paths to SVG path data
+function bezierPathsToSvgPath(paths, width, height) {
+    const pathData = [];
+    for (const bezierPath of paths) {
+        const knots = bezierPath.knots;
+        if (knots.length === 0)
+            continue;
+        // PSD bezier points are normalized (0-1), scale to document size
+        // points array: [prevAnchorX, prevAnchorY, anchorX, anchorY, nextAnchorX, nextAnchorY]
+        const scaleX = (v) => (v * width).toFixed(2);
+        const scaleY = (v) => (v * height).toFixed(2);
+        // Start with first knot
+        const firstKnot = knots[0];
+        const startX = scaleX(firstKnot.points[2]);
+        const startY = scaleY(firstKnot.points[3]);
+        pathData.push(`M ${startX} ${startY}`);
+        // Draw curves between knots
+        for (let i = 0; i < knots.length; i++) {
+            const currentKnot = knots[i];
+            const nextKnot = knots[(i + 1) % knots.length];
+            // Skip last segment if path is open
+            if (bezierPath.open && i === knots.length - 1)
+                break;
+            // Control point 1: current knot's "next" anchor
+            const cp1x = scaleX(currentKnot.points[4]);
+            const cp1y = scaleY(currentKnot.points[5]);
+            // Control point 2: next knot's "prev" anchor
+            const cp2x = scaleX(nextKnot.points[0]);
+            const cp2y = scaleY(nextKnot.points[1]);
+            // End point: next knot's anchor
+            const endX = scaleX(nextKnot.points[2]);
+            const endY = scaleY(nextKnot.points[3]);
+            pathData.push(`C ${cp1x} ${cp1y}, ${cp2x} ${cp2y}, ${endX} ${endY}`);
+        }
+        // Close path if not open
+        if (!bezierPath.open) {
+            pathData.push("Z");
+        }
+    }
+    return pathData.join(" ");
+}
+// Find vector layer by name
+function findVectorLayer(layers, name) {
+    for (const layer of layers) {
+        if (layer.name?.toLowerCase().includes(name.toLowerCase()) &&
+            layer.vectorMask) {
+            return layer;
+        }
+        if (layer.children) {
+            const found = findVectorLayer(layer.children, name);
+            if (found)
+                return found;
+        }
+    }
+    return null;
+}
+// Get all vector layers
+function getAllVectorLayers(layers) {
+    const result = [];
+    function traverse(items) {
+        for (const layer of items) {
+            if (layer.vectorMask) {
+                result.push(layer);
+            }
+            if (layer.children) {
+                traverse(layer.children);
+            }
+        }
+    }
+    traverse(layers);
+    return result;
+}
+// Convert a vector layer to SVG string
+function vectorLayerToSvg(layer, width, height) {
+    if (!layer.vectorMask) {
+        throw new Error("Layer does not have vector data");
+    }
+    const paths = layer.vectorMask.paths;
+    const svgPath = bezierPathsToSvgPath(paths, width, height);
+    // Get fill color
+    const fillColor = vectorContentToColor(layer.vectorFill) || "#000000";
+    // Get stroke info
+    const stroke = layer.vectorStroke;
+    const strokeColor = stroke?.content
+        ? vectorContentToColor(stroke.content)
+        : undefined;
+    const strokeWidth = stroke?.lineWidth?.value || 0;
+    const strokeEnabled = stroke?.strokeEnabled !== false && strokeWidth > 0;
+    // Build SVG
+    const svgParts = [
+        `<?xml version="1.0" encoding="UTF-8"?>`,
+        `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}">`,
+        `  <path d="${svgPath}"`,
+        `        fill="${layer.vectorFill ? fillColor : "none"}"`,
+    ];
+    if (strokeEnabled && strokeColor) {
+        svgParts.push(`        stroke="${strokeColor}"`);
+        svgParts.push(`        stroke-width="${strokeWidth}"`);
+        if (stroke?.lineCapType) {
+            svgParts.push(`        stroke-linecap="${stroke.lineCapType}"`);
+        }
+        if (stroke?.lineJoinType) {
+            svgParts.push(`        stroke-linejoin="${stroke.lineJoinType}"`);
+        }
+    }
+    svgParts.push(`  />`);
+    svgParts.push(`</svg>`);
+    return svgParts.join("\n");
+}
+// Get all image layers (layers with canvas data)
+function getAllImageLayers(layers) {
+    const result = [];
+    function traverse(items) {
+        for (const layer of items) {
+            // Has canvas and is not a group
+            if (layer.canvas && !layer.children) {
+                result.push(layer);
+            }
+            if (layer.children) {
+                traverse(layer.children);
+            }
+        }
+    }
+    traverse(layers);
+    return result;
+}
+// Get image layers from a specific group
+function getImageLayersFromGroup(layers, groupName) {
+    // Find the group first
+    function findGroup(items) {
+        for (const layer of items) {
+            if (layer.name?.toLowerCase().includes(groupName.toLowerCase()) &&
+                layer.children) {
+                return layer;
+            }
+            if (layer.children) {
+                const found = findGroup(layer.children);
+                if (found)
+                    return found;
+            }
+        }
+        return null;
+    }
+    const group = findGroup(layers);
+    if (!group || !group.children)
+        return [];
+    return getAllImageLayers(group.children);
+}
+// Export layer canvas to image buffer (PNG or JPG)
+function layerToImageBuffer(layer, scale = 2, format = "png", quality = 90) {
+    if (!layer.canvas)
+        return null;
+    const srcCanvas = layer.canvas;
+    const width = srcCanvas.width * scale;
+    const height = srcCanvas.height * scale;
+    // Create scaled canvas
+    const canvas = createCanvas(width, height);
+    const ctx = canvas.getContext("2d");
+    // For JPG, fill with white background (no transparency support)
+    if (format === "jpg") {
+        ctx.fillStyle = "#FFFFFF";
+        ctx.fillRect(0, 0, width, height);
+    }
+    // Scale and draw
+    ctx.scale(scale, scale);
+    ctx.drawImage(srcCanvas, 0, 0);
+    if (format === "jpg") {
+        return canvas.toBuffer("image/jpeg", { quality: quality / 100 });
+    }
+    return canvas.toBuffer("image/png");
+}
+// Sanitize filename
+function sanitizeFilename(name) {
+    return name.replace(/[<>:"/\\|?*]/g, "_").replace(/\s+/g, "_");
+}
+// Convert any Color type to hex
+function anyColorToHex(color) {
+    if (!color)
+        return null;
+    let r, g, b;
+    // FRGB format (0-1 range)
+    if (typeof color.fr === "number") {
+        r = Math.round(color.fr * 255);
+        g = Math.round(color.fg * 255);
+        b = Math.round(color.fb * 255);
+    }
+    // RGB/RGBA format (0-255 range)
+    else if (typeof color.r === "number") {
+        r = Math.round(color.r);
+        g = Math.round(color.g);
+        b = Math.round(color.b);
+    }
+    // Grayscale
+    else if (typeof color.k === "number" && !("c" in color)) {
+        const gray = Math.round((1 - color.k) * 255);
+        r = g = b = gray;
+    }
+    // HSB - convert to RGB
+    else if (typeof color.h === "number" &&
+        typeof color.s === "number" &&
+        typeof color.b === "number") {
+        const h = color.h / 360;
+        const s = color.s;
+        const v = color.b;
+        const i = Math.floor(h * 6);
+        const f = h * 6 - i;
+        const p = v * (1 - s);
+        const q = v * (1 - f * s);
+        const t = v * (1 - (1 - f) * s);
+        switch (i % 6) {
+            case 0:
+                r = v * 255;
+                g = t * 255;
+                b = p * 255;
+                break;
+            case 1:
+                r = q * 255;
+                g = v * 255;
+                b = p * 255;
+                break;
+            case 2:
+                r = p * 255;
+                g = v * 255;
+                b = t * 255;
+                break;
+            case 3:
+                r = p * 255;
+                g = q * 255;
+                b = v * 255;
+                break;
+            case 4:
+                r = t * 255;
+                g = p * 255;
+                b = v * 255;
+                break;
+            case 5:
+                r = v * 255;
+                g = p * 255;
+                b = q * 255;
+                break;
+            default:
+                r = g = b = 0;
+        }
+        r = Math.round(r);
+        g = Math.round(g);
+        b = Math.round(b);
+    }
+    // LAB - simplified conversion
+    else if (typeof color.l === "number" && typeof color.a === "number") {
+        // Simplified LAB to RGB
+        const y = (color.l + 16) / 116;
+        const x = color.a / 500 + y;
+        const z = y - color.b / 200;
+        const x3 = x * x * x;
+        const y3 = y * y * y;
+        const z3 = z * z * z;
+        const xn = x3 > 0.008856 ? x3 : (x - 16 / 116) / 7.787;
+        const yn = y3 > 0.008856 ? y3 : (y - 16 / 116) / 7.787;
+        const zn = z3 > 0.008856 ? z3 : (z - 16 / 116) / 7.787;
+        // XYZ to RGB
+        const xr = xn * 0.95047;
+        const yr = yn * 1.0;
+        const zr = zn * 1.08883;
+        r = Math.round(Math.max(0, Math.min(255, (xr * 3.2406 + yr * -1.5372 + zr * -0.4986) * 255)));
+        g = Math.round(Math.max(0, Math.min(255, (xr * -0.9689 + yr * 1.8758 + zr * 0.0415) * 255)));
+        b = Math.round(Math.max(0, Math.min(255, (xr * 0.0557 + yr * -0.204 + zr * 1.057) * 255)));
+    }
+    // CMYK
+    else if (typeof color.c === "number" &&
+        typeof color.m === "number" &&
+        typeof color.y === "number" &&
+        typeof color.k === "number") {
+        r = Math.round(255 * (1 - color.c) * (1 - color.k));
+        g = Math.round(255 * (1 - color.m) * (1 - color.k));
+        b = Math.round(255 * (1 - color.y) * (1 - color.k));
+    }
+    else {
+        return null;
+    }
+    // Clamp values
+    r = Math.max(0, Math.min(255, r));
+    g = Math.max(0, Math.min(255, g));
+    b = Math.max(0, Math.min(255, b));
+    return `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`.toUpperCase();
+}
+// Extract all colors from a layer
+function extractColorsFromLayer(layer, layerName) {
+    const colors = [];
+    const gradients = [];
+    const addColor = (color, source) => {
+        const hex = anyColorToHex(color);
+        if (hex) {
+            const r = parseInt(hex.slice(1, 3), 16);
+            const g = parseInt(hex.slice(3, 5), 16);
+            const b = parseInt(hex.slice(5, 7), 16);
+            colors.push({ hex, rgb: { r, g, b }, source, layerName });
+        }
+    };
+    const addGradient = (gradient, source) => {
+        if (gradient?.colorStops) {
+            const gradientColors = gradient.colorStops
+                .map((stop) => anyColorToHex(stop.color))
+                .filter((c) => c !== null);
+            if (gradientColors.length > 0) {
+                gradients.push({
+                    name: gradient.name,
+                    colors: gradientColors,
+                    source,
+                    layerName,
+                });
+            }
+        }
+    };
+    // Text color
+    if (layer.text?.style?.fillColor) {
+        addColor(layer.text.style.fillColor, "text");
+    }
+    // Vector fill
+    if (layer.vectorFill) {
+        if (layer.vectorFill.type === "color") {
+            addColor(layer.vectorFill.color, "vector-fill");
+        }
+        else if ("colorStops" in layer.vectorFill) {
+            addGradient(layer.vectorFill, "vector-fill-gradient");
+        }
+    }
+    // Vector stroke
+    if (layer.vectorStroke?.content) {
+        if (layer.vectorStroke.content.type === "color") {
+            addColor(layer.vectorStroke.content.color, "vector-stroke");
+        }
+        else if ("colorStops" in layer.vectorStroke.content) {
+            addGradient(layer.vectorStroke.content, "vector-stroke-gradient");
+        }
+    }
+    // Layer effects
+    const effects = layer.effects;
+    if (effects) {
+        // Drop shadow
+        effects.dropShadow?.forEach((shadow, i) => {
+            if (shadow.enabled !== false && shadow.color) {
+                addColor(shadow.color, `drop-shadow${i > 0 ? `-${i + 1}` : ""}`);
+            }
+        });
+        // Inner shadow
+        effects.innerShadow?.forEach((shadow, i) => {
+            if (shadow.enabled !== false && shadow.color) {
+                addColor(shadow.color, `inner-shadow${i > 0 ? `-${i + 1}` : ""}`);
+            }
+        });
+        // Outer glow
+        if (effects.outerGlow?.enabled !== false && effects.outerGlow?.color) {
+            addColor(effects.outerGlow.color, "outer-glow");
+        }
+        // Inner glow
+        if (effects.innerGlow?.enabled !== false && effects.innerGlow?.color) {
+            addColor(effects.innerGlow.color, "inner-glow");
+        }
+        // Color overlay (solid fill)
+        effects.solidFill?.forEach((fill, i) => {
+            if (fill.enabled !== false && fill.color) {
+                addColor(fill.color, `color-overlay${i > 0 ? `-${i + 1}` : ""}`);
+            }
+        });
+        // Stroke effect
+        effects.stroke?.forEach((stroke, i) => {
+            if (stroke.enabled !== false) {
+                if (stroke.color) {
+                    addColor(stroke.color, `stroke-effect${i > 0 ? `-${i + 1}` : ""}`);
+                }
+                if (stroke.gradient) {
+                    addGradient(stroke.gradient, `stroke-gradient${i > 0 ? `-${i + 1}` : ""}`);
+                }
+            }
+        });
+        // Satin
+        if (effects.satin?.enabled !== false && effects.satin?.color) {
+            addColor(effects.satin.color, "satin");
+        }
+        // Gradient overlay
+        effects.gradientOverlay?.forEach((overlay, i) => {
+            if (overlay.enabled !== false && overlay.gradient) {
+                addGradient(overlay.gradient, `gradient-overlay${i > 0 ? `-${i + 1}` : ""}`);
+            }
+        });
+    }
+    return { colors, gradients };
+}
+// Extract all colors from PSD
+function extractAllColors(layers) {
+    const allColors = [];
+    const allGradients = [];
+    function traverse(items) {
+        for (const layer of items) {
+            const { colors, gradients } = extractColorsFromLayer(layer, layer.name || "Unnamed");
+            allColors.push(...colors);
+            allGradients.push(...gradients);
+            if (layer.children) {
+                traverse(layer.children);
+            }
+        }
+    }
+    traverse(layers);
+    // Get unique colors
+    const uniqueColors = [...new Set(allColors.map((c) => c.hex))].sort();
+    return {
+        solidColors: allColors,
+        gradients: allGradients,
+        uniqueColors,
+    };
+}
+// Format layers as tree structure
+function formatLayerTree(layers, prefix = "") {
+    const lines = [];
+    layers.forEach((layer, index) => {
+        const isLast = index === layers.length - 1;
+        const connector = isLast ? "└── " : "├── ";
+        const childPrefix = isLast ? "    " : "│   ";
+        const typeLabel = layer.type === "group"
+            ? "(group)"
+            : layer.type === "text"
+                ? "(text)"
+                : layer.type === "image"
+                    ? "(image)"
+                    : layer.type === "shape"
+                        ? "(shape)"
+                        : "";
+        const visibilityMark = layer.visible ? "" : " [hidden]";
+        lines.push(`${prefix}${connector}${layer.name} ${typeLabel}${visibilityMark}`);
+        if (layer.children && layer.children.length > 0) {
+            lines.push(formatLayerTree(layer.children, prefix + childPrefix));
+        }
+    });
+    return lines.join("\n");
+}
+// Find layer by name (recursive search)
+function findLayerByName(layers, name, exact = false) {
+    for (const layer of layers) {
+        const match = exact
+            ? layer.name === name
+            : layer.name.toLowerCase().includes(name.toLowerCase());
+        if (match) {
+            return layer;
+        }
+        if (layer.children) {
+            const found = findLayerByName(layer.children, name, exact);
+            if (found)
+                return found;
+        }
+    }
+    return null;
+}
+// Search layers by name (returns all matches)
+function searchLayersByName(layers, name) {
+    const results = [];
+    function traverse(items) {
+        for (const layer of items) {
+            if (layer.name.toLowerCase().includes(name.toLowerCase())) {
+                results.push(layer);
+            }
+            if (layer.children) {
+                traverse(layer.children);
+            }
+        }
+    }
+    traverse(layers);
+    return results;
+}
+// Get text layers only (flattened)
+function getTextLayers(layers) {
+    const result = [];
+    function traverse(items) {
+        for (const layer of items) {
+            if (layer.type === "text") {
+                result.push(layer);
+            }
+            if (layer.children) {
+                traverse(layer.children);
+            }
+        }
+    }
+    traverse(layers);
+    return result;
+}
+// Extract all fonts from text layers
+function extractAllFonts(layers) {
+    const fontMap = new Map();
+    function addFont(fontName, fontSize, style, layerName) {
+        if (!fontName)
+            return;
+        if (!fontMap.has(fontName)) {
+            fontMap.set(fontName, {
+                fontName,
+                sizes: [],
+                styles: {
+                    regular: false,
+                    bold: false,
+                    italic: false,
+                    fauxBold: false,
+                    fauxItalic: false,
+                },
+                layers: [],
+                colors: [],
+            });
+        }
+        const usage = fontMap.get(fontName);
+        // Add size
+        if (fontSize && !usage.sizes.includes(fontSize)) {
+            usage.sizes.push(fontSize);
+        }
+        // Track styles
+        if (style?.fauxBold) {
+            usage.styles.fauxBold = true;
+        }
+        else if (style?.fauxItalic) {
+            usage.styles.fauxItalic = true;
+        }
+        else {
+            // Check font name for style hints
+            const nameLower = fontName.toLowerCase();
+            if (nameLower.includes("bold")) {
+                usage.styles.bold = true;
+            }
+            else if (nameLower.includes("italic") ||
+                nameLower.includes("oblique")) {
+                usage.styles.italic = true;
+            }
+            else {
+                usage.styles.regular = true;
+            }
+        }
+        // Add layer name
+        if (!usage.layers.includes(layerName)) {
+            usage.layers.push(layerName);
+        }
+        // Add color
+        if (style?.fillColor) {
+            const hex = anyColorToHex(style.fillColor);
+            if (hex && !usage.colors.includes(hex)) {
+                usage.colors.push(hex);
+            }
+        }
+    }
+    function traverse(items) {
+        for (const layer of items) {
+            if (layer.text) {
+                const layerName = layer.name || "Unnamed";
+                // Check default style
+                if (layer.text.style?.font?.name) {
+                    addFont(layer.text.style.font.name, layer.text.style.fontSize, layer.text.style, layerName);
+                }
+                // Check style runs (for text with multiple fonts)
+                if (layer.text.styleRuns) {
+                    for (const run of layer.text.styleRuns) {
+                        if (run.style?.font?.name) {
+                            addFont(run.style.font.name, run.style.fontSize, run.style, layerName);
+                        }
+                    }
+                }
+            }
+            if (layer.children) {
+                traverse(layer.children);
+            }
+        }
+    }
+    traverse(layers);
+    // Sort sizes
+    for (const usage of fontMap.values()) {
+        usage.sizes.sort((a, b) => a - b);
+    }
+    return fontMap;
+}
+// Get all smart object layers from PSD
+function getAllSmartObjectLayers(layers) {
+    const result = [];
+    function traverse(items, currentPath) {
+        for (const layer of items) {
+            if (layer.placedLayer) {
+                result.push({ layer, path: [...currentPath, layer.name || "Unnamed"] });
+            }
+            if (layer.children) {
+                traverse(layer.children, [...currentPath, layer.name || "Unnamed"]);
+            }
+        }
+    }
+    traverse(layers, []);
+    return result;
+}
+// Extract smart object information
+function extractSmartObjectInfo(layer, linkedFiles, psdFilePath) {
+    const placed = layer.placedLayer;
+    // Determine type (ag-psd uses "image stack" not "imageStack")
+    let soType = "unknown";
+    if (placed.type === "vector") {
+        soType = "vector";
+    }
+    else if (placed.type === "raster") {
+        soType = "raster";
+    }
+    else if (placed.type === "image stack") {
+        soType = "imageStack";
+    }
+    // Find linked file
+    let linkedFile = undefined;
+    if (placed.id && linkedFiles) {
+        linkedFile = linkedFiles.find((f) => f.id === placed.id);
+    }
+    // Transform is an array [xx, xy, yx, yy, tx, ty] in ag-psd
+    const transform = placed.transform;
+    // Check for external file if no embedded data
+    let externalFilePath;
+    const hasEmbeddedData = !!(linkedFile?.data && linkedFile.data.length > 0);
+    if (!hasEmbeddedData && linkedFile?.name && psdFilePath) {
+        const psdDir = path.dirname(psdFilePath);
+        const linkedFileName = linkedFile.name;
+        const possiblePaths = [
+            path.join(psdDir, linkedFileName),
+            path.join(psdDir, "Links", linkedFileName),
+            path.join(psdDir, "links", linkedFileName),
+            path.join(psdDir, "..", linkedFileName),
+        ];
+        for (const tryPath of possiblePaths) {
+            if (fs.existsSync(tryPath)) {
+                externalFilePath = tryPath;
+                break;
+            }
+        }
+    }
+    return {
+        layerName: layer.name || "Unnamed",
+        type: soType,
+        transform: transform && transform.length >= 6
+            ? {
+                xx: transform[0],
+                xy: transform[1],
+                yx: transform[2],
+                yy: transform[3],
+                tx: transform[4],
+                ty: transform[5],
+            }
+            : undefined,
+        width: placed.width,
+        height: placed.height,
+        linkedFileId: placed.id,
+        linkedFileName: linkedFile?.name,
+        linkedFileType: linkedFile?.type,
+        hasEmbeddedData,
+        externalFilePath,
+    };
+}
+// Create MCP Server
+const server = new Server({
+    name: "psd-parser",
+    version: "1.0.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// List available tools
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: "extract_colors",
+                description: "Extract all colors used in the PSD file including text colors, fills, strokes, layer effects (shadows, glows, overlays), and gradients",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: {
+                            type: "string",
+                            description: "Absolute path to the PSD file",
+                        },
+                        format: {
+                            type: "string",
+                            enum: ["summary", "detailed", "css"],
+                            description: "Output format: 'summary' for unique colors only, 'detailed' for all colors with sources, 'css' for CSS custom properties (default: summary)",
+                        },
+                    },
+                    required: ["path"],
+                },
+            },
+            {
+                name: "export_layer_image",
+                description: "Export a single image layer by name. Use layerIndex when multiple layers have the same name.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: {
+                            type: "string",
+                            description: "Absolute path to the PSD file",
+                        },
+                        layerName: {
+                            type: "string",
+                            description: "Name of the layer to export (partial match, case-insensitive)",
+                        },
+                        layerIndex: {
+                            type: "number",
+                            description: "When multiple layers match the name, specify which one (0-based index). Use list_layers first to see the order.",
+                        },
+                        groupName: {
+                            type: "string",
+                            description: "Optional: Search only within this group (useful for narrowing down same-named layers)",
+                        },
+                        outputPath: {
+                            type: "string",
+                            description: "Full output path including filename (e.g., /path/to/output/hero.png)",
+                        },
+                        scale: {
+                            type: "number",
+                            description: "Scale factor (default: 2 for @2x)",
+                        },
+                        format: {
+                            type: "string",
+                            enum: ["png", "jpg"],
+                            description: "Image format (default: png)",
+                        },
+                        quality: {
+                            type: "number",
+                            description: "JPG quality 1-100 (default: 90)",
+                        },
+                    },
+                    required: ["path", "layerName", "outputPath"],
+                },
+            },
+            {
+                name: "export_all_vectors_as_svg",
+                description: "Export all vector/shape layers as SVG files to a specified directory",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: {
+                            type: "string",
+                            description: "Absolute path to the PSD file",
+                        },
+                        outputDir: {
+                            type: "string",
+                            description: "Directory to save SVG files",
+                        },
+                        groupName: {
+                            type: "string",
+                            description: "Optional: Only export vectors from this group",
+                        },
+                    },
+                    required: ["path", "outputDir"],
+                },
+            },
+            {
+                name: "export_images",
+                description: "Export image layers as PNG or JPG files (@2x scale for Retina). Can export from a specific group or all images.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: {
+                            type: "string",
+                            description: "Absolute path to the PSD file",
+                        },
+                        outputDir: {
+                            type: "string",
+                            description: "Directory to save image files",
+                        },
+                        groupName: {
+                            type: "string",
+                            description: "Optional: Only export images from this group",
+                        },
+                        scale: {
+                            type: "number",
+                            description: "Scale factor (default: 2 for @2x)",
+                        },
+                        format: {
+                            type: "string",
+                            enum: ["png", "jpg"],
+                            description: "Image format: 'png' (default, supports transparency) or 'jpg' (smaller file size)",
+                        },
+                        quality: {
+                            type: "number",
+                            description: "JPG quality 1-100 (default: 90). Only applies to JPG format.",
+                        },
+                    },
+                    required: ["path", "outputDir"],
+                },
+            },
+            {
+                name: "list_vector_layers",
+                description: "List all vector/shape layers in a PSD file that can be exported as SVG",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: {
+                            type: "string",
+                            description: "Absolute path to the PSD file",
+                        },
+                    },
+                    required: ["path"],
+                },
+            },
+            {
+                name: "export_vector_as_svg",
+                description: "Export a vector/shape layer as SVG. Returns the SVG string or saves to a file.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: {
+                            type: "string",
+                            description: "Absolute path to the PSD file",
+                        },
+                        layerName: {
+                            type: "string",
+                            description: "Name of the vector layer to export",
+                        },
+                        outputPath: {
+                            type: "string",
+                            description: "Optional: Path to save the SVG file. If not provided, returns the SVG string.",
+                        },
+                    },
+                    required: ["path", "layerName"],
+                },
+            },
+            {
+                name: "list_layers",
+                description: "List all layers in a PSD file as a tree structure. Great for getting an overview of the document structure.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: {
+                            type: "string",
+                            description: "Absolute path to the PSD file",
+                        },
+                        depth: {
+                            type: "number",
+                            description: "Maximum depth to display (optional, default: unlimited)",
+                        },
+                    },
+                    required: ["path"],
+                },
+            },
+            {
+                name: "get_layer_by_name",
+                description: "Find a layer by name and return its detailed information including position, size, and text content if applicable",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: {
+                            type: "string",
+                            description: "Absolute path to the PSD file",
+                        },
+                        name: {
+                            type: "string",
+                            description: "Layer name to search for (partial match, case-insensitive)",
+                        },
+                        exact: {
+                            type: "boolean",
+                            description: "If true, require exact name match (default: false)",
+                        },
+                    },
+                    required: ["path", "name"],
+                },
+            },
+            {
+                name: "get_layer_children",
+                description: "Get the children of a specific group layer. Use this to drill down into nested groups.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: {
+                            type: "string",
+                            description: "Absolute path to the PSD file",
+                        },
+                        groupName: {
+                            type: "string",
+                            description: "Name of the group layer to get children from",
+                        },
+                        format: {
+                            type: "string",
+                            enum: ["tree", "detailed"],
+                            description: "Output format: 'tree' for simple tree view, 'detailed' for full info (default: tree)",
+                        },
+                    },
+                    required: ["path", "groupName"],
+                },
+            },
+            {
+                name: "parse_psd",
+                description: "Parse a PSD file and return document info with all layers including text content, sizes, positions, and hierarchy",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: {
+                            type: "string",
+                            description: "Absolute path to the PSD file",
+                        },
+                    },
+                    required: ["path"],
+                },
+            },
+            {
+                name: "get_text_layers",
+                description: "Get only text layers from a PSD file with their content, font info, and positions",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: {
+                            type: "string",
+                            description: "Absolute path to the PSD file",
+                        },
+                    },
+                    required: ["path"],
+                },
+            },
+            {
+                name: "list_fonts",
+                description: "List all fonts used in a PSD file with sizes, styles, colors, and which layers use them",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: {
+                            type: "string",
+                            description: "Absolute path to the PSD file",
+                        },
+                        format: {
+                            type: "string",
+                            enum: ["summary", "detailed", "css"],
+                            description: "Output format: 'summary' for font list, 'detailed' for full info, 'css' for @font-face template (default: summary)",
+                        },
+                    },
+                    required: ["path"],
+                },
+            },
+            {
+                name: "list_smart_objects",
+                description: "List all Smart Object layers in a PSD file. Shows their type (vector/raster/imageStack), linked file info, and whether embedded data is available.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: {
+                            type: "string",
+                            description: "Absolute path to the PSD file",
+                        },
+                    },
+                    required: ["path"],
+                },
+            },
+            {
+                name: "get_smart_object_content",
+                description: "Get the content of an embedded Smart Object. If the embedded file is a PSD, it will be parsed recursively to show its layers. Supports PSD, PSB, AI, and other embedded formats.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: {
+                            type: "string",
+                            description: "Absolute path to the PSD file",
+                        },
+                        layerName: {
+                            type: "string",
+                            description: "Name of the Smart Object layer to read (partial match, case-insensitive)",
+                        },
+                        layerIndex: {
+                            type: "number",
+                            description: "When multiple Smart Objects match the name, specify which one (0-based index)",
+                        },
+                        outputPath: {
+                            type: "string",
+                            description: "Optional: Save the embedded file data to this path. If not provided, embedded PSD files are parsed and layers are returned.",
+                        },
+                    },
+                    required: ["path", "layerName"],
+                },
+            },
+        ],
+    };
+});
+// Handle tool calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        switch (name) {
+            case "extract_colors": {
+                const { path: filePath, format = "summary" } = args;
+                const absolutePath = path.resolve(filePath);
+                if (!fs.existsSync(absolutePath)) {
+                    throw new Error(`File not found: ${absolutePath}`);
+                }
+                const buffer = fs.readFileSync(absolutePath);
+                const psd = readPsd(buffer, {
+                    skipCompositeImageData: true,
+                    skipLayerImageData: true,
+                    skipThumbnail: true,
+                });
+                const palette = extractAllColors(psd.children || []);
+                if (palette.uniqueColors.length === 0 &&
+                    palette.gradients.length === 0) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: "No colors found in this PSD file.",
+                            },
+                        ],
+                    };
+                }
+                let output;
+                if (format === "css") {
+                    // Generate CSS custom properties
+                    const cssLines = [":root {"];
+                    palette.uniqueColors.forEach((hex, i) => {
+                        cssLines.push(`  --color-${i + 1}: ${hex};`);
+                    });
+                    cssLines.push("");
+                    palette.gradients.forEach((grad, i) => {
+                        const gradientCss = `linear-gradient(90deg, ${grad.colors.join(", ")})`;
+                        cssLines.push(`  --gradient-${i + 1}: ${gradientCss};`);
+                    });
+                    cssLines.push("}");
+                    output = cssLines.join("\n");
+                }
+                else if (format === "detailed") {
+                    // Detailed output with sources
+                    const lines = ["## Solid Colors\n"];
+                    // Group by color
+                    const colorMap = new Map();
+                    for (const color of palette.solidColors) {
+                        if (!colorMap.has(color.hex)) {
+                            colorMap.set(color.hex, { sources: [], layers: [] });
+                        }
+                        const entry = colorMap.get(color.hex);
+                        if (!entry.sources.includes(color.source)) {
+                            entry.sources.push(color.source);
+                        }
+                        if (!entry.layers.includes(color.layerName)) {
+                            entry.layers.push(color.layerName);
+                        }
+                    }
+                    for (const [hex, info] of colorMap) {
+                        lines.push(`**${hex}**`);
+                        lines.push(`  Sources: ${info.sources.join(", ")}`);
+                        lines.push(`  Layers: ${info.layers.slice(0, 3).join(", ")}${info.layers.length > 3 ? ` (+${info.layers.length - 3} more)` : ""}`);
+                        lines.push("");
+                    }
+                    if (palette.gradients.length > 0) {
+                        lines.push("\n## Gradients\n");
+                        for (const grad of palette.gradients) {
+                            lines.push(`**${grad.name || "Unnamed"}** (${grad.source})`);
+                            lines.push(`  Colors: ${grad.colors.join(" → ")}`);
+                            lines.push(`  Layer: ${grad.layerName}`);
+                            lines.push("");
+                        }
+                    }
+                    output = lines.join("\n");
+                }
+                else {
+                    // Summary format
+                    const lines = [
+                        `Found ${palette.uniqueColors.length} unique color(s) and ${palette.gradients.length} gradient(s)`,
+                        "",
+                        "## Colors",
+                        ...palette.uniqueColors.map((hex) => `- ${hex}`),
+                    ];
+                    if (palette.gradients.length > 0) {
+                        lines.push("");
+                        lines.push("## Gradients");
+                        for (const grad of palette.gradients) {
+                            lines.push(`- ${grad.name || "Unnamed"}: ${grad.colors.join(" → ")}`);
+                        }
+                    }
+                    output = lines.join("\n");
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: output,
+                        },
+                    ],
+                };
+            }
+            case "export_layer_image": {
+                const { path: filePath, layerName, layerIndex, groupName, outputPath: outPath, scale = 2, format = "png", quality = 90, } = args;
+                const absolutePath = path.resolve(filePath);
+                const absoluteOutputPath = path.resolve(outPath);
+                if (!fs.existsSync(absolutePath)) {
+                    throw new Error(`File not found: ${absolutePath}`);
+                }
+                const buffer = fs.readFileSync(absolutePath);
+                const psd = readPsd(buffer, {
+                    skipCompositeImageData: true,
+                    skipLayerImageData: false,
+                    skipThumbnail: true,
+                });
+                // Get image layers (optionally from specific group)
+                let allImages;
+                if (groupName) {
+                    allImages = getImageLayersFromGroup(psd.children || [], groupName);
+                }
+                else {
+                    allImages = getAllImageLayers(psd.children || []);
+                }
+                // Find matching layers
+                const matchingLayers = allImages.filter((l) => l.name?.toLowerCase().includes(layerName.toLowerCase()));
+                if (matchingLayers.length === 0) {
+                    const suggestions = allImages
+                        .slice(0, 5)
+                        .map((l) => l.name)
+                        .join(", ");
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Layer "${layerName}" not found${groupName ? ` in group "${groupName}"` : ""}.\n\nAvailable image layers: ${suggestions || "none"}`,
+                            },
+                        ],
+                    };
+                }
+                // If multiple matches and no index specified, show options
+                if (matchingLayers.length > 1 && layerIndex === undefined) {
+                    const options = matchingLayers
+                        .map((l, i) => `  ${i}: "${l.name}"`)
+                        .join("\n");
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Found ${matchingLayers.length} layers matching "${layerName}". Please specify layerIndex:\n\n${options}\n\nExample: layerIndex: 0 for the first one`,
+                            },
+                        ],
+                    };
+                }
+                // Select the target layer
+                const targetIndex = layerIndex ?? 0;
+                if (targetIndex >= matchingLayers.length) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `layerIndex ${targetIndex} is out of range. Only ${matchingLayers.length} layer(s) found.`,
+                            },
+                        ],
+                    };
+                }
+                const targetLayer = matchingLayers[targetIndex];
+                // Create output directory if needed
+                const outputDir = path.dirname(absoluteOutputPath);
+                if (!fs.existsSync(outputDir)) {
+                    fs.mkdirSync(outputDir, { recursive: true });
+                }
+                const imageBuffer = layerToImageBuffer(targetLayer, scale, format, quality);
+                if (!imageBuffer) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Layer "${targetLayer.name}" has no image data.`,
+                            },
+                        ],
+                    };
+                }
+                fs.writeFileSync(absoluteOutputPath, imageBuffer);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Exported "${targetLayer.name}" to ${absoluteOutputPath} (${format.toUpperCase()}, ${scale}x)`,
+                        },
+                    ],
+                };
+            }
+            case "export_all_vectors_as_svg": {
+                const { path: filePath, outputDir, groupName, } = args;
+                const absolutePath = path.resolve(filePath);
+                const absoluteOutputDir = path.resolve(outputDir);
+                if (!fs.existsSync(absolutePath)) {
+                    throw new Error(`File not found: ${absolutePath}`);
+                }
+                // Create output directory if it doesn't exist
+                if (!fs.existsSync(absoluteOutputDir)) {
+                    fs.mkdirSync(absoluteOutputDir, { recursive: true });
+                }
+                const buffer = fs.readFileSync(absolutePath);
+                const psd = readPsd(buffer, {
+                    skipCompositeImageData: true,
+                    skipLayerImageData: true,
+                    skipThumbnail: true,
+                });
+                let vectorLayers;
+                if (groupName) {
+                    // Find group and get vectors from it
+                    const findGroup = (layers) => {
+                        for (const layer of layers) {
+                            if (layer.name?.toLowerCase().includes(groupName.toLowerCase()) &&
+                                layer.children) {
+                                return layer;
+                            }
+                            if (layer.children) {
+                                const found = findGroup(layer.children);
+                                if (found)
+                                    return found;
+                            }
+                        }
+                        return null;
+                    };
+                    const group = findGroup(psd.children || []);
+                    vectorLayers = group ? getAllVectorLayers(group.children || []) : [];
+                }
+                else {
+                    vectorLayers = getAllVectorLayers(psd.children || []);
+                }
+                if (vectorLayers.length === 0) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: groupName
+                                    ? `No vector layers found in group "${groupName}".`
+                                    : "No vector layers found in this PSD file.",
+                            },
+                        ],
+                    };
+                }
+                const exported = [];
+                // Track filenames to avoid duplicates
+                const usedFilenames = new Map();
+                for (const layer of vectorLayers) {
+                    try {
+                        const svg = vectorLayerToSvg(layer, psd.width, psd.height);
+                        const baseName = sanitizeFilename(layer.name || "unnamed");
+                        // Check for duplicate and add number suffix if needed
+                        let finalName;
+                        const count = usedFilenames.get(baseName) || 0;
+                        if (count === 0) {
+                            finalName = baseName;
+                        }
+                        else {
+                            finalName = `${baseName}_${String(count).padStart(2, "0")}`;
+                        }
+                        usedFilenames.set(baseName, count + 1);
+                        const filename = finalName + ".svg";
+                        const outputPath = path.join(absoluteOutputDir, filename);
+                        fs.writeFileSync(outputPath, svg, "utf-8");
+                        exported.push(filename);
+                    }
+                    catch (e) {
+                        // Skip layers that fail to export
+                    }
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Exported ${exported.length} SVG file(s) to ${absoluteOutputDir}:\n\n${exported.map((f) => `- ${f}`).join("\n")}`,
+                        },
+                    ],
+                };
+            }
+            case "export_images": {
+                const { path: filePath, outputDir, groupName, scale = 2, format = "png", quality = 90, } = args;
+                const absolutePath = path.resolve(filePath);
+                const absoluteOutputDir = path.resolve(outputDir);
+                if (!fs.existsSync(absolutePath)) {
+                    throw new Error(`File not found: ${absolutePath}`);
+                }
+                // Create output directory if it doesn't exist
+                if (!fs.existsSync(absoluteOutputDir)) {
+                    fs.mkdirSync(absoluteOutputDir, { recursive: true });
+                }
+                const buffer = fs.readFileSync(absolutePath);
+                const psd = readPsd(buffer, {
+                    skipCompositeImageData: true,
+                    skipLayerImageData: false, // Need image data for export
+                    skipThumbnail: true,
+                });
+                let imageLayers;
+                if (groupName) {
+                    imageLayers = getImageLayersFromGroup(psd.children || [], groupName);
+                }
+                else {
+                    imageLayers = getAllImageLayers(psd.children || []);
+                }
+                if (imageLayers.length === 0) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: groupName
+                                    ? `No image layers found in group "${groupName}".`
+                                    : "No image layers found in this PSD file.",
+                            },
+                        ],
+                    };
+                }
+                const exported = [];
+                const suffix = scale !== 1 ? `@${scale}x` : "";
+                const ext = format === "jpg" ? ".jpg" : ".png";
+                // Track filenames to avoid duplicates
+                const usedFilenames = new Map();
+                for (const layer of imageLayers) {
+                    try {
+                        const imageBuffer = layerToImageBuffer(layer, scale, format, quality);
+                        if (imageBuffer) {
+                            const baseName = sanitizeFilename(layer.name || "unnamed");
+                            // Check for duplicate and add number suffix if needed
+                            let finalName;
+                            const count = usedFilenames.get(baseName) || 0;
+                            if (count === 0) {
+                                finalName = baseName;
+                            }
+                            else {
+                                finalName = `${baseName}_${String(count).padStart(2, "0")}`;
+                            }
+                            usedFilenames.set(baseName, count + 1);
+                            const filename = finalName + suffix + ext;
+                            const outputPath = path.join(absoluteOutputDir, filename);
+                            fs.writeFileSync(outputPath, imageBuffer);
+                            exported.push(filename);
+                        }
+                    }
+                    catch (e) {
+                        // Skip layers that fail to export
+                    }
+                }
+                const formatInfo = format === "jpg" ? `JPG (quality: ${quality})` : "PNG";
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Exported ${exported.length} ${formatInfo} file(s) at ${scale}x to ${absoluteOutputDir}:\n\n${exported.map((f) => `- ${f}`).join("\n")}`,
+                        },
+                    ],
+                };
+            }
+            case "list_vector_layers": {
+                const filePath = args.path;
+                const absolutePath = path.resolve(filePath);
+                if (!fs.existsSync(absolutePath)) {
+                    throw new Error(`File not found: ${absolutePath}`);
+                }
+                const buffer = fs.readFileSync(absolutePath);
+                const psd = readPsd(buffer, {
+                    skipCompositeImageData: true,
+                    skipLayerImageData: true,
+                    skipThumbnail: true,
+                });
+                const vectorLayers = getAllVectorLayers(psd.children || []);
+                if (vectorLayers.length === 0) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: "No vector layers found in this PSD file.",
+                            },
+                        ],
+                    };
+                }
+                const layerList = vectorLayers
+                    .map((layer) => {
+                    const hasFill = !!layer.vectorFill;
+                    const hasStroke = !!layer.vectorStroke?.strokeEnabled;
+                    return `- ${layer.name} (fill: ${hasFill ? "yes" : "no"}, stroke: ${hasStroke ? "yes" : "no"})`;
+                })
+                    .join("\n");
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Found ${vectorLayers.length} vector layer(s):\n\n${layerList}`,
+                        },
+                    ],
+                };
+            }
+            case "export_vector_as_svg": {
+                const { path: filePath, layerName, outputPath, } = args;
+                const absolutePath = path.resolve(filePath);
+                if (!fs.existsSync(absolutePath)) {
+                    throw new Error(`File not found: ${absolutePath}`);
+                }
+                const buffer = fs.readFileSync(absolutePath);
+                const psd = readPsd(buffer, {
+                    skipCompositeImageData: true,
+                    skipLayerImageData: true,
+                    skipThumbnail: true,
+                });
+                const vectorLayer = findVectorLayer(psd.children || [], layerName);
+                if (!vectorLayer) {
+                    const allVectors = getAllVectorLayers(psd.children || []);
+                    const suggestions = allVectors
+                        .slice(0, 5)
+                        .map((l) => l.name)
+                        .join(", ");
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Vector layer "${layerName}" not found.\n\nAvailable vector layers: ${suggestions || "none"}`,
+                            },
+                        ],
+                    };
+                }
+                const svg = vectorLayerToSvg(vectorLayer, psd.width, psd.height);
+                if (outputPath) {
+                    const absoluteOutputPath = path.resolve(outputPath);
+                    fs.writeFileSync(absoluteOutputPath, svg, "utf-8");
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `SVG saved to: ${absoluteOutputPath}`,
+                            },
+                        ],
+                    };
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: svg,
+                        },
+                    ],
+                };
+            }
+            case "list_layers": {
+                const { path: filePath, depth } = args;
+                const psdInfo = parsePsdFile(filePath);
+                // Apply depth limit if specified
+                function limitDepth(layers, currentDepth, maxDepth) {
+                    if (currentDepth >= maxDepth) {
+                        return layers.map((l) => ({
+                            ...l,
+                            children: l.children?.length
+                                ? [
+                                    {
+                                        name: `... (${l.children.length} children)`,
+                                        type: "unknown",
+                                        visible: true,
+                                        opacity: 1,
+                                        bounds: { left: 0, top: 0, width: 0, height: 0 },
+                                    },
+                                ]
+                                : undefined,
+                        }));
+                    }
+                    return layers.map((l) => ({
+                        ...l,
+                        children: l.children
+                            ? limitDepth(l.children, currentDepth + 1, maxDepth)
+                            : undefined,
+                    }));
+                }
+                const layersToShow = depth
+                    ? limitDepth(psdInfo.layers, 0, depth)
+                    : psdInfo.layers;
+                const tree = formatLayerTree(layersToShow);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `PSD: ${psdInfo.width}x${psdInfo.height}\n\n${tree}`,
+                        },
+                    ],
+                };
+            }
+            case "get_layer_by_name": {
+                const { path: filePath, name: layerName, exact, } = args;
+                const psdInfo = parsePsdFile(filePath);
+                const layer = findLayerByName(psdInfo.layers, layerName, exact ?? false);
+                if (!layer) {
+                    // Show suggestions
+                    const similar = searchLayersByName(psdInfo.layers, layerName.slice(0, 3));
+                    const suggestions = similar
+                        .slice(0, 5)
+                        .map((l) => l.name)
+                        .join(", ");
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Layer "${layerName}" not found.\n\nSimilar layers: ${suggestions || "none"}`,
+                            },
+                        ],
+                    };
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(layer, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "get_layer_children": {
+                const { path: filePath, groupName, format, } = args;
+                const psdInfo = parsePsdFile(filePath);
+                const group = findLayerByName(psdInfo.layers, groupName, false);
+                if (!group) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Group "${groupName}" not found.`,
+                            },
+                        ],
+                    };
+                }
+                if (!group.children || group.children.length === 0) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `"${group.name}" has no children (type: ${group.type})`,
+                            },
+                        ],
+                    };
+                }
+                const outputFormat = format ?? "tree";
+                const output = outputFormat === "tree"
+                    ? formatLayerTree(group.children)
+                    : JSON.stringify(group.children, null, 2);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Children of "${group.name}" (${group.children.length} items):\n\n${output}`,
+                        },
+                    ],
+                };
+            }
+            case "parse_psd": {
+                const filePath = args.path;
+                const psdInfo = parsePsdFile(filePath);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(psdInfo, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "get_text_layers": {
+                const filePath = args.path;
+                const psdInfo = parsePsdFile(filePath);
+                const textLayers = getTextLayers(psdInfo.layers);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                documentSize: {
+                                    width: psdInfo.width,
+                                    height: psdInfo.height,
+                                },
+                                textLayers,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "list_fonts": {
+                const { path: filePath, format = "summary" } = args;
+                const absolutePath = path.resolve(filePath);
+                if (!fs.existsSync(absolutePath)) {
+                    throw new Error(`File not found: ${absolutePath}`);
+                }
+                const buffer = fs.readFileSync(absolutePath);
+                const psd = readPsd(buffer, {
+                    skipCompositeImageData: true,
+                    skipLayerImageData: true,
+                    skipThumbnail: true,
+                });
+                const fontMap = extractAllFonts(psd.children || []);
+                if (fontMap.size === 0) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: "No fonts found in this PSD file (no text layers).",
+                            },
+                        ],
+                    };
+                }
+                const fonts = Array.from(fontMap.values()).sort((a, b) => a.fontName.localeCompare(b.fontName));
+                let output;
+                if (format === "css") {
+                    // Generate CSS @font-face template
+                    const cssLines = [
+                        "/* Font faces used in this PSD */",
+                        "/* Replace src with actual font file paths */",
+                        "",
+                    ];
+                    for (const font of fonts) {
+                        const safeName = font.fontName.replace(/[^a-zA-Z0-9-]/g, "-");
+                        cssLines.push(`@font-face {`);
+                        cssLines.push(`  font-family: '${font.fontName}';`);
+                        cssLines.push(`  src: url('./fonts/${safeName}.woff2') format('woff2'),`);
+                        cssLines.push(`       url('./fonts/${safeName}.woff') format('woff');`);
+                        cssLines.push(`  font-weight: normal;`);
+                        cssLines.push(`  font-style: normal;`);
+                        cssLines.push(`  font-display: swap;`);
+                        cssLines.push(`}`);
+                        cssLines.push(``);
+                    }
+                    cssLines.push(`/* CSS variables for font sizes */`);
+                    cssLines.push(`:root {`);
+                    const allSizes = [...new Set(fonts.flatMap((f) => f.sizes))].sort((a, b) => a - b);
+                    allSizes.forEach((size, i) => {
+                        cssLines.push(`  --font-size-${i + 1}: ${size}px;`);
+                    });
+                    cssLines.push(`}`);
+                    output = cssLines.join("\n");
+                }
+                else if (format === "detailed") {
+                    // Detailed output
+                    const lines = [`Found ${fonts.length} font(s):\n`];
+                    for (const font of fonts) {
+                        const styleList = [];
+                        if (font.styles.regular)
+                            styleList.push("Regular");
+                        if (font.styles.bold)
+                            styleList.push("Bold");
+                        if (font.styles.italic)
+                            styleList.push("Italic");
+                        if (font.styles.fauxBold)
+                            styleList.push("Faux Bold");
+                        if (font.styles.fauxItalic)
+                            styleList.push("Faux Italic");
+                        lines.push(`## ${font.fontName}`);
+                        lines.push(`   Sizes: ${font.sizes.join("px, ")}px`);
+                        lines.push(`   Styles: ${styleList.join(", ") || "Unknown"}`);
+                        if (font.colors.length > 0) {
+                            lines.push(`   Colors: ${font.colors.join(", ")}`);
+                        }
+                        lines.push(`   Used in: ${font.layers.slice(0, 5).join(", ")}${font.layers.length > 5 ? ` (+${font.layers.length - 5} more)` : ""}`);
+                        lines.push(``);
+                    }
+                    output = lines.join("\n");
+                }
+                else {
+                    // Summary format
+                    const lines = [`Found ${fonts.length} font(s):\n`];
+                    for (const font of fonts) {
+                        const sizeRange = font.sizes.length > 0
+                            ? font.sizes.length === 1
+                                ? `${font.sizes[0]}px`
+                                : `${font.sizes[0]}-${font.sizes[font.sizes.length - 1]}px`
+                            : "";
+                        lines.push(`- **${font.fontName}** ${sizeRange}`);
+                    }
+                    output = lines.join("\n");
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: output,
+                        },
+                    ],
+                };
+            }
+            case "list_smart_objects": {
+                const filePath = args.path;
+                const absolutePath = path.resolve(filePath);
+                if (!fs.existsSync(absolutePath)) {
+                    throw new Error(`File not found: ${absolutePath}`);
+                }
+                const buffer = fs.readFileSync(absolutePath);
+                const psd = readPsd(buffer, {
+                    skipCompositeImageData: true,
+                    skipLayerImageData: true,
+                    skipThumbnail: true,
+                    skipLinkedFilesData: false, // We need linked file info
+                });
+                const smartObjects = getAllSmartObjectLayers(psd.children || []);
+                if (smartObjects.length === 0) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: "No Smart Object layers found in this PSD file.",
+                            },
+                        ],
+                    };
+                }
+                const results = smartObjects.map(({ layer, path: layerPath }) => {
+                    const info = extractSmartObjectInfo(layer, psd.linkedFiles, absolutePath);
+                    return {
+                        ...info,
+                        layerPath: layerPath.join(" > "),
+                    };
+                });
+                const lines = [
+                    `Found ${smartObjects.length} Smart Object(s):\n`,
+                    ...results.map((so, i) => {
+                        let statusLine;
+                        if (so.hasEmbeddedData) {
+                            statusLine = "✓ embedded data available";
+                        }
+                        else if (so.externalFilePath) {
+                            statusLine = `✓ external file found: ${so.externalFilePath}`;
+                        }
+                        else if (so.linkedFileName) {
+                            statusLine = `✗ external link (file not found: ${so.linkedFileName})`;
+                        }
+                        else {
+                            statusLine = "✗ no data available";
+                        }
+                        return [
+                            `${i + 1}. **${so.layerName}**`,
+                            `   Path: ${so.layerPath}`,
+                            `   Type: ${so.type}`,
+                            so.linkedFileName ? `   File: ${so.linkedFileName}` : null,
+                            so.linkedFileType ? `   Format: ${so.linkedFileType}` : null,
+                            so.width && so.height
+                                ? `   Size: ${so.width}x${so.height}`
+                                : null,
+                            `   Status: ${statusLine}`,
+                            "",
+                        ]
+                            .filter((l) => l !== null)
+                            .join("\n");
+                    }),
+                ];
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: lines.join("\n"),
+                        },
+                    ],
+                };
+            }
+            case "get_smart_object_content": {
+                const { path: filePath, layerName, layerIndex, outputPath, } = args;
+                const absolutePath = path.resolve(filePath);
+                if (!fs.existsSync(absolutePath)) {
+                    throw new Error(`File not found: ${absolutePath}`);
+                }
+                const buffer = fs.readFileSync(absolutePath);
+                const psd = readPsd(buffer, {
+                    skipCompositeImageData: true,
+                    skipLayerImageData: true,
+                    skipThumbnail: true,
+                    skipLinkedFilesData: false, // Need the embedded data
+                });
+                const smartObjects = getAllSmartObjectLayers(psd.children || []);
+                // Find matching smart objects
+                const matchingSOs = smartObjects.filter(({ layer }) => layer.name?.toLowerCase().includes(layerName.toLowerCase()));
+                if (matchingSOs.length === 0) {
+                    const suggestions = smartObjects
+                        .slice(0, 5)
+                        .map(({ layer }) => layer.name)
+                        .join(", ");
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Smart Object "${layerName}" not found.\n\nAvailable Smart Objects: ${suggestions || "none"}`,
+                            },
+                        ],
+                    };
+                }
+                // If multiple matches and no index specified, show options
+                if (matchingSOs.length > 1 && layerIndex === undefined) {
+                    const options = matchingSOs
+                        .map(({ layer, path: p }, i) => `  ${i}: "${layer.name}" (${p.join(" > ")})`)
+                        .join("\n");
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Found ${matchingSOs.length} Smart Objects matching "${layerName}". Please specify layerIndex:\n\n${options}`,
+                            },
+                        ],
+                    };
+                }
+                // Select target
+                const targetIndex = layerIndex ?? 0;
+                if (targetIndex >= matchingSOs.length) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `layerIndex ${targetIndex} is out of range. Only ${matchingSOs.length} Smart Object(s) found.`,
+                            },
+                        ],
+                    };
+                }
+                const targetSO = matchingSOs[targetIndex];
+                const placed = targetSO.layer.placedLayer;
+                // Find linked file data
+                let linkedFile = undefined;
+                if (placed.id && psd.linkedFiles) {
+                    linkedFile = psd.linkedFiles.find((f) => f.id === placed.id);
+                }
+                // If no embedded data, try to find the external linked file
+                let fileData = null;
+                let fileType = linkedFile?.type || "unknown";
+                let externalFilePath = null;
+                if (linkedFile?.data && linkedFile.data.length > 0) {
+                    fileData = linkedFile.data;
+                }
+                else if (linkedFile?.name) {
+                    // Try to find external file relative to the PSD
+                    const psdDir = path.dirname(absolutePath);
+                    const linkedFileName = linkedFile.name;
+                    // Possible locations to search for the linked file
+                    const possiblePaths = [
+                        path.join(psdDir, linkedFileName), // Same directory
+                        path.join(psdDir, "Links", linkedFileName), // Links subfolder (common in Adobe)
+                        path.join(psdDir, "links", linkedFileName), // links subfolder (lowercase)
+                        path.join(psdDir, "..", linkedFileName), // Parent directory
+                    ];
+                    for (const tryPath of possiblePaths) {
+                        if (fs.existsSync(tryPath)) {
+                            externalFilePath = tryPath;
+                            fileData = new Uint8Array(fs.readFileSync(tryPath));
+                            break;
+                        }
+                    }
+                    if (!fileData) {
+                        const info = extractSmartObjectInfo(targetSO.layer, psd.linkedFiles);
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: [
+                                        `Smart Object "${targetSO.layer.name}" is an external link.`,
+                                        "",
+                                        `Linked file: ${linkedFileName}`,
+                                        linkedFile?.type ? `File type: ${linkedFile.type}` : "",
+                                        info.type !== "unknown"
+                                            ? `Smart Object type: ${info.type}`
+                                            : "",
+                                        "",
+                                        "Could not find the linked file in these locations:",
+                                        ...possiblePaths.map((p) => `  - ${p}`),
+                                        "",
+                                        "Please ensure the linked file exists in one of these locations.",
+                                    ]
+                                        .filter((l) => l)
+                                        .join("\n"),
+                                },
+                            ],
+                        };
+                    }
+                }
+                else {
+                    const info = extractSmartObjectInfo(targetSO.layer, psd.linkedFiles);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: [
+                                    `Smart Object "${targetSO.layer.name}" has no embedded data and no linked file info.`,
+                                    "",
+                                    info.type !== "unknown"
+                                        ? `Smart Object type: ${info.type}`
+                                        : "",
+                                ]
+                                    .filter((l) => l)
+                                    .join("\n"),
+                            },
+                        ],
+                    };
+                }
+                const embeddedData = fileData;
+                const dataSource = externalFilePath
+                    ? `external file: ${externalFilePath}`
+                    : "embedded data";
+                // If output path specified, save the raw embedded file
+                if (outputPath) {
+                    const absoluteOutputPath = path.resolve(outputPath);
+                    const outputDir = path.dirname(absoluteOutputPath);
+                    if (!fs.existsSync(outputDir)) {
+                        fs.mkdirSync(outputDir, { recursive: true });
+                    }
+                    fs.writeFileSync(absoluteOutputPath, Buffer.from(embeddedData));
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Saved file (${fileType}, ${embeddedData.length} bytes) from ${dataSource} to: ${absoluteOutputPath}`,
+                            },
+                        ],
+                    };
+                }
+                // Try to parse as PSD if it looks like one
+                const isPsd = fileType === "psd" ||
+                    fileType === "psb" ||
+                    linkedFile.name?.toLowerCase().endsWith(".psd") ||
+                    linkedFile.name?.toLowerCase().endsWith(".psb");
+                if (isPsd) {
+                    try {
+                        const embeddedPsd = readPsd(Buffer.from(embeddedData), {
+                            skipCompositeImageData: true,
+                            skipLayerImageData: true,
+                            skipThumbnail: true,
+                        });
+                        const embeddedLayers = embeddedPsd.children?.map(extractLayerInfo) || [];
+                        const tree = formatLayerTree(embeddedLayers);
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: [
+                                        `**Smart Object: ${targetSO.layer.name}**`,
+                                        `Source: ${dataSource}`,
+                                        `PSD Size: ${embeddedPsd.width}x${embeddedPsd.height}`,
+                                        "",
+                                        "## Layers inside Smart Object:",
+                                        "",
+                                        tree,
+                                    ].join("\n"),
+                                },
+                            ],
+                        };
+                    }
+                    catch (parseError) {
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: [
+                                        `Smart Object "${targetSO.layer.name}" contains embedded data (${embeddedData.length} bytes).`,
+                                        `File type: ${fileType}`,
+                                        "",
+                                        "Could not parse as PSD. Use outputPath to extract the raw file.",
+                                    ].join("\n"),
+                                },
+                            ],
+                        };
+                    }
+                }
+                // For non-PSD files, return info about the data
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: [
+                                `**Smart Object: ${targetSO.layer.name}**`,
+                                `Source: ${dataSource}`,
+                                `File type: ${fileType}`,
+                                `Data size: ${embeddedData.length} bytes`,
+                                linkedFile?.name ? `Original name: ${linkedFile.name}` : "",
+                                "",
+                                "This is not a PSD file. Use outputPath to extract the file.",
+                            ]
+                                .filter((l) => l)
+                                .join("\n"),
+                        },
+                    ],
+                };
+            }
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error: ${message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+// Start server
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("PSD Parser MCP Server running on stdio");
+}
+main().catch(console.error);