pabal-web-mcp 0.1.1 → 0.1.2

package/dist/bin/mcp-server.js

@@ -7,13 +7,15 @@ import {
   getPullDataDir,
   getPushDataDir,
   googlePlayToUnified,
+  isAppStoreLocale,
   isAppStoreMultilingual,
+  isGooglePlayLocale,
   isGooglePlayMultilingual,
   loadAsoFromConfig,
   saveAsoToAsoDir,
   unifiedToAppStore,
   unifiedToGooglePlay
-} from "../chunk-MWXNTV3M.js";
+} from "../chunk-AM6RGDD4.js";
 
 // src/bin/mcp-server.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -506,6 +508,7 @@ function convertToMultilingual(data, locale) {
 }
 
 // src/tools/public-to-aso.ts
+import fs4 from "fs";
 var FIELD_LIMITS_DOC_PATH = "docs/aso/ASO_FIELD_LIMITS.md";
 var toJsonSchema2 = zodToJsonSchema2;
 var publicToAsoInputSchema = z2.object({
@@ -520,12 +523,7 @@ var jsonSchema2 = toJsonSchema2(publicToAsoInputSchema, {
 var inputSchema2 = jsonSchema2.definitions?.PublicToAsoInput || jsonSchema2;
 async function downloadScreenshotsToAsoDir(slug, asoData, options) {
   const rootDir = options?.rootDir ?? getPushDataDir();
-  const productStoreRoot = path4.join(
-    rootDir,
-    "products",
-    slug,
-    "store"
-  );
+  const productStoreRoot = path4.join(rootDir, "products", slug, "store");
   if (asoData.googlePlay) {
     let googlePlayData = asoData.googlePlay;
     if (!isGooglePlayMultilingual(googlePlayData)) {
@@ -675,7 +673,85 @@ async function handlePublicToAso(input) {
   const { slug, dryRun } = input;
   const configData = loadAsoFromConfig(slug);
   if (!configData.googlePlay && !configData.appStore) {
-    throw new Error(`No ASO data found in config.json + locales/ for ${slug}`);
+    const productsDir = getProductsDir();
+    const configPath = path4.join(productsDir, slug, "config.json");
+    const localesDir = path4.join(productsDir, slug, "locales");
+    const errors = [];
+    if (!fs4.existsSync(configPath)) {
+      errors.push(`- config.json not found at ${configPath}`);
+    } else {
+      try {
+        const config = JSON.parse(fs4.readFileSync(configPath, "utf-8"));
+        if (!config.packageName && !config.bundleId) {
+          errors.push(
+            `- config.json exists but missing both packageName and bundleId`
+          );
+        } else {
+          if (config.packageName) {
+            errors.push(`- packageName found: ${config.packageName}`);
+          }
+          if (config.bundleId) {
+            errors.push(`- bundleId found: ${config.bundleId}`);
+          }
+        }
+      } catch (e) {
+        errors.push(
+          `- Failed to parse config.json: ${e instanceof Error ? e.message : String(e)}`
+        );
+      }
+    }
+    if (!fs4.existsSync(localesDir)) {
+      errors.push(`- locales directory not found at ${localesDir}`);
+    } else {
+      try {
+        const localeFiles = fs4.readdirSync(localesDir).filter((f) => f.endsWith(".json"));
+        if (localeFiles.length === 0) {
+          errors.push(`- locales directory exists but no .json files found`);
+        } else {
+          errors.push(
+            `- Found ${localeFiles.length} locale file(s): ${localeFiles.join(
+              ", "
+            )}`
+          );
+          const validLocales = [];
+          const invalidLocales = [];
+          for (const file of localeFiles) {
+            const localeCode = file.replace(".json", "");
+            if (isGooglePlayLocale(localeCode) || isAppStoreLocale(localeCode)) {
+              validLocales.push(localeCode);
+            } else {
+              invalidLocales.push(localeCode);
+            }
+          }
+          if (validLocales.length > 0) {
+            errors.push(`- Valid locales: ${validLocales.join(", ")}`);
+          }
+          if (invalidLocales.length > 0) {
+            errors.push(
+              `- Invalid locales (not supported by Google Play or App Store): ${invalidLocales.join(
+                ", "
+              )}`
+            );
+          }
+        }
+      } catch (e) {
+        errors.push(
+          `- Failed to read locales directory: ${e instanceof Error ? e.message : String(e)}`
+        );
+      }
+    }
+    throw new Error(
+      `No ASO data found in config.json + locales/ for ${slug}
+
+Diagnostics:
+${errors.join("\n")}
+
+Possible causes:
+1. config.json is missing packageName (for Google Play) or bundleId (for App Store)
+2. locales/ directory is missing or empty
+3. Locale files exist but don't match supported Google Play/App Store locales
+4. Locale files don't contain valid ASO data`
+    );
   }
   const storeData = prepareAsoDataForPush(slug, configData);
   const pushDataRoot = getPushDataDir();
@@ -742,7 +818,7 @@ import { z as z3 } from "zod";
 import { zodToJsonSchema as zodToJsonSchema3 } from "zod-to-json-schema";
 
 // src/tools/utils/improve-public/load-product-locales.util.ts
-import fs4 from "fs";
+import fs5 from "fs";
 import path5 from "path";
 function loadProductLocales(slug) {
   const productsDir = getProductsDir();
@@ -750,22 +826,22 @@ function loadProductLocales(slug) {
   const configPath = path5.join(productDir, "config.json");
   const localesDir = path5.join(productDir, "locales");
   let config = null;
-  if (fs4.existsSync(configPath)) {
-    const raw = fs4.readFileSync(configPath, "utf-8");
+  if (fs5.existsSync(configPath)) {
+    const raw = fs5.readFileSync(configPath, "utf-8");
     config = JSON.parse(raw);
   }
-  if (!fs4.existsSync(localesDir)) {
+  if (!fs5.existsSync(localesDir)) {
     throw new Error(`No locales directory found for ${slug}`);
   }
   const locales = {};
-  const localeFiles = fs4.readdirSync(localesDir).filter((file) => file.endsWith(".json"));
+  const localeFiles = fs5.readdirSync(localesDir).filter((file) => file.endsWith(".json"));
   if (localeFiles.length === 0) {
     throw new Error(`No locale files found for ${slug}`);
   }
   for (const file of localeFiles) {
     const localeCode = file.replace(".json", "");
     const localePath = path5.join(localesDir, file);
-    const content = fs4.readFileSync(localePath, "utf-8");
+    const content = fs5.readFileSync(localePath, "utf-8");
     locales[localeCode] = JSON.parse(content);
   }
   return { config, locales };
@@ -1706,13 +1782,13 @@ async function handleImprovePublic(input) {
 }
 
 // src/tools/init-project.ts
-import fs5 from "fs";
+import fs6 from "fs";
 import path6 from "path";
 import { z as z4 } from "zod";
 import { zodToJsonSchema as zodToJsonSchema4 } from "zod-to-json-schema";
 var listSlugDirs = (dir) => {
-  if (!fs5.existsSync(dir)) return [];
-  return fs5.readdirSync(dir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+  if (!fs6.existsSync(dir)) return [];
+  return fs6.readdirSync(dir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
 };
 var initProjectInputSchema = z4.object({
   slug: z4.string().trim().optional().describe(

package/dist/chunk-AM6RGDD4.js

@@ -0,0 +1,1001 @@
+// src/constants/unified-locales.ts
+var UNIFIED_LOCALES = [
+  "af",
+  // Afrikaans - Google Play only
+  "am",
+  // Amharic - Google Play only
+  "ar",
+  // Arabic
+  "az-AZ",
+  // Azerbaijani - Google Play only
+  "be",
+  // Belarusian - Google Play only
+  "bg-BG",
+  // Bulgarian - Google Play only
+  "bn-BD",
+  // Bengali - Google Play only
+  "ca-ES",
+  // Catalan
+  "cs-CZ",
+  // Czech
+  "da-DK",
+  // Danish
+  "de-DE",
+  // German
+  "el-GR",
+  // Greek
+  "en-AU",
+  // English (Australia)
+  "en-CA",
+  // English (Canada)
+  "en-GB",
+  // English (United Kingdom)
+  "en-IN",
+  // English (India) - Google Play only
+  "en-SG",
+  // English (Singapore) - Google Play only
+  "en-US",
+  // English (United States)
+  "en-ZA",
+  // English (South Africa) - Google Play only
+  "es-419",
+  // Spanish (Latin America)
+  "es-ES",
+  // Spanish (Spain)
+  "es-US",
+  // Spanish (United States)
+  "et-EE",
+  // Estonian - Google Play only
+  "eu-ES",
+  // Basque - Google Play only
+  "fa",
+  // Persian - Google Play only
+  "fa-AE",
+  // Persian (UAE) - Google Play only
+  "fa-AF",
+  // Persian (Afghanistan) - Google Play only
+  "fa-IR",
+  // Persian (Iran) - Google Play only
+  "fi-FI",
+  // Finnish
+  "fil",
+  // Filipino - Google Play only
+  "fr-CA",
+  // French (Canada)
+  "fr-FR",
+  // French (France)
+  "gl-ES",
+  // Galician - Google Play only
+  "gu",
+  // Gujarati - Google Play only
+  "he-IL",
+  // Hebrew
+  "hi-IN",
+  // Hindi
+  "hr-HR",
+  // Croatian - Google Play only
+  "hu-HU",
+  // Hungarian
+  "hy-AM",
+  // Armenian - Google Play only
+  "id-ID",
+  // Indonesian
+  "is-IS",
+  // Icelandic - Google Play only
+  "it-IT",
+  // Italian
+  "ja-JP",
+  // Japanese
+  "ka-GE",
+  // Georgian - Google Play only
+  "kk",
+  // Kazakh - Google Play only
+  "km-KH",
+  // Khmer - Google Play only
+  "kn-IN",
+  // Kannada - Google Play only
+  "ko-KR",
+  // Korean
+  "ky-KG",
+  // Kyrgyz - Google Play only
+  "lo-LA",
+  // Lao - Google Play only
+  "lt-LT",
+  // Lithuanian - Google Play only
+  "lv-LV",
+  // Latvian - Google Play only
+  "mk-MK",
+  // Macedonian - Google Play only
+  "ml-IN",
+  // Malayalam - Google Play only
+  "mn-MN",
+  // Mongolian - Google Play only
+  "mr-IN",
+  // Marathi - Google Play only
+  "ms",
+  // Malay - Google Play only
+  "ms-MY",
+  // Malay (Malaysia)
+  "my-MM",
+  // Burmese - Google Play only
+  "ne-NP",
+  // Nepali - Google Play only
+  "nl-NL",
+  // Dutch
+  "no-NO",
+  // Norwegian
+  "pa",
+  // Punjabi - Google Play only
+  "pl-PL",
+  // Polish
+  "pt-BR",
+  // Portuguese (Brazil)
+  "pt-PT",
+  // Portuguese (Portugal)
+  "rm",
+  // Romansh - Google Play only
+  "ro-RO",
+  // Romanian
+  "ru-RU",
+  // Russian
+  "si-LK",
+  // Sinhala - Google Play only
+  "sk-SK",
+  // Slovak
+  "sl-SI",
+  // Slovenian - Google Play only
+  "sq",
+  // Albanian - Google Play only
+  "sr-RS",
+  // Serbian - Google Play only
+  "sv-SE",
+  // Swedish
+  "sw",
+  // Swahili - Google Play only
+  "ta-IN",
+  // Tamil - Google Play only
+  "te-IN",
+  // Telugu - Google Play only
+  "th-TH",
+  // Thai
+  "tr-TR",
+  // Turkish
+  "uk-UA",
+  // Ukrainian
+  "ur",
+  // Urdu - Google Play only
+  "vi-VN",
+  // Vietnamese
+  "zh-HK",
+  // Chinese (Hong Kong)
+  "zh-Hans",
+  // Chinese (Simplified)
+  "zh-Hant",
+  // Chinese (Traditional)
+  "zu"
+  // Zulu - Google Play only
+];
+var DEFAULT_LOCALE = "en-US";
+var UNIFIED_TO_APP_STORE = {
+  af: null,
+  // Not supported by App Store
+  am: null,
+  // Not supported by App Store
+  ar: "ar-SA",
+  "az-AZ": null,
+  // Not supported by App Store
+  be: null,
+  // Not supported by App Store
+  "bg-BG": null,
+  // Not supported by App Store
+  "bn-BD": null,
+  // Not supported by App Store
+  "ca-ES": "ca",
+  "cs-CZ": "cs",
+  "da-DK": "da",
+  "de-DE": "de-DE",
+  "el-GR": "el",
+  "en-AU": "en-AU",
+  "en-CA": "en-CA",
+  "en-GB": "en-GB",
+  "en-IN": null,
+  // Not supported by App Store
+  "en-SG": null,
+  // Not supported by App Store
+  "en-US": "en-US",
+  "en-ZA": null,
+  // Not supported by App Store
+  "es-419": "es-MX",
+  // Latin America → Mexico for App Store
+  "es-ES": "es-ES",
+  "es-US": null,
+  // Not supported by App Store
+  "et-EE": null,
+  // Not supported by App Store
+  "eu-ES": null,
+  // Not supported by App Store
+  fa: null,
+  // Not supported by App Store
+  "fa-AE": null,
+  // Not supported by App Store
+  "fa-AF": null,
+  // Not supported by App Store
+  "fa-IR": null,
+  // Not supported by App Store
+  "fi-FI": "fi",
+  fil: null,
+  // Not supported by App Store
+  "fr-CA": "fr-CA",
+  "fr-FR": "fr-FR",
+  "gl-ES": null,
+  // Not supported by App Store
+  gu: null,
+  // Not supported by App Store
+  "he-IL": "he",
+  "hi-IN": "hi",
+  "hr-HR": "hr",
+  "hu-HU": "hu",
+  "hy-AM": null,
+  // Not supported by App Store
+  "id-ID": "id",
+  "is-IS": null,
+  // Not supported by App Store
+  "it-IT": "it",
+  "ja-JP": "ja",
+  "ka-GE": null,
+  // Not supported by App Store
+  kk: null,
+  // Not supported by App Store
+  "km-KH": null,
+  // Not supported by App Store
+  "kn-IN": null,
+  // Not supported by App Store
+  "ko-KR": "ko",
+  "ky-KG": null,
+  // Not supported by App Store
+  "lo-LA": null,
+  // Not supported by App Store
+  "lt-LT": null,
+  // Not supported by App Store
+  "lv-LV": null,
+  // Not supported by App Store
+  "mk-MK": null,
+  // Not supported by App Store
+  "ml-IN": null,
+  // Not supported by App Store
+  "mn-MN": null,
+  // Not supported by App Store
+  "mr-IN": null,
+  // Not supported by App Store
+  ms: null,
+  // Use ms-MY for App Store Malay coverage
+  "ms-MY": "ms",
+  "my-MM": null,
+  // Not supported by App Store
+  "ne-NP": null,
+  // Not supported by App Store
+  "nl-NL": "nl-NL",
+  "no-NO": "no",
+  pa: null,
+  // Not supported by App Store
+  "pl-PL": "pl",
+  "pt-BR": "pt-BR",
+  "pt-PT": "pt-PT",
+  rm: null,
+  // Not supported by App Store
+  "ro-RO": "ro",
+  "ru-RU": "ru",
+  "si-LK": null,
+  // Not supported by App Store
+  "sk-SK": "sk",
+  "sl-SI": null,
+  // Not supported by App Store
+  sq: null,
+  // Not supported by App Store
+  "sr-RS": null,
+  // Not supported by App Store
+  "sv-SE": "sv",
+  sw: null,
+  // Not supported by App Store
+  "ta-IN": null,
+  // Not supported by App Store
+  "te-IN": null,
+  // Not supported by App Store
+  "th-TH": "th",
+  "tr-TR": "tr",
+  "uk-UA": "uk",
+  ur: null,
+  // Not supported by App Store
+  "vi-VN": "vi",
+  "zh-HK": null,
+  // Not supported by App Store
+  "zh-Hans": "zh-Hans",
+  "zh-Hant": "zh-Hant",
+  zu: null
+  // Not supported by App Store
+};
+var UNIFIED_TO_GOOGLE_PLAY = {
+  af: "af",
+  am: "am",
+  ar: "ar",
+  "az-AZ": "az-AZ",
+  be: "be",
+  "bg-BG": "bg",
+  "bn-BD": "bn-BD",
+  "ca-ES": "ca",
+  "cs-CZ": "cs-CZ",
+  "da-DK": "da-DK",
+  "de-DE": "de-DE",
+  "el-GR": "el-GR",
+  "en-AU": "en-AU",
+  "en-CA": "en-CA",
+  "en-GB": "en-GB",
+  "en-IN": "en-IN",
+  "en-SG": "en-SG",
+  "en-US": "en-US",
+  "en-ZA": "en-ZA",
+  "es-419": "es-419",
+  "es-ES": "es-ES",
+  "es-US": "es-US",
+  "et-EE": "et",
+  "eu-ES": "eu-ES",
+  fa: "fa",
+  "fa-AE": "fa-AE",
+  "fa-AF": "fa-AF",
+  "fa-IR": "fa-IR",
+  "fi-FI": "fi-FI",
+  fil: "fil",
+  "fr-CA": "fr-CA",
+  "fr-FR": "fr-FR",
+  "gl-ES": "gl-ES",
+  gu: "gu",
+  "he-IL": "iw-IL",
+  "hi-IN": "hi-IN",
+  "hr-HR": "hr",
+  "hu-HU": "hu-HU",
+  "hy-AM": "hy-AM",
+  "id-ID": "id",
+  // Google Play also accepts "in"
+  "is-IS": "is-IS",
+  "it-IT": "it-IT",
+  "ja-JP": "ja-JP",
+  "ka-GE": "ka-GE",
+  kk: "kk",
+  "km-KH": "km-KH",
+  "kn-IN": "kn-IN",
+  "ko-KR": "ko-KR",
+  "ky-KG": "ky-KG",
+  "lo-LA": "lo-LA",
+  "lt-LT": "lt",
+  "lv-LV": "lv",
+  "mk-MK": "mk-MK",
+  "ml-IN": "ml-IN",
+  "mn-MN": "mn-MN",
+  "mr-IN": "mr-IN",
+  ms: "ms",
+  "ms-MY": "ms-MY",
+  "my-MM": "my-MM",
+  "ne-NP": "ne-NP",
+  "nl-NL": "nl-NL",
+  "no-NO": "no-NO",
+  pa: "pa",
+  "pl-PL": "pl-PL",
+  "pt-BR": "pt-BR",
+  "pt-PT": "pt-PT",
+  rm: "rm",
+  "ro-RO": "ro",
+  "ru-RU": "ru-RU",
+  "si-LK": "si-LK",
+  "sk-SK": "sk",
+  "sl-SI": "sl",
+  sq: "sq",
+  "sr-RS": "sr",
+  "sv-SE": "sv-SE",
+  sw: "sw",
+  "ta-IN": "ta-IN",
+  "te-IN": "te-IN",
+  "th-TH": "th",
+  "tr-TR": "tr-TR",
+  "uk-UA": "uk",
+  ur: "ur",
+  "vi-VN": "vi",
+  "zh-HK": "zh-HK",
+  "zh-Hans": "zh-CN",
+  // Simplified Chinese → China for Google Play
+  "zh-Hant": "zh-TW",
+  // Traditional Chinese → Taiwan for Google Play
+  zu: "zu"
+};
+var APP_STORE_TO_UNIFIED = {
+  "en-US": "en-US",
+  "en-AU": "en-AU",
+  "en-CA": "en-CA",
+  "en-GB": "en-GB",
+  ko: "ko-KR",
+  ja: "ja-JP",
+  "zh-Hans": "zh-Hans",
+  "zh-Hant": "zh-Hant",
+  "fr-FR": "fr-FR",
+  "fr-CA": "fr-CA",
+  "de-DE": "de-DE",
+  it: "it-IT",
+  "es-ES": "es-ES",
+  "es-MX": "es-419",
+  // Mexico → Latin America in unified system
+  "pt-BR": "pt-BR",
+  "pt-PT": "pt-PT",
+  ru: "ru-RU",
+  "ar-SA": "ar",
+  // Saudi Arabia → Generic Arabic in unified system
+  "nl-NL": "nl-NL",
+  sv: "sv-SE",
+  da: "da-DK",
+  no: "no-NO",
+  fi: "fi-FI",
+  pl: "pl-PL",
+  tr: "tr-TR",
+  vi: "vi-VN",
+  th: "th-TH",
+  id: "id-ID",
+  ms: "ms-MY",
+  hi: "hi-IN",
+  cs: "cs-CZ",
+  sk: "sk-SK",
+  hu: "hu-HU",
+  ro: "ro-RO",
+  uk: "uk-UA",
+  he: "he-IL",
+  el: "el-GR",
+  ca: "ca-ES",
+  hr: "hr-HR"
+};
+var GOOGLE_PLAY_TO_UNIFIED = {
+  af: "af",
+  am: "am",
+  ar: "ar",
+  "az-AZ": "az-AZ",
+  be: "be",
+  bg: "bg-BG",
+  "bn-BD": "bn-BD",
+  ca: "ca-ES",
+  "cs-CZ": "cs-CZ",
+  cs: "cs-CZ",
+  "da-DK": "da-DK",
+  da: "da-DK",
+  "de-DE": "de-DE",
+  de: "de-DE",
+  "el-GR": "el-GR",
+  el: "el-GR",
+  "en-AU": "en-AU",
+  "en-CA": "en-CA",
+  "en-GB": "en-GB",
+  "en-IN": "en-IN",
+  "en-SG": "en-SG",
+  "en-US": "en-US",
+  "en-ZA": "en-ZA",
+  "es-419": "es-419",
+  "es-ES": "es-ES",
+  es: "es-ES",
+  "es-US": "es-US",
+  et: "et-EE",
+  "et-EE": "et-EE",
+  "eu-ES": "eu-ES",
+  fa: "fa",
+  "fa-AE": "fa-AE",
+  "fa-AF": "fa-AF",
+  "fa-IR": "fa-IR",
+  "fi-FI": "fi-FI",
+  fi: "fi-FI",
+  fil: "fil",
+  "fr-FR": "fr-FR",
+  fr: "fr-FR",
+  "fr-CA": "fr-CA",
+  "gl-ES": "gl-ES",
+  gu: "gu",
+  "iw-IL": "he-IL",
+  "he-IL": "he-IL",
+  he: "he-IL",
+  "hi-IN": "hi-IN",
+  hi: "hi-IN",
+  hr: "hr-HR",
+  "hu-HU": "hu-HU",
+  hu: "hu-HU",
+  "hy-AM": "hy-AM",
+  id: "id-ID",
+  // Google Play "id" or "in" maps to unified "id-ID"
+  in: "id-ID",
+  // Alternative Indonesian code
+  "is-IS": "is-IS",
+  "it-IT": "it-IT",
+  it: "it-IT",
+  "ja-JP": "ja-JP",
+  ja: "ja-JP",
+  "ka-GE": "ka-GE",
+  kk: "kk",
+  "km-KH": "km-KH",
+  "kn-IN": "kn-IN",
+  "ko-KR": "ko-KR",
+  ko: "ko-KR",
+  "ky-KG": "ky-KG",
+  "lo-LA": "lo-LA",
+  lt: "lt-LT",
+  "lt-LT": "lt-LT",
+  lv: "lv-LV",
+  "lv-LV": "lv-LV",
+  "mk-MK": "mk-MK",
+  "ml-IN": "ml-IN",
+  "mn-MN": "mn-MN",
+  "mr-IN": "mr-IN",
+  ms: "ms",
+  "ms-MY": "ms-MY",
+  "my-MM": "my-MM",
+  "ne-NP": "ne-NP",
+  "nl-NL": "nl-NL",
+  nl: "nl-NL",
+  "no-NO": "no-NO",
+  no: "no-NO",
+  pa: "pa",
+  "pl-PL": "pl-PL",
+  pl: "pl-PL",
+  "pt-BR": "pt-BR",
+  "pt-PT": "pt-PT",
+  rm: "rm",
+  ro: "ro-RO",
+  "ru-RU": "ru-RU",
+  ru: "ru-RU",
+  "si-LK": "si-LK",
+  sk: "sk-SK",
+  "sl-SI": "sl-SI",
+  sl: "sl-SI",
+  sq: "sq",
+  sr: "sr-RS",
+  "sv-SE": "sv-SE",
+  sv: "sv-SE",
+  sw: "sw",
+  "ta-IN": "ta-IN",
+  "te-IN": "te-IN",
+  th: "th-TH",
+  "tr-TR": "tr-TR",
+  tr: "tr-TR",
+  uk: "uk-UA",
+  ur: "ur",
+  vi: "vi-VN",
+  "zh-HK": "zh-HK",
+  "zh-CN": "zh-Hans",
+  // China → Simplified Chinese in unified system
+  "zh-TW": "zh-Hant",
+  // Taiwan → Traditional Chinese in unified system
+  zu: "zu"
+};
+var APP_STORE_SUPPORTED_LOCALES = UNIFIED_LOCALES.filter(
+  (locale) => UNIFIED_TO_APP_STORE[locale] !== null
+);
+var GOOGLE_PLAY_SUPPORTED_LOCALES = UNIFIED_LOCALES.filter(
+  (locale) => UNIFIED_TO_GOOGLE_PLAY[locale] !== null
+);
+var COMMON_SUPPORTED_LOCALES = UNIFIED_LOCALES.filter(
+  (locale) => UNIFIED_TO_APP_STORE[locale] !== null && UNIFIED_TO_GOOGLE_PLAY[locale] !== null
+);
+function appStoreToUnified(appStoreLocale) {
+  const unified = APP_STORE_TO_UNIFIED[appStoreLocale];
+  if (!unified) {
+    throw new Error(`Unknown App Store locale: ${appStoreLocale}`);
+  }
+  return unified;
+}
+function googlePlayToUnified(googlePlayLocale) {
+  const unified = GOOGLE_PLAY_TO_UNIFIED[googlePlayLocale];
+  if (!unified) {
+    throw new Error(`Unknown Google Play locale: ${googlePlayLocale}`);
+  }
+  return unified;
+}
+
+// src/types/aso/aso.types.ts
+function isSupportedLocale(locale) {
+  return UNIFIED_LOCALES.includes(locale);
+}
+function isAppStoreLocale(locale) {
+  return APP_STORE_SUPPORTED_LOCALES.includes(locale);
+}
+function isGooglePlayLocale(locale) {
+  return GOOGLE_PLAY_SUPPORTED_LOCALES.includes(locale);
+}
+function isGooglePlayMultilingual(data) {
+  return data !== void 0 && "locales" in data;
+}
+function isAppStoreMultilingual(data) {
+  return data !== void 0 && "locales" in data;
+}
+
+// src/utils/locale-converter.ts
+function unifiedToAppStore(locale) {
+  return UNIFIED_TO_APP_STORE[locale];
+}
+function unifiedToGooglePlay(locale) {
+  return UNIFIED_TO_GOOGLE_PLAY[locale];
+}
+function unifiedToBothPlatforms(locale) {
+  return {
+    appStore: unifiedToAppStore(locale),
+    googlePlay: unifiedToGooglePlay(locale)
+  };
+}
+function appStoreToUnified2(locale) {
+  return APP_STORE_TO_UNIFIED[locale] ?? DEFAULT_LOCALE;
+}
+function googlePlayToUnified2(locale) {
+  return GOOGLE_PLAY_TO_UNIFIED[locale] ?? DEFAULT_LOCALE;
+}
+function unifiedToAppStoreBatch(locales) {
+  return locales.map((locale) => unifiedToAppStore(locale)).filter((locale) => locale !== null);
+}
+function unifiedToGooglePlayBatch(locales) {
+  return locales.map((locale) => unifiedToGooglePlay(locale)).filter((locale) => locale !== null);
+}
+function appStoreToUnifiedBatch(locales) {
+  return locales.map((locale) => appStoreToUnified2(locale));
+}
+function googlePlayToUnifiedBatch(locales) {
+  return locales.map((locale) => googlePlayToUnified2(locale));
+}
+function appStoreToGooglePlay(locale) {
+  const unified = appStoreToUnified2(locale);
+  return unifiedToGooglePlay(unified);
+}
+function googlePlayToAppStore(locale) {
+  const unified = googlePlayToUnified2(locale);
+  return unifiedToAppStore(unified);
+}
+function convertObjectToAppStore(data) {
+  const result = {};
+  for (const [locale, value] of Object.entries(data)) {
+    const appStoreLocale = unifiedToAppStore(locale);
+    if (appStoreLocale !== null) {
+      result[appStoreLocale] = value;
+    }
+  }
+  return result;
+}
+function convertObjectToGooglePlay(data) {
+  const result = {};
+  for (const [locale, value] of Object.entries(data)) {
+    const googlePlayLocale = unifiedToGooglePlay(locale);
+    if (googlePlayLocale !== null) {
+      result[googlePlayLocale] = value;
+    }
+  }
+  return result;
+}
+function convertObjectFromAppStore(data) {
+  const result = {};
+  for (const [locale, value] of Object.entries(data)) {
+    const unifiedLocale = appStoreToUnified2(locale);
+    result[unifiedLocale] = value;
+  }
+  return result;
+}
+function convertObjectFromGooglePlay(data) {
+  const result = {};
+  for (const [locale, value] of Object.entries(data)) {
+    const unifiedLocale = googlePlayToUnified2(locale);
+    result[unifiedLocale] = value;
+  }
+  return result;
+}
+
+// src/utils/config.util.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+function getAsoDataDir() {
+  const configPath = path.join(
+    os.homedir(),
+    ".config",
+    "pabal-mcp",
+    "config.json"
+  );
+  if (!fs.existsSync(configPath)) {
+    throw new Error(
+      `Config file not found at ${configPath}. Please create the config file and set the 'dataDir' property to specify the ASO data directory.`
+    );
+  }
+  try {
+    const configContent = fs.readFileSync(configPath, "utf-8");
+    const config = JSON.parse(configContent);
+    if (!config.dataDir) {
+      throw new Error(
+        `'dataDir' property is not set in ${configPath}. Please set 'dataDir' to specify the ASO data directory.`
+      );
+    }
+    if (path.isAbsolute(config.dataDir)) {
+      return config.dataDir;
+    }
+    return path.resolve(os.homedir(), config.dataDir);
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("dataDir")) {
+      throw error;
+    }
+    throw new Error(
+      `Failed to read config from ${configPath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function getPullDataDir() {
+  return path.join(getAsoDataDir(), "pullData");
+}
+function getPushDataDir() {
+  return path.join(getAsoDataDir(), "pushData");
+}
+function getPublicDir() {
+  return path.join(getAsoDataDir(), "public");
+}
+function getProductsDir() {
+  return path.join(getPublicDir(), "products");
+}
+
+// src/utils/aso-converter.ts
+import fs2 from "fs";
+import path2 from "path";
+function generateFullDescription(localeData, metadata = {}) {
+  const { aso, landing } = localeData;
+  const template = aso?.template;
+  if (!template) {
+    return "";
+  }
+  const landingFeatures = landing?.features?.items || [];
+  const landingScreenshots = landing?.screenshots?.images || [];
+  const keyHeading = template.keyFeaturesHeading || "Key Features";
+  const featuresHeading = template.featuresHeading || "Additional Features";
+  const parts = [template.intro];
+  if (landingFeatures.length > 0) {
+    parts.push(
+      "",
+      keyHeading,
+      "",
+      ...landingFeatures.map(
+        (feature) => [feature.title, feature.body || ""].filter(Boolean).join("\n")
+      )
+    );
+  }
+  if (landingScreenshots.length > 0) {
+    parts.push("", featuresHeading, "");
+    parts.push(
+      ...landingScreenshots.map(
+        (screenshot) => [screenshot.title, screenshot.description || ""].filter(Boolean).join("\n")
+      )
+    );
+  }
+  parts.push("", template.outro);
+  const includeSupport = template.includeSupportLinks ?? true;
+  if (includeSupport) {
+    const contactLines = [
+      metadata.instagram ? `Instagram: ${metadata.instagram}` : null,
+      metadata.contactEmail ? `Email: ${metadata.contactEmail}` : null,
+      metadata.termsUrl ? `- Terms of Use: ${metadata.termsUrl}` : null,
+      metadata.privacyUrl ? `- Privacy Policy: ${metadata.privacyUrl}` : null
+    ].filter((line) => line !== null);
+    if (contactLines.length > 0) {
+      parts.push("", "[Contact & Support]", "", ...contactLines);
+    }
+  }
+  return parts.join("\n");
+}
+function loadAsoFromConfig(slug) {
+  const productsDir = getProductsDir();
+  const configPath = path2.join(
+    productsDir,
+    slug,
+    "config.json"
+  );
+  if (!fs2.existsSync(configPath)) {
+    return {};
+  }
+  try {
+    const configContent = fs2.readFileSync(configPath, "utf-8");
+    const config = JSON.parse(configContent);
+    const localesDir = path2.join(
+      productsDir,
+      slug,
+      "locales"
+    );
+    if (!fs2.existsSync(localesDir)) {
+      return {};
+    }
+    const localeFiles = fs2.readdirSync(localesDir).filter((f) => f.endsWith(".json"));
+    const locales = {};
+    for (const file of localeFiles) {
+      const localeCode = file.replace(".json", "");
+      const localePath = path2.join(localesDir, file);
+      const localeContent = fs2.readFileSync(localePath, "utf-8");
+      locales[localeCode] = JSON.parse(localeContent);
+    }
+    const defaultLocale = config.content?.defaultLocale || DEFAULT_LOCALE;
+    const asoData = {};
+    if (config.packageName) {
+      const googlePlayLocales = {};
+      const metadata = config.metadata || {};
+      const screenshots = metadata.screenshots || {};
+      for (const [locale, localeData] of Object.entries(locales)) {
+        if (!isGooglePlayLocale(locale)) {
+          continue;
+        }
+        const aso = localeData.aso || {};
+        const localeScreenshots = {
+          phone: screenshots.phone?.map((p) => p.replace("/screenshots/", `/screenshots/${locale}/`)),
+          tablet: screenshots.tablet?.map((p) => p.replace("/screenshots/", `/screenshots/${locale}/`))
+        };
+        googlePlayLocales[locale] = {
+          title: aso.title || "",
+          shortDescription: aso.shortDescription || "",
+          fullDescription: generateFullDescription(localeData, metadata),
+          packageName: config.packageName,
+          defaultLanguage: locale,
+          screenshots: {
+            phone: localeScreenshots.phone || [],
+            tablet: localeScreenshots.tablet
+          },
+          contactEmail: metadata.contactEmail
+        };
+      }
+      const googleLocaleKeys = Object.keys(googlePlayLocales);
+      if (googleLocaleKeys.length > 0) {
+        const hasConfigDefault = isGooglePlayLocale(defaultLocale) && Boolean(googlePlayLocales[defaultLocale]);
+        const resolvedDefault = hasConfigDefault ? defaultLocale : googlePlayLocales[DEFAULT_LOCALE] ? DEFAULT_LOCALE : googleLocaleKeys[0];
+        asoData.googlePlay = {
+          locales: googlePlayLocales,
+          defaultLocale: resolvedDefault
+        };
+      }
+    }
+    if (config.bundleId) {
+      const appStoreLocales = {};
+      const metadata = config.metadata || {};
+      const screenshots = metadata.screenshots || {};
+      for (const [locale, localeData] of Object.entries(locales)) {
+        if (!isAppStoreLocale(locale)) {
+          continue;
+        }
+        const aso = localeData.aso || {};
+        const localeScreenshots = {
+          phone: screenshots.phone?.map((p) => p.replace("/screenshots/", `/screenshots/${locale}/`)),
+          tablet: screenshots.tablet?.map((p) => p.replace("/screenshots/", `/screenshots/${locale}/`))
+        };
+        appStoreLocales[locale] = {
+          name: aso.title || "",
+          subtitle: aso.subtitle,
+          description: generateFullDescription(localeData, metadata),
+          keywords: Array.isArray(aso.keywords) ? aso.keywords.join(", ") : aso.keywords,
+          promotionalText: void 0,
+          bundleId: config.bundleId,
+          locale,
+          supportUrl: metadata.supportUrl,
+          marketingUrl: metadata.marketingUrl,
+          privacyPolicyUrl: metadata.privacyUrl,
+          screenshots: {
+            // 폰 스크린샷을 iphone65로 매핑
+            iphone65: localeScreenshots.phone || [],
+            // 태블릿 스크린샷을 ipadPro129로 매핑
+            ipadPro129: localeScreenshots.tablet
+          }
+        };
+      }
+      const appStoreLocaleKeys = Object.keys(appStoreLocales);
+      if (appStoreLocaleKeys.length > 0) {
+        const hasConfigDefault = isAppStoreLocale(defaultLocale) && Boolean(appStoreLocales[defaultLocale]);
+        const resolvedDefault = hasConfigDefault ? defaultLocale : appStoreLocales[DEFAULT_LOCALE] ? DEFAULT_LOCALE : appStoreLocaleKeys[0];
+        asoData.appStore = {
+          locales: appStoreLocales,
+          defaultLocale: resolvedDefault
+        };
+      }
+    }
+    return asoData;
+  } catch (error) {
+    console.error(`Failed to load ASO data from config for ${slug}:`, error);
+    return {};
+  }
+}
+function saveAsoToConfig(slug, config) {
+  const productsDir = getProductsDir();
+  const configPath = path2.join(
+    productsDir,
+    slug,
+    "config.json"
+  );
+  fs2.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+function saveAsoToAsoDir(slug, asoData, options) {
+  const rootDir = options?.rootDir ?? getPushDataDir();
+  if (asoData.googlePlay) {
+    const asoPath = path2.join(
+      rootDir,
+      "products",
+      slug,
+      "store",
+      "google-play",
+      "aso-data.json"
+    );
+    const dir = path2.dirname(asoPath);
+    if (!fs2.existsSync(dir)) {
+      fs2.mkdirSync(dir, { recursive: true });
+    }
+    const googlePlayData = asoData.googlePlay;
+    const multilingualData = "locales" in googlePlayData ? googlePlayData : {
+      locales: {
+        [googlePlayData.defaultLanguage || DEFAULT_LOCALE]: googlePlayData
+      },
+      defaultLocale: googlePlayData.defaultLanguage || DEFAULT_LOCALE
+    };
+    fs2.writeFileSync(
+      asoPath,
+      JSON.stringify({ googlePlay: multilingualData }, null, 2) + "\n",
+      "utf-8"
+    );
+  }
+  if (asoData.appStore) {
+    const asoPath = path2.join(
+      rootDir,
+      "products",
+      slug,
+      "store",
+      "app-store",
+      "aso-data.json"
+    );
+    const dir = path2.dirname(asoPath);
+    if (!fs2.existsSync(dir)) {
+      fs2.mkdirSync(dir, { recursive: true });
+    }
+    const appStoreData = asoData.appStore;
+    const multilingualData = "locales" in appStoreData ? appStoreData : {
+      locales: {
+        [appStoreData.locale || DEFAULT_LOCALE]: appStoreData
+      },
+      defaultLocale: appStoreData.locale || DEFAULT_LOCALE
+    };
+    fs2.writeFileSync(
+      asoPath,
+      JSON.stringify({ appStore: multilingualData }, null, 2) + "\n",
+      "utf-8"
+    );
+  }
+}
+
+export {
+  UNIFIED_LOCALES,
+  DEFAULT_LOCALE,
+  UNIFIED_TO_APP_STORE,
+  UNIFIED_TO_GOOGLE_PLAY,
+  APP_STORE_TO_UNIFIED,
+  GOOGLE_PLAY_TO_UNIFIED,
+  appStoreToUnified,
+  googlePlayToUnified,
+  isSupportedLocale,
+  isAppStoreLocale,
+  isGooglePlayLocale,
+  isGooglePlayMultilingual,
+  isAppStoreMultilingual,
+  unifiedToAppStore,
+  unifiedToGooglePlay,
+  unifiedToBothPlatforms,
+  appStoreToUnified2,
+  googlePlayToUnified2,
+  unifiedToAppStoreBatch,
+  unifiedToGooglePlayBatch,
+  appStoreToUnifiedBatch,
+  googlePlayToUnifiedBatch,
+  appStoreToGooglePlay,
+  googlePlayToAppStore,
+  convertObjectToAppStore,
+  convertObjectToGooglePlay,
+  convertObjectFromAppStore,
+  convertObjectFromGooglePlay,
+  getAsoDataDir,
+  getPullDataDir,
+  getPushDataDir,
+  getPublicDir,
+  getProductsDir,
+  loadAsoFromConfig,
+  saveAsoToConfig,
+  saveAsoToAsoDir
+};

package/dist/index.d.ts

@@ -603,11 +603,11 @@ declare function getPullDataDir(): string;
  */
 declare function getPushDataDir(): string;
 /**
- * Get the public directory path (always relative to process.cwd())
+ * Get the public directory path (dataDir/public)
  */
 declare function getPublicDir(): string;
 /**
- * Get the products directory path (public/products)
+ * Get the products directory path (dataDir/public/products)
  */
 declare function getProductsDir(): string;
 

package/dist/index.js

@@ -33,7 +33,7 @@ import {
   unifiedToBothPlatforms,
   unifiedToGooglePlay,
   unifiedToGooglePlayBatch
-} from "./chunk-MWXNTV3M.js";
+} from "./chunk-AM6RGDD4.js";
 export {
   APP_STORE_TO_UNIFIED,
   DEFAULT_LOCALE,

package/package.json

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