pabal-store-api-mcp 1.1.0

package/dist/src/tools/aso/pull.js

@@ -0,0 +1,264 @@
+import { isGooglePlayMultilingual, isAppStoreMultilingual, saveAsoData, downloadImage, copyLocalAssetToAso, isLocalAssetPath, resolveAppStoreImageUrl, convertToMultilingual, getAsoPullDir, getPullProductAsoDir, getScreenshotDir, getScreenshotFilePath, } from "../../packages/configs/aso-config/utils.js";
+import { getStoreTargets } from "../../packages/configs/aso-config/store.js";
+import { loadConfig } from "../../packages/configs/secrets-config/config.js";
+import { updateAppSupportedLocales } from "../../packages/configs/secrets-config/registered-apps.js";
+import { AppStoreService } from "../../core/services/app-store-service.js";
+import { GooglePlayService } from "../../core/services/google-play-service.js";
+import { AppResolutionService } from "../../core/services/app-resolution-service.js";
+const appStoreService = new AppStoreService();
+const googlePlayService = new GooglePlayService();
+const appResolutionService = new AppResolutionService();
+async function downloadScreenshotsToAso(slug, asoData, asoDir) {
+    const productStoreRoot = getPullProductAsoDir(slug, asoDir);
+    if (asoData.googlePlay) {
+        const googlePlayData = isGooglePlayMultilingual(asoData.googlePlay)
+            ? asoData.googlePlay
+            : convertToMultilingual(asoData.googlePlay, asoData.googlePlay.defaultLanguage);
+        const languages = Object.keys(googlePlayData.locales);
+        const defaultLanguage = googlePlayData.defaultLocale;
+        const targetLanguage = (defaultLanguage && googlePlayData.locales[defaultLanguage]
+            ? defaultLanguage
+            : languages[0]) || null;
+        if (targetLanguage) {
+            const localeData = googlePlayData.locales[targetLanguage];
+            const screenshotDir = getScreenshotDir(productStoreRoot, "google-play", targetLanguage);
+            if (localeData.screenshots.phone?.length > 0) {
+                console.error(`[MCP]   📥 Downloading ${localeData.screenshots.phone.length} Google Play phone screenshots...`);
+                for (let i = 0; i < localeData.screenshots.phone.length; i++) {
+                    const url = localeData.screenshots.phone[i];
+                    const outputPath = getScreenshotFilePath(screenshotDir, `phone-${i + 1}.png`);
+                    try {
+                        if (isLocalAssetPath(url)) {
+                            copyLocalAssetToAso(url, outputPath);
+                        }
+                        else {
+                            await downloadImage(url, outputPath);
+                        }
+                        console.error(`[MCP]     ✅ phone-${i + 1}.png`);
+                    }
+                    catch (error) {
+                        console.error(`[MCP]     ❌ Failed to handle screenshot ${url}: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                }
+            }
+            if (localeData.featureGraphic) {
+                console.error(`[MCP]   📥 Downloading Feature Graphic...`);
+                const outputPath = getScreenshotFilePath(screenshotDir, "feature-graphic.png");
+                try {
+                    if (isLocalAssetPath(localeData.featureGraphic)) {
+                        copyLocalAssetToAso(localeData.featureGraphic, outputPath);
+                    }
+                    else {
+                        await downloadImage(localeData.featureGraphic, outputPath);
+                    }
+                    console.error(`[MCP]     ✅ feature-graphic.png`);
+                }
+                catch (error) {
+                    console.error(`[MCP]     ❌ Failed to handle feature graphic ${localeData.featureGraphic}: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+    }
+    if (asoData.appStore) {
+        const appStoreData = isAppStoreMultilingual(asoData.appStore)
+            ? asoData.appStore
+            : convertToMultilingual(asoData.appStore, asoData.appStore.locale);
+        const locales = Object.keys(appStoreData.locales);
+        const defaultLocale = appStoreData.defaultLocale;
+        const targetLocale = (defaultLocale && appStoreData.locales[defaultLocale]
+            ? defaultLocale
+            : locales[0]) || null;
+        if (targetLocale) {
+            const localeData = appStoreData.locales[targetLocale];
+            const screenshotDir = getScreenshotDir(productStoreRoot, "app-store", targetLocale);
+            const screenshotTypes = ["iphone65", "iphone61", "ipadPro129"];
+            for (const type of screenshotTypes) {
+                const screenshots = localeData.screenshots[type];
+                if (screenshots && screenshots.length > 0) {
+                    console.error(`[MCP]   📥 Downloading ${screenshots.length} App Store ${type} screenshots...`);
+                    for (let i = 0; i < screenshots.length; i++) {
+                        let url = screenshots[i];
+                        const outputPath = getScreenshotFilePath(screenshotDir, `${type}-${i + 1}.png`);
+                        if (isLocalAssetPath(url)) {
+                            copyLocalAssetToAso(url, outputPath);
+                        }
+                        else {
+                            if (url.includes("{w}") || url.includes("{h}")) {
+                                url = resolveAppStoreImageUrl(url);
+                            }
+                            try {
+                                await downloadImage(url, outputPath);
+                            }
+                            catch (error) {
+                                console.error(`[MCP]     ❌ Failed to handle screenshot ${url}: ${error instanceof Error ? error.message : String(error)}`);
+                            }
+                        }
+                        console.error(`[MCP]     ✅ ${type}-${i + 1}.png`);
+                    }
+                }
+            }
+        }
+    }
+}
+export async function handleAsoPull(options) {
+    const { app, store, dryRun = false } = options;
+    let { packageName, bundleId } = options;
+    const { store: targetStore, includeAppStore, includeGooglePlay, } = getStoreTargets(store);
+    const resolved = appResolutionService.resolve({
+        slug: app,
+        packageName,
+        bundleId,
+    });
+    if (!resolved.success) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: resolved.error.message,
+                },
+            ],
+        };
+    }
+    const { slug, bundleId: resolvedBundleId, packageName: resolvedPackageName, hasAppStore, hasGooglePlay, } = resolved.data;
+    bundleId = resolvedBundleId;
+    packageName = resolvedPackageName;
+    console.error(`[MCP] 📥 Pulling ASO data`);
+    console.error(`[MCP]   Store: ${targetStore}`);
+    console.error(`[MCP]   App: ${slug}`);
+    if (packageName)
+        console.error(`[MCP]   Package Name: ${packageName}`);
+    if (bundleId)
+        console.error(`[MCP]   Bundle ID: ${bundleId}`);
+    console.error(`[MCP]   Mode: ${dryRun ? "Dry run" : "Actual fetch"}`);
+    let config;
+    try {
+        config = loadConfig();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            content: [
+                { type: "text", text: `❌ Failed to load config: ${message}` },
+            ],
+            isError: true,
+        };
+    }
+    const syncedData = {};
+    const pullDir = getAsoPullDir();
+    if (includeGooglePlay) {
+        if (!hasGooglePlay) {
+            console.error(`[MCP]   ⏭️  Skipping Google Play (not registered for Google Play)`);
+        }
+        else if (!config.playStore) {
+            console.error(`[MCP]   ⏭️  Skipping Google Play (not configured in ~/.config/pabal-mcp/config.json)`);
+        }
+        else if (!packageName) {
+            console.error(`[MCP]   ⏭️  Skipping Google Play (no packageName provided)`);
+        }
+        else {
+            const clientResult = googlePlayService.createClient(packageName);
+            if (!clientResult.success) {
+                console.error(`[MCP]   ❌ Failed to create Google Play client: ${clientResult.error.message}`);
+            }
+            else {
+                try {
+                    console.error(`[MCP]   📥 Fetching from Google Play...`);
+                    const data = await clientResult.data.pullAllLanguagesAsoData();
+                    syncedData.googlePlay = data;
+                    console.error(`[MCP]   ✅ Google Play data fetched`);
+                    // Update registered-apps.json with pulled locales
+                    if (data.locales && Object.keys(data.locales).length > 0) {
+                        const locales = Object.keys(data.locales);
+                        try {
+                            const updated = updateAppSupportedLocales({
+                                identifier: packageName,
+                                store: "googlePlay",
+                                locales,
+                            });
+                            if (updated) {
+                                console.error(`[MCP]   ✅ Updated registered-apps.json with ${locales.length} Google Play locales`);
+                            }
+                        }
+                        catch (updateError) {
+                            console.error(`[MCP]   ⚠️ Failed to update registered-apps.json: ${updateError instanceof Error
+                                ? updateError.message
+                                : String(updateError)}`);
+                        }
+                    }
+                }
+                catch (error) {
+                    console.error(`[MCP]   ❌ Google Play fetch failed:`, error);
+                }
+            }
+        }
+    }
+    if (includeAppStore) {
+        if (!hasAppStore) {
+            console.error(`[MCP]   ⏭️  Skipping App Store (not registered for App Store)`);
+        }
+        else if (!config.appStore) {
+            console.error(`[MCP]   ⏭️  Skipping App Store (not configured in ~/.config/pabal-mcp/config.json)`);
+        }
+        else if (!bundleId) {
+            console.error(`[MCP]   ⏭️  Skipping App Store (no bundleId provided)`);
+        }
+        else {
+            const clientResult = appStoreService.createClient(bundleId);
+            if (!clientResult.success) {
+                console.error(`[MCP]   ❌ Failed to create App Store client: ${clientResult.error.message}`);
+            }
+            else {
+                try {
+                    console.error(`[MCP]   📥 Fetching from App Store...`);
+                    const data = await clientResult.data.pullAllLocalesAsoData();
+                    syncedData.appStore = data;
+                    console.error(`[MCP]   ✅ App Store data fetched`);
+                    // Update registered-apps.json with pulled locales
+                    if (data.locales && Object.keys(data.locales).length > 0) {
+                        const locales = Object.keys(data.locales);
+                        try {
+                            const updated = updateAppSupportedLocales({
+                                identifier: bundleId,
+                                store: "appStore",
+                                locales,
+                            });
+                            if (updated) {
+                                console.error(`[MCP]   ✅ Updated registered-apps.json with ${locales.length} App Store locales`);
+                            }
+                        }
+                        catch (updateError) {
+                            console.error(`[MCP]   ⚠️ Failed to update registered-apps.json: ${updateError instanceof Error
+                                ? updateError.message
+                                : String(updateError)}`);
+                        }
+                    }
+                }
+                catch (error) {
+                    console.error(`[MCP]   ❌ App Store fetch failed:`, error);
+                }
+            }
+        }
+    }
+    if (dryRun) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `📋 Dry run - Data that would be saved:\n${JSON.stringify(syncedData, null, 2)}`,
+                },
+            ],
+        };
+    }
+    saveAsoData(slug, syncedData, { asoDir: pullDir });
+    await downloadScreenshotsToAso(slug, syncedData, pullDir);
+    return {
+        content: [
+            {
+                type: "text",
+                text: `✅ ASO data pulled\n` +
+                    `   Google Play: ${syncedData.googlePlay ? "✓" : "✗"}\n` +
+                    `   App Store: ${syncedData.appStore ? "✓" : "✗"}`,
+            },
+        ],
+    };
+}

