@translateimage/mcp-server 1.0.0

package/dist/src/tools/index.js

@@ -0,0 +1,202 @@
+import { ListToolsRequestSchema, CallToolRequestSchema, McpError, ErrorCode, } from "@modelcontextprotocol/sdk/types.js";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { ZodError } from "zod";
+import { TranslateImageInputSchema } from "../schemas/translate.js";
+import { OcrInputSchema } from "../schemas/ocr.js";
+import { TextRemovalInputSchema } from "../schemas/text-removal.js";
+import { ImageToTextInputSchema } from "../schemas/image-to-text.js";
+import { TranslateProductInputSchema, BatchTranslateInputSchema, ShopStatsInputSchema, ProductScanInputSchema, } from "../schemas/shopify.js";
+import { handleTranslateImage } from "./translate.js";
+import { handleOcr } from "./ocr.js";
+import { handleTextRemoval } from "./text-removal.js";
+import { handleImageToText } from "./image-to-text.js";
+import { shopifyToolDefinitions, handleTranslateProduct, handleBatchTranslate, handleShopStats, handleScanProducts, } from "./shopify/index.js";
+const coreToolDefinitions = [
+    {
+        name: "translate_image",
+        description: "Translate text in images while preserving the original layout. Detects text, translates it to the target language, and renders the translation back onto the image.",
+        inputSchema: zodToJsonSchema(TranslateImageInputSchema),
+    },
+    {
+        name: "extract_text",
+        description: "Extract text from images using OCR (Optical Character Recognition). Returns detected paragraphs with bounding boxes and detected language information.",
+        inputSchema: zodToJsonSchema(OcrInputSchema),
+    },
+    {
+        name: "remove_text",
+        description: "Remove text from images using inpainting. Detects text regions and fills them with appropriate background content.",
+        inputSchema: zodToJsonSchema(TextRemovalInputSchema),
+    },
+    {
+        name: "image_to_text",
+        description: "Extract text from images using Gemini AI and optionally translate to specified languages. Provides high-quality OCR with language detection and translation capabilities.",
+        inputSchema: zodToJsonSchema(ImageToTextInputSchema),
+    },
+];
+export function registerAllTools(server, config) {
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: [...coreToolDefinitions, ...shopifyToolDefinitions],
+    }));
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        try {
+            let result;
+            let contentItems;
+            switch (name) {
+                case "translate_image": {
+                    const input = TranslateImageInputSchema.parse(args);
+                    const output = await handleTranslateImage(input, config);
+                    result = output;
+                    contentItems = [
+                        {
+                            type: "image",
+                            data: output.translatedImage,
+                            mimeType: "image/png",
+                        },
+                        {
+                            type: "text",
+                            text: `Translated image with ${output.textRegions.length} text regions`,
+                        },
+                    ];
+                    break;
+                }
+                case "extract_text": {
+                    const input = OcrInputSchema.parse(args);
+                    const output = await handleOcr(input, config);
+                    result = output;
+                    const extractedText = output.paragraphs
+                        .map((p) => p.text)
+                        .join("\n\n");
+                    contentItems = [
+                        {
+                            type: "text",
+                            text: extractedText || "(No text detected)",
+                        },
+                    ];
+                    break;
+                }
+                case "remove_text": {
+                    const input = TextRemovalInputSchema.parse(args);
+                    const output = await handleTextRemoval(input, config);
+                    result = output;
+                    contentItems = [
+                        {
+                            type: "image",
+                            data: output.cleanedImage,
+                            mimeType: "image/png",
+                        },
+                        {
+                            type: "text",
+                            text: "Text removed from image",
+                        },
+                    ];
+                    break;
+                }
+                case "image_to_text": {
+                    const input = ImageToTextInputSchema.parse(args);
+                    const output = await handleImageToText(input, config);
+                    result = output;
+                    let textContent = output.extractedText || "(No text detected)";
+                    if (output.translations &&
+                        Object.keys(output.translations).length > 0) {
+                        textContent += "\n\n--- Translations ---";
+                        for (const [lang, translation] of Object.entries(output.translations)) {
+                            textContent += `\n\n[${lang}]:\n${translation}`;
+                        }
+                    }
+                    contentItems = [
+                        {
+                            type: "text",
+                            text: textContent,
+                        },
+                    ];
+                    break;
+                }
+                case "translate_product": {
+                    const input = TranslateProductInputSchema.parse(args);
+                    const output = await handleTranslateProduct(input, config);
+                    result = output;
+                    contentItems = [
+                        {
+                            type: "text",
+                            text: `Status: ${output.status}, Product: ${output.productTitle}, Images translated: ${output.imagesTranslated}`,
+                        },
+                    ];
+                    break;
+                }
+                case "batch_translate": {
+                    const input = BatchTranslateInputSchema.parse(args);
+                    const output = await handleBatchTranslate(input, config);
+                    result = output;
+                    contentItems = [
+                        {
+                            type: "text",
+                            text: `Batch complete: ${output.successCount}/${output.totalProducts} products translated to ${output.targetLanguage}`,
+                        },
+                    ];
+                    break;
+                }
+                case "shop_stats": {
+                    const input = ShopStatsInputSchema.parse(args);
+                    const output = await handleShopStats(input, config);
+                    result = output;
+                    const partialNote = output.isPartial ? " (partial scan)" : "";
+                    contentItems = [
+                        {
+                            type: "text",
+                            text: `Shop: ${output.shopName}, Products: ${output.totalProducts}, With images: ${output.productsWithImages}, Total images: ${output.totalImages}${partialNote}`,
+                        },
+                    ];
+                    break;
+                }
+                case "scan_products": {
+                    const input = ProductScanInputSchema.parse(args);
+                    const output = await handleScanProducts(input, config);
+                    result = output;
+                    const partialScanNote = output.isPartial
+                        ? ` (stopped: ${output.stoppedReason})`
+                        : "";
+                    contentItems = [
+                        {
+                            type: "text",
+                            text: `Scanned ${output.productsScanned} products, ${output.imagesScanned} images, ${output.imagesWithText} with text${partialScanNote}`,
+                        },
+                    ];
+                    break;
+                }
+                default:
+                    throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+            }
+            return {
+                content: contentItems,
+                structuredContent: result,
+            };
+        }
+        catch (error) {
+            if (error instanceof ZodError) {
+                const issues = error.issues
+                    .map((i) => `${i.path.join(".")}: ${i.message}`)
+                    .join("; ");
+                return {
+                    content: [{ type: "text", text: `Invalid input: ${issues}` }],
+                    isError: true,
+                };
+            }
+            if (error instanceof McpError) {
+                return {
+                    content: [{ type: "text", text: error.message }],
+                    isError: true,
+                };
+            }
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                content: [{ type: "text", text: errorMessage }],
+                isError: true,
+            };
+        }
+    });
+}
+export { handleTranslateImage } from "./translate.js";
+export { handleOcr } from "./ocr.js";
+export { handleTextRemoval } from "./text-removal.js";
+export { handleImageToText } from "./image-to-text.js";

