pabal-store-api-mcp 1.3.11 → 1.3.14

package/dist/src/core/services/google-play-service.d.ts

@@ -10,6 +10,10 @@ export declare function resolveGooglePlayLocales(allLocales: string[], requested
     localesToPush: string[];
     missingLocales: string[];
 };
+export declare function shouldPushGooglePlayAppDetails({ hasContactDetails, requestedLocales, }: {
+    hasContactDetails: boolean;
+    requestedLocales?: string[];
+}): boolean;
 /**
  * Google Play-facing service layer that wraps client creation and common operations.
  * Keeps MCP tools independent from client factories and SDK details.

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

@@ -6,6 +6,7 @@ import { verifyPlayStoreAuth } from "../../packages/stores/play-store/verify-aut
 import { createGooglePlayClient } from "../../core/clients/google-play-factory.js";
 import { parseGooglePlayScreenshots, hasScreenshots, } from "../../core/helpers/screenshot-helpers.js";
 import { checkPushPrerequisites, serviceFailure, toServiceResult, updateRegisteredLocales, } from "./service-helpers.js";
+const GOOGLE_PLAY_SCREENSHOT_LOCALE_BATCH_SIZE = 5;
 export function resolveGooglePlayLocales(allLocales, requestedLocales) {
     if (!requestedLocales?.length) {
         return { localesToPush: allLocales, missingLocales: [] };
@@ -16,6 +17,9 @@ export function resolveGooglePlayLocales(allLocales, requestedLocales) {
         missingLocales: requestedLocales.filter((locale) => !allLocales.includes(locale)),
     };
 }
+export function shouldPushGooglePlayAppDetails({ hasContactDetails, requestedLocales, }) {
+    return hasContactDetails && !requestedLocales?.length;
+}
 /**
  * Google Play-facing service layer that wraps client creation and common operations.
  * Keeps MCP tools independent from client factories and SDK details.
@@ -197,8 +201,13 @@ export class GooglePlayService {
                     googlePlayData.locales[locale],
                 ])),
             });
-            // Push app-level contact information
-            if (googlePlayData.contactEmail || googlePlayData.contactWebsite) {
+            // Push app-level contact information once for full pushes. Partial locale
+            // pushes are commonly batched, and repeating details edits can invalidate
+            // otherwise-successful listing commits on Google Play.
+            if (shouldPushGooglePlayAppDetails({
+                hasContactDetails: Boolean(googlePlayData.contactEmail || googlePlayData.contactWebsite),
+                requestedLocales: locales,
+            })) {
                 console.error(`[GooglePlay]   📤 Pushing app details...`);
                 await client.pushAppDetails({
                     contactEmail: googlePlayData.contactEmail,
@@ -206,6 +215,9 @@ export class GooglePlayService {
                 });
                 console.error(`[GooglePlay]   ✅ App details uploaded successfully`);
             }
+            else if (locales?.length) {
+                console.error(`[GooglePlay]   ⏭️  Skipping app details for partial locale push`);
+            }
             // Upload screenshots if enabled
             if (uploadImages && slug) {
                 console.error(`[GooglePlay]   📤 Uploading screenshots...`);
@@ -214,6 +226,7 @@ export class GooglePlayService {
                 const uploadedLocales = [];
                 const skippedLocales = [];
                 const failedLocales = [];
+                const screenshotUploadOptions = [];
                 for (const locale of localesToPush) {
                     try {
                         const localeData = googlePlayData.locales[locale];
@@ -271,11 +284,11 @@ export class GooglePlayService {
                             skippedLocales.push(locale);
                             continue;
                         }
-                        console.error(`[GooglePlay]   📤 Uploading screenshots for ${locale} (batch mode - will replace existing)...`);
+                        console.error(`[GooglePlay]   📋 Queued screenshots for ${locale} (batch mode - will replace existing)...`);
                         // Google Play upload strategy:
                         // - phone → uploads to phoneScreenshots AND sevenInchScreenshots (both use same images)
                         // - tablet → uploads to tenInchScreenshots only
-                        const uploadResult = await client.uploadScreenshotsForLocale({
+                        screenshotUploadOptions.push({
                             language: locale,
                             phoneScreenshots: screenshots.phone,
                             sevenInchScreenshots: screenshots.phone,
@@ -283,14 +296,28 @@ export class GooglePlayService {
                             featureGraphic: screenshots.featureGraphic || undefined,
                             imageUploadTimeoutMs,
                         });
-                        console.error(`[GooglePlay]   ✅ Images uploaded for ${locale}: ${uploadResult.uploaded.phoneScreenshots} phone, ${uploadResult.uploaded.sevenInchScreenshots} 7-inch, ${uploadResult.uploaded.tenInchScreenshots} 10-inch, feature graphic ${uploadResult.uploaded.featureGraphic ? "yes" : "no"}`);
-                        uploadedLocales.push(locale);
                     }
                     catch (error) {
                         console.error(`[GooglePlay]   ❌ Failed to upload screenshots for ${locale}: ${error instanceof Error ? error.message : String(error)}`);
                         failedLocales.push(locale);
                     }
                 }
+                for (let offset = 0; offset < screenshotUploadOptions.length; offset += GOOGLE_PLAY_SCREENSHOT_LOCALE_BATCH_SIZE) {
+                    const batch = screenshotUploadOptions.slice(offset, offset + GOOGLE_PLAY_SCREENSHOT_LOCALE_BATCH_SIZE);
+                    try {
+                        console.error(`[GooglePlay]   📤 Uploading screenshots for ${batch.length} locale(s) in one edit...`);
+                        const uploadResults = await client.uploadScreenshotsForLocales(batch);
+                        for (const uploadResult of uploadResults) {
+                            console.error(`[GooglePlay]   ✅ Images uploaded for ${uploadResult.language}: ${uploadResult.uploaded.phoneScreenshots} phone, ${uploadResult.uploaded.sevenInchScreenshots} 7-inch, ${uploadResult.uploaded.tenInchScreenshots} 10-inch, feature graphic ${uploadResult.uploaded.featureGraphic ? "yes" : "no"}`);
+                            uploadedLocales.push(uploadResult.language);
+                        }
+                    }
+                    catch (error) {
+                        const failedBatchLocales = batch.map((option) => option.language);
+                        console.error(`[GooglePlay]   ❌ Batch screenshot upload failed for ${failedBatchLocales.join(", ")}: ${error instanceof Error ? error.message : String(error)}`);
+                        failedLocales.push(...failedBatchLocales);
+                    }
+                }
                 console.error(`[GooglePlay]   📊 Screenshot upload summary: ${uploadedLocales.length} succeeded, ${skippedLocales.length} skipped, ${failedLocales.length} failed`);
                 if (uploadedLocales.length > 0) {
                     console.error(`[GooglePlay]     ✅ Uploaded: ${uploadedLocales.join(", ")}`);
@@ -299,7 +326,9 @@ export class GooglePlayService {
                     console.error(`[GooglePlay]     ⏭️  Skipped: ${skippedLocales.join(", ")}`);
                 }
                 if (failedLocales.length > 0) {
-                    console.error(`[GooglePlay]     ❌ Failed: ${failedLocales.join(", ")}`);
+                    const uniqueFailedLocales = [...new Set(failedLocales)];
+                    console.error(`[GooglePlay]     ❌ Failed: ${uniqueFailedLocales.join(", ")}`);
+                    throw new Error(`Screenshot upload failed for locales: ${uniqueFailedLocales.join(", ")}`);
                 }
             }
             try {

package/dist/src/index.js

@@ -204,7 +204,7 @@ registerToolWithInfo("aso-push", {
             .int()
             .positive()
             .optional()
-            .describe("Per-image upload timeout in milliseconds"),
+            .describe("Per-image upload timeout in milliseconds (default: 600000 when uploadImages=true)"),
         dryRun: z
             .boolean()
             .optional()

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

@@ -108,15 +108,34 @@ export declare class AppStoreClient {
      * Delete all screenshots in a screenshot set
      */
     private deleteAllScreenshotsInSet;