package/dist/src/tools/aso/push.d.ts

@@ -0,0 +1,23 @@
+import type { StoreType } from "../../packages/configs/aso-config/types.js";
+interface AsoPushOptions {
+    app?: string;
+    packageName?: string;
+    bundleId?: string;
+    store?: StoreType;
+    uploadImages?: boolean;
+    dryRun?: boolean;
+}
+export declare function handleAsoPush(options: AsoPushOptions): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError?: undefined;
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: boolean;
+}>;
+export {};

package/dist/src/tools/aso/push.js

@@ -0,0 +1,189 @@
+import { isGooglePlayMultilingual, isAppStoreMultilingual, loadAsoData, saveAsoData, prepareAsoDataForPush, getAsoDir, getAsoDataPaths, getAsoPushDir, } from "../../packages/configs/aso-config/utils.js";
+import { loadConfig } from "../../packages/configs/secrets-config/config.js";
+import { existsSync } from "node:fs";
+import { AppResolutionService } from "../../core/services/app-resolution-service.js";
+import { AppStoreService } from "../../core/services/app-store-service.js";
+import { GooglePlayService } from "../../core/services/google-play-service.js";
+import { formatPushResult } from "../../core/helpers/formatters.js";
+const appResolutionService = new AppResolutionService();
+const appStoreService = new AppStoreService();
+const googlePlayService = new GooglePlayService();
+export async function handleAsoPush(options) {
+    const { store = "both", uploadImages = false, dryRun = false } = options;
+    const resolved = appResolutionService.resolve({
+        slug: options.app,
+        packageName: options.packageName,
+        bundleId: options.bundleId,
+    });
+    if (!resolved.success) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: resolved.error.message,
+                },
+            ],
+        };
+    }
+    const { slug, packageName, bundleId, hasAppStore, hasGooglePlay } = resolved.data;
+    console.error(`[MCP] 📤 Pushing ASO data`);
+    console.error(`[MCP]   Store: ${store}`);
+    console.error(`[MCP]   App: ${slug}`);
+    if (packageName)
+        console.error(`[MCP]   Package Name: ${packageName}`);
+    if (bundleId)
+        console.error(`[MCP]   Bundle ID: ${bundleId}`);
+    console.error(`[MCP]   Upload Images: ${uploadImages ? "Yes" : "No"}`);
+    console.error(`[MCP]   Mode: ${dryRun ? "Dry run" : "Actual push"}`);
+    let config;
+    try {
+        config = loadConfig();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            content: [
+                { type: "text", text: `❌ Failed to load config: ${message}` },
+            ],
+            isError: true,
+        };
+    }
+    // Load local data from ASO directory
+    const asoDir = getAsoPushDir();
+    const { googlePlay: googlePlayDataPath, appStore: appStoreDataPath } = getAsoDataPaths(slug, asoDir);
+    console.error(`[MCP]   📁 ASO Directory: ${asoDir}`);
+    console.error(`[MCP]   📁 Base ASO Dir: ${getAsoDir()}`);
+    console.error(`[MCP]   🔍 Checking data files...`);
+    console.error(`[MCP]     Google Play: ${googlePlayDataPath}`);
+    console.error(`[MCP]       Exists: ${existsSync(googlePlayDataPath) ? "✅ Yes" : "❌ No"}`);
+    console.error(`[MCP]     App Store: ${appStoreDataPath}`);
+    console.error(`[MCP]       Exists: ${existsSync(appStoreDataPath) ? "✅ Yes" : "❌ No"}`);
+    let configData;
+    try {
+        configData = loadAsoData(slug, { asoDir });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `❌ Failed to load ASO data: ${message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+    console.error(`[MCP]   📊 Loaded data status:`);
+    console.error(`[MCP]     Google Play: ${configData.googlePlay ? "✅ Loaded" : "❌ Not found"}`);
+    if (configData.googlePlay) {
+        const gpData = configData.googlePlay;
+        if (isGooglePlayMultilingual(gpData)) {
+            const locales = Object.keys(gpData.locales);
+            console.error(`[MCP]       Locales: ${locales.join(", ")} (${locales.length} total)`);
+        }
+        else {
+            console.error(`[MCP]       Language: ${gpData.defaultLanguage || "unknown"}`);
+        }
+    }
+    console.error(`[MCP]     App Store: ${configData.appStore ? "✅ Loaded" : "❌ Not found"}`);
+    if (configData.appStore) {
+        const asData = configData.appStore;
+        if (isAppStoreMultilingual(asData)) {
+            const locales = Object.keys(asData.locales);
+            console.error(`[MCP]       Locales: ${locales.join(", ")} (${locales.length} total)`);
+        }
+        else {
+            console.error(`[MCP]       Locale: ${asData.locale || "unknown"}`);
+        }
+    }
+    if (!configData.googlePlay && !configData.appStore) {
+        const errorDetails = `❌ No ASO data found for ${slug}.
+
+📁 Expected paths:
+   Google Play: ${googlePlayDataPath}
+   App Store: ${appStoreDataPath}
+
+💡 To fix this:
+   1. Run \`aso-pull\` to fetch data from stores
+   2. Or ensure data exists at the paths above
+   3. Check that data directory is set correctly (current: ${getAsoDir()})`;
+        console.error(`[MCP]   ${errorDetails}`);
+        return {
+            content: [{ type: "text", text: errorDetails }],
+        };
+    }
+    // Prepare data for push
+    console.error(`[MCP]   🔄 Preparing data for push...`);
+    const localAsoData = prepareAsoDataForPush(slug, configData);
+    console.error(`[MCP]   📊 Prepared data status:`);
+    console.error(`[MCP]     Google Play: ${localAsoData.googlePlay ? "✅ Ready" : "❌ Not available"}`);
+    if (localAsoData.googlePlay) {
+        const gpData = localAsoData.googlePlay;
+        if (isGooglePlayMultilingual(gpData)) {
+            const locales = Object.keys(gpData.locales);
+            console.error(`[MCP]       Locales to push: ${locales.join(", ")} (${locales.length} total)`);
+        }
+    }
+    console.error(`[MCP]     App Store: ${localAsoData.appStore ? "✅ Ready" : "❌ Not available"}`);
+    if (localAsoData.appStore) {
+        const asData = localAsoData.appStore;
+        if (isAppStoreMultilingual(asData)) {
+            const locales = Object.keys(asData.locales);
+            console.error(`[MCP]       Locales to push: ${locales.join(", ")} (${locales.length} total)`);
+        }
+    }
+    if (dryRun) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `📋 Dry run - Data that would be pushed:\n${JSON.stringify(localAsoData, null, 2)}`,
+                },
+            ],
+        };
+    }
+    // Save to ASO directory before pushing
+    if (localAsoData.googlePlay || localAsoData.appStore) {
+        saveAsoData(slug, localAsoData, { asoDir });
+    }
+    const results = [];
+    // Push to Google Play
+    if (store === "googlePlay" || store === "both") {
+        if (!hasGooglePlay) {
+            results.push(`⏭️  Skipping Google Play (not registered for Google Play)`);
+        }
+        else {
+            const result = await googlePlayService.pushAsoData({
+                config,
+                packageName,
+                localAsoData,
+                googlePlayDataPath,
+            });
+            results.push(formatPushResult("Google Play", result));
+        }
+    }
+    // Push to App Store
+    if (store === "appStore" || store === "both") {
+        if (!hasAppStore) {
+            results.push(`⏭️  Skipping App Store (not registered for App Store)`);
+        }
+        else {
+            const appStoreResult = await appStoreService.pushAsoData({
+                config,
+                bundleId,
+                localAsoData,
+                appStoreDataPath,
+            });
+            results.push(formatPushResult("App Store", appStoreResult));
+        }
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: `📤 ASO Push Results:\n${results.join("\n")}`,
+            },
+        ],
+    };
+}