package/dist/src/tools/ocr.d.ts

@@ -0,0 +1,4 @@
+import { McpServerConfig } from "../utils/config.js";
+import { OcrInput, OcrOutput } from "../schemas/ocr.js";
+export declare function handleOcr(input: OcrInput, config: McpServerConfig): Promise<OcrOutput>;
+//# sourceMappingURL=ocr.d.ts.map

package/dist/src/tools/ocr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ocr.d.ts","sourceRoot":"","sources":["../../../src/tools/ocr.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAGrD,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAExD,wBAAsB,SAAS,CAC7B,KAAK,EAAE,QAAQ,EACf,MAAM,EAAE,eAAe,GACtB,OAAO,CAAC,SAAS,CAAC,CA4BpB"}

package/dist/src/tools/ocr.js

@@ -0,0 +1,28 @@
+import { TranslateImageApiClient } from "../utils/api-client.js";
+import { resolveImageInput } from "../utils/image.js";
+export async function handleOcr(input, config) {
+    const client = new TranslateImageApiClient(config);
+    const imageBlob = await resolveImageInput(input.image);
+    const result = await client.ocr(imageBlob);
+    const paragraphs = result.regions.map((region) => ({
+        boundingBox: [
+            region.bounds.x,
+            region.bounds.y,
+            region.bounds.x + region.bounds.width,
+            region.bounds.y + region.bounds.height,
+        ],
+        text: Object.values(region.languages)[0] || "",
+        lines: [],
+        detectedLanguage: {
+            language: result.language,
+            code: result.language,
+            confidence: region.probability,
+        },
+    }));
+    return {
+        paragraphs,
+        width: 0,
+        height: 0,
+        angle: 0,
+    };
+}