+    private deleteScreenshots;
+    private prepareScreenshotSetForUpload;
     private sanitizePathSegment;
     private getScreenshotLockPath;
     private acquireScreenshotUploadLock;
     private preflightScreenshotBatch;
     /**
-     * Upload multiple screenshots for a locale, replacing existing ones
+     * Upload multiple screenshots for a locale, replacing existing ones.
+     *
+     * Failure model:
+     *
+     * existing screenshots ──┐
+     *                        ├─ free only the slots App Store requires
+     * incoming screenshots ──┘
+     *          │
+     *          ├─ upload + commit every incoming screenshot
+     *          │
+     *          └─ only after success, delete the remaining old screenshots
+     *
+     * This avoids the old delete-first behavior where a timeout could leave the
+     * user with an empty screenshot set. If upload fails, most existing
+     * screenshots remain visible and any successfully uploaded new screenshots
+     * are left in App Store Connect for manual or retry cleanup.
+     *
      * 1. Find or create screenshot sets for each display type
-     * 2. Delete existing screenshots in each set
+     * 2. Delete only enough existing screenshots to fit the incoming batch
      * 3. Upload new screenshots in order
+     * 4. Delete remaining old screenshots after the batch succeeds
      */
     uploadScreenshotsForLocale(options: {
         locale: string;

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

@@ -12,6 +12,9 @@ import { DEFAULT_LOCALE } from "../../../packages/configs/aso-config/constants.j
 import { getAsoDir } from "../../../packages/configs/aso-config/utils.js";
 import { convertToAsoData, convertToMultilingualAsoData, convertToReleaseNote, fetchScreenshotsForLocalization, mapLocalizationsByLocale, selectEnglishAppName, sortReleaseNotes, sortVersions, } from "./api-converters.js";
 import { APP_STORE_API_BASE_URL, APP_STORE_PLATFORM, DEFAULT_APP_LIST_LIMIT, DEFAULT_VERSIONS_FETCH_LIMIT, } from "./constants.js";
+const APP_STORE_SCREENSHOT_SET_MAX_COUNT = 10;
+const DEFAULT_IMAGE_UPLOAD_TIMEOUT_MS = 10 * 60 * 1000;
+const SCREENSHOT_UPLOAD_LOCK_STALE_MS = 30 * 60 * 1000;
 export class AppStoreClient {
     issuerId;
     keyId;
@@ -727,9 +730,10 @@ export class AppStoreClient {
                 }
             });
             req.on("error", reject);
-            if (timeoutMs) {
-                req.setTimeout(timeoutMs, () => {
-                    req.destroy(new Error(`Upload timed out after ${timeoutMs}ms`));
+            const effectiveTimeoutMs = timeoutMs ?? DEFAULT_IMAGE_UPLOAD_TIMEOUT_MS;
+            if (effectiveTimeoutMs > 0) {
+                req.setTimeout(effectiveTimeoutMs, () => {
+                    req.destroy(new Error(`Upload timed out after ${effectiveTimeoutMs}ms`));
                 });
             }
             req.write(fileBuffer);
@@ -779,13 +783,47 @@ export class AppStoreClient {
     async deleteAllScreenshotsInSet(screenshotSetId) {
         const screenshotsResponse = await this.listScreenshots(screenshotSetId);
         const screenshots = screenshotsResponse.data || [];
+        return this.deleteScreenshots(screenshots);
+    }
+    async deleteScreenshots(screenshots) {
         let deletedCount = 0;
         for (const screenshot of screenshots) {
+            if (screenshot.type !== "appScreenshots") {
+                console.error(`[AppStore]       Skipping non-screenshot asset ${screenshot.id}`);
+                continue;
+            }
             await this.deleteScreenshot(screenshot.id);
             deletedCount++;
         }
         return deletedCount;
     }
+    async prepareScreenshotSetForUpload(screenshotSetId, incomingCount) {
+        if (incomingCount > APP_STORE_SCREENSHOT_SET_MAX_COUNT) {
+            throw new Error(`Preflight failed: App Store allows up to ${APP_STORE_SCREENSHOT_SET_MAX_COUNT} screenshots per display type, got ${incomingCount}`);
+        }
+        const screenshotsResponse = await this.listScreenshots(screenshotSetId);
+        const existingScreenshots = (screenshotsResponse.data || []).filter((screenshot) => screenshot.type === "appScreenshots");
+        const nonScreenshotCount = (screenshotsResponse.data || []).length - existingScreenshots.length;
+        if (nonScreenshotCount > 0) {
+            console.error(`[AppStore]       Ignoring ${nonScreenshotCount} non-screenshot asset(s) in screenshot set`);
+        }
+        const slotsToFree = Math.max(0, existingScreenshots.length +
+            incomingCount -
+            APP_STORE_SCREENSHOT_SET_MAX_COUNT);
+        // Preserve the first screenshots as long as possible. If the upload fails
+        // after freeing slots, users are more likely to still see the primary
+        // screenshots rather than the tail of the old set.
+        const screenshotsToDeleteBeforeUpload = slotsToFree > 0 ? existingScreenshots.slice(-slotsToFree) : [];
+        const screenshotsToDeleteAfterUpload = existingScreenshots.slice(0, existingScreenshots.length - slotsToFree);
+        const deletedBeforeUpload = await this.deleteScreenshots(screenshotsToDeleteBeforeUpload);
+        if (deletedBeforeUpload > 0) {
+            console.error(`[AppStore]       Deleted ${deletedBeforeUpload} existing screenshots to free upload slots`);
+        }
+        return {
+            deletedBeforeUpload,
+            screenshotsToDeleteAfterUpload,
+        };
+    }
     sanitizePathSegment(value) {
         return value.replace(/[^a-zA-Z0-9._-]/g, "_");
     }
@@ -804,9 +842,19 @@ export class AppStoreClient {
         catch (error) {
             const code = error.code;
             if (code === "EEXIST") {
-                throw new Error(`Screenshot upload lock is already held (${lockPath}). Another upload is running for this locale/display type.`);
+                const lockAgeMs = Date.now() - statSync(lockPath).mtimeMs;
+                if (lockAgeMs > SCREENSHOT_UPLOAD_LOCK_STALE_MS) {
+                    console.error(`[AppStore] Removing stale screenshot upload lock (${lockPath})`);
+                    unlinkSync(lockPath);
+                    descriptor = openSync(lockPath, "wx");
+                }
+                else {
+                    throw new Error(`Screenshot upload lock is already held (${lockPath}). Another upload is running for this locale/display type.`);
+                }
+            }
+            else {
+                throw error;
             }
-            throw error;
         }
         closeSync(descriptor);
         return () => {
@@ -852,10 +900,27 @@ export class AppStoreClient {
         }
     }
     /**
-     * Upload multiple screenshots for a locale, replacing existing ones
+     * Upload multiple screenshots for a locale, replacing existing ones.
+     *
+     * Failure model:
+     *
+     * existing screenshots ──┐
+     *                        ├─ free only the slots App Store requires
+     * incoming screenshots ──┘
+     *          │
+     *          ├─ upload + commit every incoming screenshot
+     *          │
+     *          └─ only after success, delete the remaining old screenshots
+     *
+     * This avoids the old delete-first behavior where a timeout could leave the
+     * user with an empty screenshot set. If upload fails, most existing
+     * screenshots remain visible and any successfully uploaded new screenshots
+     * are left in App Store Connect for manual or retry cleanup.
+     *
      * 1. Find or create screenshot sets for each display type
-     * 2. Delete existing screenshots in each set
+     * 2. Delete only enough existing screenshots to fit the incoming batch
      * 3. Upload new screenshots in order
+     * 4. Delete remaining old screenshots after the batch succeeds
      */
     async uploadScreenshotsForLocale(options) {
         const { locale, screenshots, imageUploadTimeoutMs } = options;
@@ -902,13 +967,10 @@ export class AppStoreClient {
                     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;
-                    }
+                    const { deletedBeforeUpload, screenshotsToDeleteAfterUpload } = await this.prepareScreenshotSetForUpload(screenshotSetId, screenshotList.length);
+                    result.deleted += deletedBeforeUpload;
                     // Upload new screenshots in order
+                    let uploadedForDisplayType = 0;
                     for (const screenshot of screenshotList) {
                         try {
                             const fileBuffer = readFileSync(screenshot.path);
@@ -925,12 +987,20 @@ export class AppStoreClient {
                             await this.commitAppScreenshot(screenshotData.id);
                             console.error(`[AppStore]       ✅ ${screenshot.filename}`);
                             result.uploaded++;
+                            uploadedForDisplayType++;
                         }
                         catch (error) {
                             result.failed++;
                             throw new Error(`[${displayType}] ${screenshot.filename}: ${error instanceof Error ? error.message : String(error)}`);
                         }
                     }
+                    if (uploadedForDisplayType === screenshotList.length) {
+                        const deletedAfterUpload = await this.deleteScreenshots(screenshotsToDeleteAfterUpload);
+                        if (deletedAfterUpload > 0) {
+                            console.error(`[AppStore]       Deleted ${deletedAfterUpload} replaced screenshots after successful upload`);
+                            result.deleted += deletedAfterUpload;
+                        }
+                    }
                 }
                 finally {
                     releaseLock();

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

@@ -55,6 +55,8 @@ export declare class GooglePlayClient {
      * Deletes existing screenshots before uploading new ones
      */
     uploadScreenshotsForLocale(options: BatchUploadScreenshotsOptions): Promise<BatchUploadScreenshotsResult>;
+    uploadScreenshotsForLocales(optionsList: BatchUploadScreenshotsOptions[]): Promise<BatchUploadScreenshotsResult[]>;
+    private uploadScreenshotsInSession;
     private uploadImageWithOptionalTimeout;
     private getTrack;
     private updateTrack;

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

@@ -620,7 +620,6 @@ export class GooglePlayClient {
      * Deletes existing screenshots before uploading new ones
      */
     async uploadScreenshotsForLocale(options) {
-        const { language, phoneScreenshots = [], sevenInchScreenshots = [], tenInchScreenshots = [], featureGraphic, imageUploadTimeoutMs, } = options;
         const authClient = await this.auth.getClient();
         const editResponse = await this.createEdit(authClient, this.packageName);
         const editId = editResponse.data.id;
@@ -629,6 +628,61 @@ export class GooglePlayClient {
             packageName: this.packageName,
             editId,
         };
+        try {
+            const result = await this.uploadScreenshotsInSession(session, options);
+            // Commit all changes
+            console.error(`[GooglePlayClient] Committing screenshots for ${options.language}...`);
+            await this.commitEdit(session);
+            console.error(`[GooglePlayClient] ✅ Screenshots committed for ${options.language}`);
+            return result;
+        }
+        catch (error) {
+            console.error(`[GooglePlayClient] Rolling back screenshot upload for ${options.language}...`);
+            try {
+                await this.deleteEdit(session);
+            }
+            catch {
+                // Ignore deletion failure
+            }
+            throw error;
+        }
+    }
+    async uploadScreenshotsForLocales(optionsList) {
+        if (optionsList.length === 0)
+            return [];
+        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,
+        };
+        try {
+            const results = [];
+            for (const options of optionsList) {
+                console.error(`[GooglePlayClient] Preparing screenshots for ${options.language}...`);
+                const result = await this.uploadScreenshotsInSession(session, options);
+                results.push(result);
+            }
+            console.error(`[GooglePlayClient] Committing screenshots for ${optionsList.length} locale(s)...`);
+            await this.commitEdit(session);
+            console.error(`[GooglePlayClient] ✅ Screenshots committed for ${optionsList.length} locale(s)`);
+            return results;
+        }
+        catch (error) {
+            console.error(`[GooglePlayClient] Rolling back batch screenshot upload...`);
+            try {
+                await this.deleteEdit(session);
+            }
+            catch {
+                // Ignore deletion failure
+            }
+            throw error;
+        }
+    }
+    async uploadScreenshotsInSession(session, options) {
+        const { language, phoneScreenshots = [], sevenInchScreenshots = [], tenInchScreenshots = [], featureGraphic, imageUploadTimeoutMs, } = options;
         const result = {
             language,
             uploaded: {
@@ -638,115 +692,94 @@ export class GooglePlayClient {
                 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 (phoneScreenshots.length > 0) {
+            console.error(`[GooglePlayClient] Deleting existing phone screenshots for ${language}...`);
+            try {
+                await this.deleteAllImages(session, language, "phoneScreenshots");
             }
-            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}`);
-                    }
+            catch (e) {
+                // Ignore if no images exist
+                if (e.code !== 404) {
+                    console.error(`[GooglePlayClient] Warning: Failed to delete phone 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 (sevenInchScreenshots.length > 0) {
+            console.error(`[GooglePlayClient] Deleting existing 7-inch screenshots for ${language}...`);
+            try {
+                await this.deleteAllImages(session, language, "sevenInchScreenshots");
             }
-            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}`);
-                    }
+            catch (e) {
+                if (e.code !== 404) {
+                    console.error(`[GooglePlayClient] Warning: Failed to delete 7-inch screenshots: ${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.uploadImageWithOptionalTimeout(session, language, "phoneScreenshots", imageBuffer, imageUploadTimeoutMs);
-                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.uploadImageWithOptionalTimeout(session, language, "sevenInchScreenshots", imageBuffer, imageUploadTimeoutMs);
-                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;
+        }
+        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}`);
                 }
-                const imageBuffer = readFileSync(imagePath);
-                const fileName = imagePath.split("/").pop() || `tablet10-${i + 1}.png`;
-                await this.uploadImageWithOptionalTimeout(session, language, "tenInchScreenshots", imageBuffer, imageUploadTimeoutMs);
-                console.error(`[GooglePlayClient]   ✅ Uploaded ${fileName}`);
-                result.uploaded.tenInchScreenshots++;
-            }
-            // Upload feature graphic
-            if (featureGraphic && existsSync(featureGraphic)) {
-                const imageBuffer = readFileSync(featureGraphic);
-                await this.uploadImageWithOptionalTimeout(session, language, "featureGraphic", imageBuffer, imageUploadTimeoutMs);
-                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}...`);
+        if (featureGraphic) {
+            console.error(`[GooglePlayClient] Deleting existing feature graphic for ${language}...`);
             try {
-                await this.deleteEdit(session);
+                await this.deleteAllImages(session, language, "featureGraphic");
             }
-            catch {
-                // Ignore deletion failure
+            catch (e) {
+                if (e.code !== 404) {
+                    console.error(`[GooglePlayClient] Warning: Failed to delete feature graphic: ${e.message}`);
+                }
             }
-            throw error;
         }
+        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.uploadImageWithOptionalTimeout(session, language, "phoneScreenshots", imageBuffer, imageUploadTimeoutMs);
+            console.error(`[GooglePlayClient]   ✅ Uploaded ${fileName}`);
+            result.uploaded.phoneScreenshots++;
+        }
+        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.uploadImageWithOptionalTimeout(session, language, "sevenInchScreenshots", imageBuffer, imageUploadTimeoutMs);
+            console.error(`[GooglePlayClient]   ✅ Uploaded ${fileName}`);
+            result.uploaded.sevenInchScreenshots++;
+        }
+        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.uploadImageWithOptionalTimeout(session, language, "tenInchScreenshots", imageBuffer, imageUploadTimeoutMs);
+            console.error(`[GooglePlayClient]   ✅ Uploaded ${fileName}`);
+            result.uploaded.tenInchScreenshots++;
+        }
+        if (featureGraphic && existsSync(featureGraphic)) {
+            const imageBuffer = readFileSync(featureGraphic);
+            await this.uploadImageWithOptionalTimeout(session, language, "featureGraphic", imageBuffer, imageUploadTimeoutMs);
+            console.error(`[GooglePlayClient]   ✅ Uploaded feature-graphic.png`);
+            result.uploaded.featureGraphic = true;
+        }
+        return result;
     }
     async uploadImageWithOptionalTimeout(session, language, imageType, imageBuffer, timeoutMs) {
         await this.androidPublisher.edits.images.upload({

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

@@ -5,11 +5,14 @@ import { AppResolutionService } from "../../core/services/app-resolution-service
 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 DEFAULT_IMAGE_UPLOAD_TIMEOUT_MS = 10 * 60 * 1000;
 const appResolutionService = new AppResolutionService();
 const appStoreService = new AppStoreService();
 const googlePlayService = new GooglePlayService();
 export async function handleAsoPush(options) {
-    const { store = "both", uploadImages = false, locales, imageUploadTimeoutMs, dryRun = false, } = options;
+    const { store = "both", uploadImages = false, locales, dryRun = false, } = options;
+    const imageUploadTimeoutMs = options.imageUploadTimeoutMs ??
+        (uploadImages ? DEFAULT_IMAGE_UPLOAD_TIMEOUT_MS : undefined);
     const resolved = appResolutionService.resolve({
         slug: options.app,
         packageName: options.packageName,

package/package.json

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