pabal-resource-mcp 1.5.1 → 1.5.3

package/dist/bin/mcp-server.js

@@ -3428,9 +3428,10 @@ function scanLocaleScreenshots(slug, locale) {
 }
 
 // src/tools/aso/utils/localize-screenshots/gemini-image-translator.util.ts
-import { GoogleGenAI, Modality } from "@google/genai";
+import { GoogleGenAI } from "@google/genai";
 import fs10 from "fs";
 import path10 from "path";
+import sharp from "sharp";
 var LANGUAGE_NAMES = {
   "en-US": "English (US)",
   "en-GB": "English (UK)",
@@ -3506,11 +3507,29 @@ function readImageAsBase64(imagePath) {
   }
   return { data: base64, mimeType };
 }
+async function getImageDimensions(imagePath) {
+  const metadata = await sharp(imagePath).metadata();
+  return {
+    width: metadata.width || 1080,
+    height: metadata.height || 1920
+  };
+}
+function calculateAspectRatio(width, height) {
+  const ratio = width / height;
+  if (Math.abs(ratio - 1) < 0.1) return "1:1";
+  if (Math.abs(ratio - 9 / 16) < 0.1) return "9:16";
+  if (Math.abs(ratio - 16 / 9) < 0.1) return "16:9";
+  if (Math.abs(ratio - 3 / 4) < 0.1) return "3:4";
+  if (Math.abs(ratio - 4 / 3) < 0.1) return "4:3";
+  return ratio < 1 ? "9:16" : "16:9";
+}
 async function translateImage(sourcePath, sourceLocale, targetLocale, outputPath) {
   try {
     const client = getGeminiClient();
     const sourceLanguage = getLanguageName(sourceLocale);
     const targetLanguage = getLanguageName(targetLocale);
+    const { width, height } = await getImageDimensions(sourcePath);
+    const aspectRatio = calculateAspectRatio(width, height);
     const { data: imageData, mimeType } = readImageAsBase64(sourcePath);
     const prompt = `This is an app screenshot with text in ${sourceLanguage}.
 Please translate ONLY the text/words in this image to ${targetLanguage}.
@@ -3522,24 +3541,27 @@ IMPORTANT INSTRUCTIONS:
 - Do NOT add any new elements or remove existing design elements
 - The output should look identical except the text language is ${targetLanguage}
 - Preserve all icons, images, and graphical elements exactly as they are`;
-    const response = await client.models.generateContent({
-      model: "imagen-3.0-generate-002",
-      contents: [
+    const chat = client.chats.create({
+      model: "gemini-3-pro-image-preview",
+      config: {
+        responseModalities: ["TEXT", "IMAGE"]
+      }
+    });
+    const response = await chat.sendMessage({
+      message: [
+        { text: prompt },
         {
-          role: "user",
-          parts: [
-            { text: prompt },
-            {
-              inlineData: {
-                mimeType,
-                data: imageData
-              }
-            }
-          ]
+          inlineData: {
+            mimeType,
+            data: imageData
+          }
         }
       ],
       config: {
-        responseModalities: [Modality.TEXT, Modality.IMAGE]
+        responseModalities: ["TEXT", "IMAGE"],
+        imageConfig: {
+          aspectRatio
+        }
       }
     });
     const candidates = response.candidates;
@@ -3563,7 +3585,7 @@ IMPORTANT INSTRUCTIONS:
         if (!fs10.existsSync(outputDir)) {
           fs10.mkdirSync(outputDir, { recursive: true });
         }
-        fs10.writeFileSync(outputPath, imageBuffer);
+        await sharp(imageBuffer).png().toFile(outputPath);
         return {
           success: true,
           outputPath
@@ -3586,13 +3608,18 @@ async function translateImagesWithProgress(translations, onProgress) {
   let successful = 0;
   let failed = 0;
   const errors = [];
-  for (const translation of translations) {
+  const total = translations.length;
+  for (let i = 0; i < translations.length; i++) {
+    const translation = translations[i];
+    const current = i + 1;
     const progress = {
       sourceLocale: translation.sourceLocale,
       targetLocale: translation.targetLocale,
       deviceType: translation.deviceType,
       filename: translation.filename,
-      status: "translating"
+      status: "translating",
+      current,
+      total
     };
     onProgress?.(progress);
     const result = await translateImage(
@@ -3608,7 +3635,10 @@ async function translateImagesWithProgress(translations, onProgress) {
       failed++;
       progress.status = "failed";
       progress.error = result.error;
-      errors.push({ path: translation.sourcePath, error: result.error || "Unknown error" });
+      errors.push({
+        path: translation.sourcePath,
+        error: result.error || "Unknown error"
+      });
     }
     onProgress?.(progress);
     await new Promise((resolve) => setTimeout(resolve, 500));
@@ -3617,10 +3647,10 @@ async function translateImagesWithProgress(translations, onProgress) {
 }
 
 // src/tools/aso/utils/localize-screenshots/image-resizer.util.ts
-import sharp from "sharp";
+import sharp2 from "sharp";
 import fs11 from "fs";
-async function getImageDimensions(imagePath) {
-  const metadata = await sharp(imagePath).metadata();
+async function getImageDimensions2(imagePath) {
+  const metadata = await sharp2(imagePath).metadata();
   if (!metadata.width || !metadata.height) {
     throw new Error(`Unable to read dimensions from ${imagePath}`);
   }
@@ -3629,18 +3659,63 @@ async function getImageDimensions(imagePath) {
     height: metadata.height
   };
 }
+async function detectEdgeColor(imagePath) {
+  const image = sharp2(imagePath);
+  const metadata = await image.metadata();
+  const width = metadata.width || 100;
+  const height = metadata.height || 100;
+  const { data, info } = await image.raw().toBuffer({ resolveWithObject: true });
+  const channels = info.channels;
+  const colorCounts = /* @__PURE__ */ new Map();
+  const sampleEdgePixel = (x, y) => {
+    const idx = (y * width + x) * channels;
+    const r = data[idx];
+    const g = data[idx + 1];
+    const b = data[idx + 2];
+    const qr = Math.round(r / 16) * 16;
+    const qg = Math.round(g / 16) * 16;
+    const qb = Math.round(b / 16) * 16;
+    const key = `${qr},${qg},${qb}`;
+    const existing = colorCounts.get(key);
+    if (existing) {
+      existing.count++;
+    } else {
+      colorCounts.set(key, { count: 1, color: { r: qr, g: qg, b: qb } });
+    }
+  };
+  for (let x = 0; x < width; x += 2) {
+    sampleEdgePixel(x, 0);
+    sampleEdgePixel(x, height - 1);
+  }
+  for (let y = 0; y < height; y += 2) {
+    sampleEdgePixel(0, y);
+    sampleEdgePixel(width - 1, y);
+  }
+  let maxCount = 0;
+  let dominantColor = { r: 255, g: 255, b: 255 };
+  for (const { count, color } of colorCounts.values()) {
+    if (count > maxCount) {
+      maxCount = count;
+      dominantColor = color;
+    }
+  }
+  return dominantColor;
+}
 async function resizeImage(inputPath, outputPath, targetDimensions) {
-  await sharp(inputPath).resize(targetDimensions.width, targetDimensions.height, {
-    fit: "fill",
-    // Exact resize to target dimensions
-    withoutEnlargement: false
+  const bgColor = await detectEdgeColor(inputPath);
+  await sharp2(inputPath).resize(targetDimensions.width, targetDimensions.height, {
+    fit: "contain",
+    // Preserve aspect ratio
+    withoutEnlargement: false,
     // Allow enlargement if needed
-  }).toFile(outputPath + ".tmp");
+    background: bgColor
+    // Use detected edge color
+  }).flatten({ background: bgColor }).png().toFile(outputPath + ".tmp");
   fs11.renameSync(outputPath + ".tmp", outputPath);
 }
 async function validateAndResizeImage(sourcePath, translatedPath) {
-  const sourceDimensions = await getImageDimensions(sourcePath);
-  const translatedDimensions = await getImageDimensions(translatedPath);
+  const sourceDimensions = await getImageDimensions2(sourcePath);
+  const translatedDimensions = await getImageDimensions2(translatedPath);
   const needsResize = sourceDimensions.width !== translatedDimensions.width || sourceDimensions.height !== translatedDimensions.height;
   if (needsResize) {
     await resizeImage(translatedPath, translatedPath, sourceDimensions);
@@ -3687,7 +3762,10 @@ var localizeScreenshotsInputSchema = z7.object({
   ),
   deviceTypes: z7.array(z7.enum(["phone", "tablet"])).optional().default(["phone", "tablet"]).describe("Device types to process (default: both phone and tablet)"),
   dryRun: z7.boolean().optional().default(false).describe("Preview mode - shows what would be translated without actually translating"),
-  skipExisting: z7.boolean().optional().default(true).describe("Skip translation if target file already exists (default: true)")
+  skipExisting: z7.boolean().optional().default(true).describe("Skip translation if target file already exists (default: true)"),
+  screenshotNumbers: z7.array(z7.number().int().positive()).optional().describe(
+    "Specific screenshot numbers to process (e.g., [1, 3, 5]). If not provided, all screenshots will be processed."
+  )
 });
 var jsonSchema7 = zodToJsonSchema7(localizeScreenshotsInputSchema, {
   name: "LocalizeScreenshotsInput",
@@ -3802,7 +3880,8 @@ async function handleLocalizeScreenshots(input) {
     targetLocales: requestedTargetLocales,
     deviceTypes = ["phone", "tablet"],
     dryRun = false,
-    skipExisting = true
+    skipExisting = true,
+    screenshotNumbers
   } = input;
   const results = [];
   let appInfo;
@@ -3854,9 +3933,20 @@ async function handleLocalizeScreenshots(input) {
   }
   results.push(`\u{1F3AF} Target locales: ${targetLocales.join(", ")}`);
   const sourceScreenshots = scanLocaleScreenshots(appInfo.slug, primaryLocale);
-  const filteredScreenshots = sourceScreenshots.filter(
+  let filteredScreenshots = sourceScreenshots.filter(
     (s) => deviceTypes.includes(s.type)
   );
+  if (screenshotNumbers && screenshotNumbers.length > 0) {
+    filteredScreenshots = filteredScreenshots.filter((s) => {
+      const match = s.filename.match(/^(\d+)\./);
+      if (match) {
+        const num = parseInt(match[1], 10);
+        return screenshotNumbers.includes(num);
+      }
+      return false;
+    });
+    results.push(`\u{1F522} Filtering screenshots: ${screenshotNumbers.join(", ")}`);
+  }
   if (filteredScreenshots.length === 0) {
     const screenshotsDir2 = getScreenshotsDir(appInfo.slug);
     return {
@@ -3928,13 +4018,18 @@ ${screenshotsDir2}/${primaryLocale}/tablet/1.png, 2.png, ...`
   const translationResult = await translateImagesWithProgress(
     tasks,
     (progress) => {
-      if (progress.status === "completed") {
+      const progressPrefix = `[${progress.current}/${progress.total}]`;
+      if (progress.status === "translating") {
+        console.log(
+          `\u{1F504} ${progressPrefix} Translating ${progress.targetLocale}/${progress.deviceType}/${progress.filename}...`
+        );
+      } else if (progress.status === "completed") {
         console.log(
-          `\u2705 ${progress.targetLocale}/${progress.deviceType}/${progress.filename}`
+          `\u2705 ${progressPrefix} ${progress.targetLocale}/${progress.deviceType}/${progress.filename}`
         );
       } else if (progress.status === "failed") {
         console.log(
-          `\u274C ${progress.targetLocale}/${progress.deviceType}/${progress.filename}: ${progress.error}`
+          `\u274C ${progressPrefix} ${progress.targetLocale}/${progress.deviceType}/${progress.filename}: ${progress.error}`
         );
       }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pabal-resource-mcp",
-  "version": "1.5.1",
+  "version": "1.5.3",
   "type": "module",
   "description": "MCP server for ASO data management with shared types and utilities",
   "author": "skyu",