package/dist/src/tools/auth/app-store.d.ts

@@ -0,0 +1,9 @@
+/**
+ * App Store authentication status check tool
+ */
+export declare function handleAuthAppStore(): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/src/tools/auth/app-store.js

@@ -0,0 +1,34 @@
+import { AppStoreService } from "../../core/services/app-store-service.js";
+const appStoreService = new AppStoreService();
+/**
+ * App Store authentication status check tool
+ */
+export async function handleAuthAppStore() {
+    const result = await appStoreService.verifyAuth(300);
+    const success = Boolean(result.success && result.data);
+    if (success) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        ok: true,
+                        header: result.data.header,
+                        payload: result.data.payload,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    const errorMessage = result.error?.message ||
+        "App Store authentication not configured or failed.";
+    // Keep failure response as plain text for tests that expect a string with keywords.
+    return {
+        content: [
+            {
+                type: "text",
+                text: `App Store auth failed: ${errorMessage}`,
+            },
+        ],
+    };
+}

package/dist/src/tools/auth/check.d.ts

@@ -0,0 +1,14 @@
+/**
+ * auth-check: Check App Store / Google Play authentication status
+ */
+import { type StoreType } from "../../packages/configs/aso-config/types.js";
+interface AuthCheckOptions {
+    store?: StoreType;
+}
+export declare function handleAuthCheck(options: AuthCheckOptions): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export {};

