pabal-store-api-mcp 1.3.2 → 1.3.3

package/dist/src/core/helpers/screenshot-helpers.js

@@ -102,19 +102,27 @@ export function parseAppStoreScreenshots(screenshotsBaseDir, locale) {
         unknown: unknownDeviceTypes,
     };
 }
+/**
+ * Sort screenshot filenames by numeric order
+ * e.g., phone-1.png, phone-2.png, phone-10.png (not phone-1, phone-10, phone-2)
+ */
+function sortByNumericOrder(files, prefix) {
+    return files.sort((a, b) => {
+        const numA = parseInt(a.replace(prefix, "").replace(".png", ""), 10);
+        const numB = parseInt(b.replace(prefix, "").replace(".png", ""), 10);
+        return numA - numB;
+    });
+}
 export function parseGooglePlayScreenshots(screenshotsBaseDir, locale) {
     const localeDir = `${screenshotsBaseDir}/${locale}`;
     const files = getLocaleScreenshotFiles(screenshotsBaseDir, locale);
+    const phoneFiles = files.filter((f) => f.startsWith("phone-") && f.endsWith(".png"));
+    const tablet7Files = files.filter((f) => f.startsWith("tablet7-") && f.endsWith(".png"));
+    const tablet10Files = files.filter((f) => f.startsWith("tablet10-") && f.endsWith(".png"));
     return {
-        phone: files
-            .filter((f) => f.startsWith("phone-") && f.endsWith(".png"))
-            .map((f) => `${localeDir}/${f}`),
-        tablet7: files
-            .filter((f) => f.startsWith("tablet7-") && f.endsWith(".png"))
-            .map((f) => `${localeDir}/${f}`),
-        tablet10: files
-            .filter((f) => f.startsWith("tablet10-") && f.endsWith(".png"))
-            .map((f) => `${localeDir}/${f}`),
+        phone: sortByNumericOrder(phoneFiles, "phone-").map((f) => `${localeDir}/${f}`),
+        tablet7: sortByNumericOrder(tablet7Files, "tablet7-").map((f) => `${localeDir}/${f}`),
+        tablet10: sortByNumericOrder(tablet10Files, "tablet10-").map((f) => `${localeDir}/${f}`),
         featureGraphic: files.includes("feature-graphic.png")
             ? `${localeDir}/feature-graphic.png`
             : null,

package/dist/src/core/services/app-store-service.js

@@ -273,26 +273,14 @@ export class AppStoreService {
                             skippedLocales.push(locale);
                             continue;
                         }
-                        console.error(`[AppStore]   📤 Uploading screenshots for ${locale}...`);
-                        // Upload screenshots
-                        for (const screenshot of screenshotsToUpload) {
-                            try {
-                                await client.uploadScreenshot({
-                                    imagePath: screenshot.path,
-                                    screenshotDisplayType: screenshot.displayType,
-                                    locale,
-                                });
-                                console.error(`[AppStore]       ✅ ${screenshot.filename}`);
-                            }
-                            catch (uploadError) {
-                                const msg = uploadError instanceof Error
-                                    ? uploadError.message
-                                    : String(uploadError);
-                                console.error(`[AppStore]       ❌ ${screenshot.filename}: ${msg}`);
-                            }
-                        }
+                        console.error(`[AppStore]   📤 Uploading screenshots for ${locale} (batch mode - will replace existing)...`);
+                        // Use batch upload method - deletes existing and uploads new
+                        const uploadResult = await client.uploadScreenshotsForLocale({
+                            locale,
+                            screenshots: screenshotsToUpload,
+                        });
+                        console.error(`[AppStore]   ✅ Screenshots for ${locale}: ${uploadResult.uploaded} uploaded, ${uploadResult.deleted} deleted, ${uploadResult.failed} failed`);
                         uploadedLocales.push(locale);
-                        console.error(`[AppStore]   ✅ Screenshots uploaded for ${locale}`);
                     }
                     catch (error) {
                         console.error(`[AppStore]   ❌ Failed to upload screenshots for ${locale}: ${error instanceof Error ? error.message : String(error)}`);

package/dist/src/core/services/google-play-service.js

@@ -231,47 +231,21 @@ export class GooglePlayService {
                             skippedLocales.push(locale);
                             continue;
                         }
-                        console.error(`[GooglePlay]   📤 Uploading screenshots for ${locale}...`);
-                        // Upload phone screenshots (phone-*.png)
-                        for (const imagePath of screenshots.phone) {
-                            await client.uploadScreenshot({
-                                imagePath,
-                                imageType: "phoneScreenshots",
-                                language: locale,
-                            });
-                            console.error(`[GooglePlay]     ✅ ${imagePath.split("/").pop()}`);
-                        }
-                        // Upload 7-inch tablet screenshots as phone
-                        for (const imagePath of screenshots.tablet7) {
-                            await client.uploadScreenshot({
-                                imagePath,
-                                imageType: "phoneScreenshots",
-                                language: locale,
-                            });
-                            console.error(`[GooglePlay]     ✅ ${imagePath.split("/").pop()} (as phone)`);
-                        }
-                        // Upload 10-inch tablet screenshots as tablet (optional)
-                        if (screenshots.tablet10.length > 0) {
-                            for (const imagePath of screenshots.tablet10) {
-                                await client.uploadScreenshot({
-                                    imagePath,
-                                    imageType: "tenInchScreenshots",
-                                    language: locale,
-                                });
-                                console.error(`[GooglePlay]     ✅ ${imagePath.split("/").pop()} (as tablet)`);
-                            }
-                        }
-                        // Upload feature graphic (optional)
-                        if (screenshots.featureGraphic) {
-                            await client.uploadScreenshot({
-                                imagePath: screenshots.featureGraphic,
-                                imageType: "featureGraphic",
-                                language: locale,
-                            });
-                            console.error(`[GooglePlay]     ✅ feature-graphic.png`);
-                        }
+                        console.error(`[GooglePlay]   📤 Uploading screenshots for ${locale} (batch mode - will replace existing)...`);
+                        // Use batch upload method - deletes existing and uploads new in single edit session
+                        // Combine phone and tablet7 screenshots as phoneScreenshots (Google Play accepts both sizes)
+                        const phoneScreenshotPaths = [
+                            ...screenshots.phone,
+                            ...screenshots.tablet7,
+                        ];
+                        const uploadResult = await client.uploadScreenshotsForLocale({
+                            language: locale,
+                            phoneScreenshots: phoneScreenshotPaths,
+                            tenInchScreenshots: screenshots.tablet10,
+                            featureGraphic: screenshots.featureGraphic || undefined,
+                        });
+                        console.error(`[GooglePlay]   ✅ Screenshots uploaded for ${locale}: ${uploadResult.uploaded.phoneScreenshots} phone, ${uploadResult.uploaded.tenInchScreenshots} tablet`);
                         uploadedLocales.push(locale);
-                        console.error(`[GooglePlay]   ✅ Screenshots uploaded for ${locale}`);
                     }
                     catch (error) {
                         console.error(`[GooglePlay]   ❌ Failed to upload screenshots for ${locale}: ${error instanceof Error ? error.message : String(error)}`);

package/dist/src/packages/stores/app-store/client.d.ts

@@ -99,6 +99,32 @@ export declare class AppStoreClient {
      * Commit AppScreenshot after upload
      */
     private commitAppScreenshot;
+    /**
+     * Delete a single screenshot
+     */
+    private deleteScreenshot;
+    /**
+     * Delete all screenshots in a screenshot set
+     */
+    private deleteAllScreenshotsInSet;
+    /**
+     * Upload multiple screenshots for a locale, replacing existing ones
+     * 1. Find or create screenshot sets for each display type
+     * 2. Delete existing screenshots in each set
+     * 3. Upload new screenshots in order
+     */
+    uploadScreenshotsForLocale(options: {
+        locale: string;
+        screenshots: Array<{
+            path: string;
+            displayType: string;
+            filename: string;
+        }>;
+    }): Promise<{
+        uploaded: number;
+        deleted: number;
+        failed: number;
+    }>;
     private getApi;
     private normalizeEndpoint;
     private requestCollection;

package/dist/src/packages/stores/app-store/client.js

@@ -753,6 +753,130 @@ export class AppStoreClient {
             return await this.handleSdkError(error);
         }
     }
+    /**
+     * Delete a single screenshot
+     */
+    async deleteScreenshot(screenshotId) {
+        const appScreenshotsApi = await this.getApi(AppScreenshotsApi);
+        try {
+            await appScreenshotsApi.appScreenshotsDeleteInstance({
+                id: screenshotId,
+            });
+        }
+        catch (error) {
+            return await this.handleSdkError(error);
+        }
+    }
+    /**
+     * Delete all screenshots in a screenshot set
+     */
+    async deleteAllScreenshotsInSet(screenshotSetId) {
+        const screenshotsResponse = await this.listScreenshots(screenshotSetId);
+        const screenshots = screenshotsResponse.data || [];
+        let deletedCount = 0;
+        for (const screenshot of screenshots) {
+            try {
+                await this.deleteScreenshot(screenshot.id);
+                deletedCount++;
+            }
+            catch (error) {
+                console.error(`[AppStore] Warning: Failed to delete screenshot ${screenshot.id}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        return deletedCount;
+    }
+    /**
+     * Upload multiple screenshots for a locale, replacing existing ones
+     * 1. Find or create screenshot sets for each display type
+     * 2. Delete existing screenshots in each set
+     * 3. Upload new screenshots in order
+     */
+    async uploadScreenshotsForLocale(options) {
+        const { locale, screenshots } = options;
+        const { readFileSync, statSync, existsSync } = await import("node:fs");
+        const { basename } = await import("node:path");
+        const result = { uploaded: 0, deleted: 0, failed: 0 };
+        if (screenshots.length === 0) {
+            return result;
+        }
+        try {
+            // Get app and version info
+            const appId = await this.findAppId();
+            const versionsResponse = await this.listAppStoreVersions(appId, {
+                platform: APP_STORE_PLATFORM,
+                limit: DEFAULT_VERSIONS_FETCH_LIMIT,
+            });
+            const version = sortVersions(versionsResponse.data || [])[0];
+            if (!version)
+                throw new Error("App Store version not found.");
+            // Find or create localization
+            const localizationsResponse = await this.listAppStoreVersionLocalizations(version.id, locale);
+            let localizationId;
+            if (localizationsResponse.data?.[0]) {
+                localizationId = localizationsResponse.data[0].id;
+            }
+            else {
+                const createResponse = await this.createAppStoreVersionLocalization(version.id, locale, {});
+                localizationId = createResponse.data.id;
+            }
+            // Group screenshots by display type
+            const byDisplayType = new Map();
+            for (const screenshot of screenshots) {
+                if (!byDisplayType.has(screenshot.displayType)) {
+                    byDisplayType.set(screenshot.displayType, []);
+                }
+                byDisplayType.get(screenshot.displayType).push({
+                    path: screenshot.path,
+                    filename: screenshot.filename,
+                });
+            }
+            // Process each display type
+            for (const [displayType, screenshotList] of byDisplayType) {
+                console.error(`[AppStore]     Processing ${displayType} (${screenshotList.length} screenshots)...`);
+                // Find or create screenshot set
+                const screenshotSetId = await this.findOrCreateScreenshotSet(localizationId, displayType);
+                // Delete existing screenshots in this set
+                const deletedCount = await this.deleteAllScreenshotsInSet(screenshotSetId);
+                if (deletedCount > 0) {
+                    console.error(`[AppStore]       🗑️  Deleted ${deletedCount} existing screenshots`);
+                    result.deleted += deletedCount;
+                }
+                // Upload new screenshots in order
+                for (const screenshot of screenshotList) {
+                    if (!existsSync(screenshot.path)) {
+                        console.error(`[AppStore]       ⚠️  File not found: ${screenshot.filename}`);
+                        result.failed++;
+                        continue;
+                    }
+                    try {
+                        const fileBuffer = readFileSync(screenshot.path);
+                        const fileSize = statSync(screenshot.path).size;
+                        // Create screenshot with upload operation
+                        const screenshotData = await this.createAppScreenshot(screenshotSetId, screenshot.filename, fileSize);
+                        // Upload file
+                        if (screenshotData.uploadOperations &&
+                            screenshotData.uploadOperations.length > 0) {
+                            const uploadOp = screenshotData.uploadOperations[0];
+                            await this.uploadFileToUrl(uploadOp.url, fileBuffer, uploadOp.method);
+                        }
+                        // Commit screenshot
+                        await this.commitAppScreenshot(screenshotData.id);
+                        console.error(`[AppStore]       ✅ ${screenshot.filename}`);
+                        result.uploaded++;
+                    }
+                    catch (error) {
+                        console.error(`[AppStore]       ❌ ${screenshot.filename}: ${error instanceof Error ? error.message : String(error)}`);
+                        result.failed++;
+                    }
+                }
+            }
+            return result;
+        }
+        catch (error) {
+            console.error(`[AppStore] Screenshot upload failed for ${locale}: ${error instanceof Error ? error.message : String(error)}`);
+            throw error;
+        }
+    }
     async getApi(apiClass) {
         if (!this.apiCache.has(apiClass)) {
             this.apiCache.set(apiClass, this.sdk.create(apiClass));

package/dist/src/packages/stores/play-store/client.d.ts

@@ -5,7 +5,7 @@
  * API Documentation: https://developers.google.com/android-publisher
  */
 import type { GooglePlayAsoData, GooglePlayMultilingualAsoData, GooglePlayReleaseNote } from "../../../packages/configs/aso-config/types.js";
-import type { GooglePlayClientConfig, AppAccessInfo, LatestReleaseInfo, ReleaseUpdateResult, CreateReleaseOptions, UploadScreenshotOptions, UpdateReleaseNotesOptions, AppDetailsData } from "./types.js";
+import type { GooglePlayClientConfig, AppAccessInfo, LatestReleaseInfo, ReleaseUpdateResult, CreateReleaseOptions, UploadScreenshotOptions, BatchUploadScreenshotsOptions, BatchUploadScreenshotsResult, UpdateReleaseNotesOptions, AppDetailsData } from "./types.js";
 export declare class GooglePlayClient {
     private auth;
     private androidPublisher;
@@ -49,6 +49,12 @@ export declare class GooglePlayClient {
     private updateListing;
     private listImages;
     private uploadImage;
+    private deleteAllImages;
+    /**
+     * Upload multiple screenshots for a locale in a single edit session
+     * Deletes existing screenshots before uploading new ones
+     */
+    uploadScreenshotsForLocale(options: BatchUploadScreenshotsOptions): Promise<BatchUploadScreenshotsResult>;
     private getTrack;
     private updateTrack;
     private listTracks;

package/dist/src/packages/stores/play-store/client.js

@@ -606,6 +606,188 @@ export class GooglePlayClient {
         }
         return { data: uploadData.image };
     }
+    async deleteAllImages(session, language, imageType) {
+        await this.androidPublisher.edits.images.deleteall({
+            auth: session.auth,
+            packageName: session.packageName,
+            editId: session.editId,
+            language,
+            imageType,
+        });
+    }
+    /**
+     * Upload multiple screenshots for a locale in a single edit session
+     * Deletes existing screenshots before uploading new ones
+     */
+    async uploadScreenshotsForLocale(options) {
+        const { language, phoneScreenshots = [], sevenInchScreenshots = [], tenInchScreenshots = [], featureGraphic, } = options;
+        const authClient = await this.auth.getClient();
+        const editResponse = await this.createEdit(authClient, this.packageName);
+        const editId = editResponse.data.id;
+        const session = {
+            auth: authClient,
+            packageName: this.packageName,
+            editId,
+        };
+        const result = {
+            language,
+            uploaded: {
+                phoneScreenshots: 0,
+                sevenInchScreenshots: 0,
+                tenInchScreenshots: 0,
+                featureGraphic: false,
+            },
+        };
+        try {
+            // Delete existing screenshots before uploading
+            if (phoneScreenshots.length > 0) {
+                console.error(`[GooglePlayClient] Deleting existing phone screenshots for ${language}...`);
+                try {
+                    await this.deleteAllImages(session, language, "phoneScreenshots");
+                }
+                catch (e) {
+                    // Ignore if no images exist
+                    if (e.code !== 404) {
+                        console.error(`[GooglePlayClient] Warning: Failed to delete phone screenshots: ${e.message}`);
+                    }
+                }
+            }
+            if (sevenInchScreenshots.length > 0) {
+                console.error(`[GooglePlayClient] Deleting existing 7-inch screenshots for ${language}...`);
+                try {
+                    await this.deleteAllImages(session, language, "sevenInchScreenshots");
+                }
+                catch (e) {
+                    if (e.code !== 404) {
+                        console.error(`[GooglePlayClient] Warning: Failed to delete 7-inch screenshots: ${e.message}`);
+                    }
+                }
+            }
+            if (tenInchScreenshots.length > 0) {
+                console.error(`[GooglePlayClient] Deleting existing 10-inch screenshots for ${language}...`);
+                try {
+                    await this.deleteAllImages(session, language, "tenInchScreenshots");
+                }
+                catch (e) {
+                    if (e.code !== 404) {
+                        console.error(`[GooglePlayClient] Warning: Failed to delete 10-inch screenshots: ${e.message}`);
+                    }
+                }
+            }
+            if (featureGraphic) {
+                console.error(`[GooglePlayClient] Deleting existing feature graphic for ${language}...`);
+                try {
+                    await this.deleteAllImages(session, language, "featureGraphic");
+                }
+                catch (e) {
+                    if (e.code !== 404) {
+                        console.error(`[GooglePlayClient] Warning: Failed to delete feature graphic: ${e.message}`);
+                    }
+                }
+            }
+            // Upload phone screenshots
+            for (let i = 0; i < phoneScreenshots.length; i++) {
+                const imagePath = phoneScreenshots[i];
+                if (!existsSync(imagePath)) {
+                    console.error(`[GooglePlayClient] Warning: Phone screenshot not found: ${imagePath}`);
+                    continue;
+                }
+                const imageBuffer = readFileSync(imagePath);
+                const fileName = imagePath.split("/").pop() || `phone-${i + 1}.png`;
+                await this.androidPublisher.edits.images.upload({
+                    auth: session.auth,
+                    packageName: session.packageName,
+                    editId: session.editId,
+                    language,
+                    imageType: "phoneScreenshots",
+                    media: {
+                        mimeType: "image/png",
+                        body: imageBuffer,
+                    },
+                });
+                console.error(`[GooglePlayClient]   ✅ Uploaded ${fileName}`);
+                result.uploaded.phoneScreenshots++;
+            }
+            // Upload 7-inch tablet screenshots
+            for (let i = 0; i < sevenInchScreenshots.length; i++) {
+                const imagePath = sevenInchScreenshots[i];
+                if (!existsSync(imagePath)) {
+                    console.error(`[GooglePlayClient] Warning: 7-inch screenshot not found: ${imagePath}`);
+                    continue;
+                }
+                const imageBuffer = readFileSync(imagePath);
+                const fileName = imagePath.split("/").pop() || `tablet7-${i + 1}.png`;
+                await this.androidPublisher.edits.images.upload({
+                    auth: session.auth,
+                    packageName: session.packageName,
+                    editId: session.editId,
+                    language,
+                    imageType: "sevenInchScreenshots",
+                    media: {
+                        mimeType: "image/png",
+                        body: imageBuffer,
+                    },
+                });
+                console.error(`[GooglePlayClient]   ✅ Uploaded ${fileName}`);
+                result.uploaded.sevenInchScreenshots++;
+            }
+            // Upload 10-inch tablet screenshots
+            for (let i = 0; i < tenInchScreenshots.length; i++) {
+                const imagePath = tenInchScreenshots[i];
+                if (!existsSync(imagePath)) {
+                    console.error(`[GooglePlayClient] Warning: 10-inch screenshot not found: ${imagePath}`);
+                    continue;
+                }
+                const imageBuffer = readFileSync(imagePath);
+                const fileName = imagePath.split("/").pop() || `tablet10-${i + 1}.png`;
+                await this.androidPublisher.edits.images.upload({
+                    auth: session.auth,
+                    packageName: session.packageName,
+                    editId: session.editId,
+                    language,
+                    imageType: "tenInchScreenshots",
+                    media: {
+                        mimeType: "image/png",
+                        body: imageBuffer,
+                    },
+                });
+                console.error(`[GooglePlayClient]   ✅ Uploaded ${fileName}`);
+                result.uploaded.tenInchScreenshots++;
+            }
+            // Upload feature graphic
+            if (featureGraphic && existsSync(featureGraphic)) {
+                const imageBuffer = readFileSync(featureGraphic);
+                await this.androidPublisher.edits.images.upload({
+                    auth: session.auth,
+                    packageName: session.packageName,
+                    editId: session.editId,
+                    language,
+                    imageType: "featureGraphic",
+                    media: {
+                        mimeType: "image/png",
+                        body: imageBuffer,
+                    },
+                });
+                console.error(`[GooglePlayClient]   ✅ Uploaded feature-graphic.png`);
+                result.uploaded.featureGraphic = true;
+            }
+            // Commit all changes
+            console.error(`[GooglePlayClient] Committing screenshots for ${language}...`);
+            await this.commitEdit(session);
+            console.error(`[GooglePlayClient] ✅ Screenshots committed for ${language}`);
+            return result;
+        }
+        catch (error) {
+            console.error(`[GooglePlayClient] Rolling back screenshot upload for ${language}...`);
+            try {
+                await this.deleteEdit(session);
+            }
+            catch {
+                // Ignore deletion failure
+            }
+            throw error;
+        }
+    }
     async getTrack(session, track) {
         const response = await this.androidPublisher.edits.tracks.get({
             auth: session.auth,

package/dist/src/packages/stores/play-store/types.d.ts

@@ -108,6 +108,31 @@ export interface UploadScreenshotOptions {
     imageType: "phoneScreenshots" | "sevenInchScreenshots" | "tenInchScreenshots" | "tvScreenshots" | "wearScreenshots" | "featureGraphic";
     language?: string;
 }
+/**
+ * Batch Upload Screenshots Options
+ * Internal type for uploading multiple screenshots in a single edit session
+ * Replaces existing screenshots (deletes all before upload)
+ */
+export interface BatchUploadScreenshotsOptions {
+    language: string;
+    phoneScreenshots?: string[];
+    sevenInchScreenshots?: string[];
+    tenInchScreenshots?: string[];
+    featureGraphic?: string;
+}
+/**
+ * Batch Upload Screenshots Result
+ * Internal type for tracking batch upload results
+ */
+export interface BatchUploadScreenshotsResult {
+    language: string;
+    uploaded: {
+        phoneScreenshots: number;
+        sevenInchScreenshots: number;
+        tenInchScreenshots: number;
+        featureGraphic: boolean;
+    };
+}
 /**
  * Update Release Notes Options
  * Internal type for updating release notes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pabal-store-api-mcp",
-  "version": "1.3.2",
+  "version": "1.3.3",
   "description": "MCP server for App Store / Play Store ASO workflows",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",