package/dist/src/tools/shopify/batch-translate.d.ts

@@ -0,0 +1,26 @@
+import { McpServerConfig } from "../../utils/config.js";
+import type { BatchTranslateInput } from "../../schemas/shopify.js";
+interface ProductTranslationResult {
+    productId: string;
+    productTitle: string;
+    status: "success" | "failed" | "no_images";
+    imagesTranslated: number;
+    imagesFailed: number;
+    results: Array<{
+        mediaId: string;
+        translatedImage: string;
+        status: "success" | "error";
+        error?: string;
+    }>;
+    error?: string;
+}
+export interface BatchTranslateResult {
+    totalProducts: number;
+    successCount: number;
+    failureCount: number;
+    targetLanguage: string;
+    products: ProductTranslationResult[];
+}
+export declare function handleBatchTranslate(input: BatchTranslateInput, config: McpServerConfig): Promise<BatchTranslateResult>;
+export {};
+//# sourceMappingURL=batch-translate.d.ts.map

package/dist/src/tools/shopify/batch-translate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-translate.d.ts","sourceRoot":"","sources":["../../../../src/tools/shopify/batch-translate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAExD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AA4GpE,UAAU,wBAAwB;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,SAAS,GAAG,QAAQ,GAAG,WAAW,CAAC;IAC3C,gBAAgB,EAAE,MAAM,CAAC;IACzB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,KAAK,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;QAChB,eAAe,EAAE,MAAM,CAAC;QACxB,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC;QAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,CAAC,CAAC;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,oBAAoB;IACnC,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,wBAAwB,EAAE,CAAC;CACtC;AAED,wBAAsB,oBAAoB,CACxC,KAAK,EAAE,mBAAmB,EAC1B,MAAM,EAAE,eAAe,GACtB,OAAO,CAAC,oBAAoB,CAAC,CA0G/B"}

package/dist/src/tools/shopify/batch-translate.js