package/dist/src/tools/auth/check.js

@@ -0,0 +1,50 @@
+/**
+ * auth-check: Check App Store / Google Play authentication status
+ */
+import { getStoreTargets } from "../../packages/configs/aso-config/store.js";
+import { AppStoreService } from "../../core/services/app-store-service.js";
+import { GooglePlayService } from "../../core/services/google-play-service.js";
+const appStoreService = new AppStoreService();
+const googlePlayService = new GooglePlayService();
+export async function handleAuthCheck(options) {
+    const { store } = options;
+    const { store: targetStore, includeAppStore, includeGooglePlay, } = getStoreTargets(store);
+    const results = [];
+    console.error(`[MCP] 🔐 Checking authentication (store: ${targetStore})`);
+    if (includeAppStore) {
+        console.error(`[MCP]   Checking App Store Connect...`);
+        const appStoreResult = await appStoreService.verifyAuth(300);
+        if (appStoreResult.success && appStoreResult.data) {
+            results.push(`✅ **App Store Connect**`);
+            results.push(`   Issuer ID: ${appStoreResult.data.payload.iss}`);
+            results.push(`   Key ID: ${appStoreResult.data.header.kid}`);
+            results.push(`   JWT created successfully`);
+        }
+        else {
+            results.push(`❌ **App Store Connect**`);
+            results.push(`   ${appStoreResult.error?.message || "Authentication failed"}`);
+        }
+        results.push("");
+    }
+    if (includeGooglePlay) {
+        console.error(`[MCP]   Checking Google Play Console...`);
+        const playStoreResult = await googlePlayService.verifyAuth();
+        if (playStoreResult.success && playStoreResult.data) {
+            results.push(`✅ **Google Play Console**`);
+            results.push(`   Project: ${playStoreResult.data.project_id}`);
+            results.push(`   Service Account: ${playStoreResult.data.client_email}`);
+        }
+        else {
+            results.push(`❌ **Google Play Console**`);
+            results.push(`   ${playStoreResult.error?.message || "Authentication failed"}`);
+        }
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: `🔐 **Authentication Status**\n\n${results.join("\n")}`,
+            },
+        ],
+    };
+}

package/dist/src/tools/auth/play-store.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Google Play authentication status check tool
+ */
+export declare function handleAuthPlayStore(): Promise<{
+    content: {
+        type: "text";
+        text: string | import("../../packages/common/errors/app-error.js").AppError;
+    }[];
+}>;

package/dist/src/tools/auth/play-store.js

@@ -0,0 +1,30 @@
+import { GooglePlayService } from "../../core/services/google-play-service.js";
+const googlePlayService = new GooglePlayService();
+/**
+ * Google Play authentication status check tool
+ */
+export async function handleAuthPlayStore() {
+    const result = await googlePlayService.verifyAuth();
+    if (result.success && result.data) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        ok: true,
+                        client_email: result.data.client_email,
+                        project_id: result.data.project_id,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: result.error || "An unknown error occurred.",
+            },
+        ],
+    };
+}

package/dist/src/tools/release/check-versions.d.ts

@@ -0,0 +1,14 @@
+import { type StoreType } from "../../packages/configs/aso-config/types.js";
+interface CheckVersionsOptions {
+    app?: string;
+    packageName?: string;
+    bundleId?: string;
+    store?: StoreType;
+}
+export declare function handleCheckLatestVersions(options: CheckVersionsOptions): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export {};