@@ -0,0 +1,143 @@
+import { TranslateImageApiClient } from "../../utils/api-client.js";
+const IMAGE_CONCURRENCY_LIMIT = 5;
+async function parallelWithLimit(items, limit, fn) {
+    const results = new Array(items.length);
+    let currentIndex = 0;
+    async function worker() {
+        while (currentIndex < items.length) {
+            const index = currentIndex++;
+            results[index] = await fn(items[index], index);
+        }
+    }
+    const workers = Array.from({ length: Math.min(limit, items.length) }, () => worker());
+    await Promise.all(workers);
+    return results;
+}
+async function shopifyGraphQL(shopDomain, accessToken, query, variables) {
+    const response = await fetch(`https://${shopDomain}/admin/api/2024-01/graphql.json`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "X-Shopify-Access-Token": accessToken,
+        },
+        body: JSON.stringify({ query, variables }),
+    });
+    if (!response.ok) {
+        throw new Error(`Shopify API error: ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (data.errors) {
+        throw new Error(`GraphQL errors: ${JSON.stringify(data.errors)}`);
+    }
+    return data.data;
+}
+const PRODUCTS_BY_IDS_QUERY = `
+  query getProducts($ids: [ID!]!) {
+    nodes(ids: $ids) {
+      ... on Product {
+        id
+        handle
+        title
+        media(first: 50) {
+          edges {
+            node {
+              ... on MediaImage {
+                id
+                __typename
+                image {
+                  url
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+async function fetchImageAsBlob(imageUrl) {
+    const response = await fetch(imageUrl);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch image: ${response.status}`);
+    }
+    return response.blob();
+}
+export async function handleBatchTranslate(input, config) {
+    const { shopDomain, accessToken } = input.shopifyCredentials;
+    const apiClient = new TranslateImageApiClient(config);
+    const productsData = await shopifyGraphQL(shopDomain, accessToken, PRODUCTS_BY_IDS_QUERY, { ids: input.productIds });
+    const products = productsData.nodes.filter((node) => node !== null);
+    const productResults = [];
+    let successCount = 0;
+    let failureCount = 0;
+    for (const product of products) {
+        const mediaImages = product.media.edges
+            .filter((edge) => edge.node.__typename === "MediaImage" && edge.node.image?.url)
+            .map((edge) => ({
+            mediaId: edge.node.id,
+            url: edge.node.image.url,
+        }));
+        if (mediaImages.length === 0) {
+            productResults.push({
+                productId: product.id,
+                productTitle: product.title,
+                status: "no_images",
+                imagesTranslated: 0,
+                imagesFailed: 0,
+                results: [],
+            });
+            continue;
+        }
+        const imageResults = await parallelWithLimit(mediaImages, IMAGE_CONCURRENCY_LIMIT, async (media) => {
+            try {
+                const imageBlob = await fetchImageAsBlob(media.url);
+                const translateResult = await apiClient.translate(imageBlob, {
+                    target_lang: input.targetLanguage,
+                    translator: input.translator,
+                    font: "NotoSans",
+                });
+                return {
+                    mediaId: media.mediaId,
+                    translatedImage: translateResult.resultImage,
+                    status: "success",
+                };
+            }
+            catch (error) {
+                return {
+                    mediaId: media.mediaId,
+                    translatedImage: "",
+                    status: "error",
+                    error: error instanceof Error ? error.message : "Unknown error",
+                };
+            }
+        });
+        const productImagesSuccess = imageResults.filter((r) => r.status === "success").length;
+        const productImagesFailed = imageResults.filter((r) => r.status === "error").length;
+        const productStatus = productImagesSuccess > 0
+            ? "success"
+            : productImagesFailed > 0
+                ? "failed"
+                : "no_images";
+        productResults.push({
+            productId: product.id,
+            productTitle: product.title,
+            status: productStatus,
+            imagesTranslated: productImagesSuccess,
+            imagesFailed: productImagesFailed,
+            results: imageResults,
+        });
+        if (productStatus === "success") {
+            successCount++;
+        }
+        else if (productStatus === "failed") {
+            failureCount++;
+        }
+    }
+    return {
+        totalProducts: products.length,
+        successCount,
+        failureCount,
+        targetLanguage: input.targetLanguage,
+        products: productResults,
+    };
+}

package/dist/src/tools/shopify/index.d.ts

@@ -0,0 +1,19 @@
+export { handleTranslateProduct } from "./translate-product.js";
+export type { TranslateProductResult } from "./translate-product.js";
+export { handleBatchTranslate } from "./batch-translate.js";
+export type { BatchTranslateResult } from "./batch-translate.js";
+export { handleShopStats } from "./shop-stats.js";
+export type { ShopStatsResult } from "./shop-stats.js";
+export { handleScanProducts } from "./scan-products.js";
+export type { ScanProductsResult } from "./scan-products.js";
+export declare const shopifyToolDefinitions: {
+    name: string;
+    description: string;
+    inputSchema: import("zod-to-json-schema").JsonSchema7Type & {
+        $schema?: string | undefined;
+        definitions?: {
+            [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+        } | undefined;
+    };
+}[];
+//# sourceMappingURL=index.d.ts.map

package/dist/src/tools/shopify/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/tools/shopify/index.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAChE,YAAY,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAErE,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC5D,YAAY,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAEjE,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,YAAY,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvD,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,YAAY,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAE7D,eAAO,MAAM,sBAAsB;;;;;;;;;GAyBlC,CAAC"}

package/dist/src/tools/shopify/index.js

@@ -0,0 +1,28 @@
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { TranslateProductInputSchema, BatchTranslateInputSchema, ShopStatsInputSchema, ProductScanInputSchema, } from "../../schemas/shopify.js";
+export { handleTranslateProduct } from "./translate-product.js";
+export { handleBatchTranslate } from "./batch-translate.js";
+export { handleShopStats } from "./shop-stats.js";
+export { handleScanProducts } from "./scan-products.js";
+export const shopifyToolDefinitions = [
+    {
+        name: "translate_product",
+        description: "Translate product images for an e-commerce store. Fetches product media and translates text in images to the target language.",
+        inputSchema: zodToJsonSchema(TranslateProductInputSchema),
+    },
+    {
+        name: "batch_translate",
+        description: "Batch translate product images for multiple products. Translates text in all images for the specified products to the target language.",
+        inputSchema: zodToJsonSchema(BatchTranslateInputSchema),
+    },
+    {
+        name: "shop_stats",
+        description: "Get statistics about a shop including total products, products with images, and total image count. Does not require database access.",
+        inputSchema: zodToJsonSchema(ShopStatsInputSchema),
+    },
+    {
+        name: "scan_products",
+        description: "Scan product images for text detection. Can scan a specific product or multiple products to identify which images contain translatable text.",
+        inputSchema: zodToJsonSchema(ProductScanInputSchema),
+    },
+];

package/dist/src/tools/shopify/scan-products.d.ts

@@ -0,0 +1,38 @@
+import { McpServerConfig } from "../../utils/config.js";
+import type { ProductScanInput } from "../../schemas/shopify.js";
+interface TextRegion {
+    bounds: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    text: string;
+    language: string;
+    confidence: number;
+}
+interface ImageScanResult {
+    mediaId: string;
+    imageUrl: string;
+    hasText: boolean;
+    confidence: number;
+    textRegions: TextRegion[];
+}
+interface ProductScanResult {
+    productId: string;
+    productTitle: string;
+    imagesScanned: number;
+    imagesWithText: number;
+    results: ImageScanResult[];
+}
+export interface ScanProductsResult {
+    productsScanned: number;
+    imagesScanned: number;
+    imagesWithText: number;
+    results: ProductScanResult[];
+    isPartial?: boolean;
+    stoppedReason?: string;
+}
+export declare function handleScanProducts(input: ProductScanInput, config: McpServerConfig): Promise<ScanProductsResult>;
+export {};
+//# sourceMappingURL=scan-products.d.ts.map

package/dist/src/tools/shopify/scan-products.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scan-products.d.ts","sourceRoot":"","sources":["../../../../src/tools/shopify/scan-products.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAGxD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAgHjE,UAAU,UAAU;IAClB,MAAM,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAChE,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,UAAU,eAAe;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,UAAU,EAAE,CAAC;CAC3B;AAED,UAAU,iBAAiB;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,eAAe,EAAE,CAAC;CAC5B;AAED,MAAM,WAAW,kBAAkB;IACjC,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,iBAAiB,EAAE,CAAC;IAC7B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AA0CD,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,gBAAgB,EACvB,MAAM,EAAE,eAAe,GACtB,OAAO,CAAC,kBAAkB,CAAC,CAgH7B"}