pabal-store-api-mcp 1.2.2 → 1.3.1

package/dist/src/core/helpers/screenshot-helpers.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Screenshot upload helper utilities
+ * Shared logic for Google Play and App Store screenshot operations
+ */
+/**
+ * Device type mappings for App Store screenshots
+ */
+export declare const APP_STORE_DEVICE_TYPES: {
+    readonly iphone67: "APP_IPHONE_67";
+    readonly iphone65: "APP_IPHONE_65";
+    readonly iphone61: "APP_IPHONE_61";
+    readonly iphone58: "APP_IPHONE_58";
+    readonly iphone55: "APP_IPHONE_55";
+    readonly iphone47: "APP_IPHONE_47";
+    readonly iphone40: "APP_IPHONE_40";
+    readonly ipadPro129: "APP_IPAD_PRO_3GEN_129";
+    readonly ipadPro11: "APP_IPAD_PRO_11";
+    readonly ipad105: "APP_IPAD_105";
+    readonly ipad97: "APP_IPAD_97";
+};
+export type AppStoreDeviceType = keyof typeof APP_STORE_DEVICE_TYPES;
+export type AppStoreScreenshotDisplayType = (typeof APP_STORE_DEVICE_TYPES)[AppStoreDeviceType];
+/**
+ * Screenshot file info parsed from filename
+ */
+export interface ParsedScreenshotFile {
+    filename: string;
+    path: string;
+    deviceType: string;
+    order: number;
+}
+/**
+ * Parse App Store screenshot filename
+ * @param filename e.g., "iphone65-1.png"
+ * @returns Parsed info or null if invalid
+ */
+export declare function parseAppStoreScreenshotFilename(filename: string, basePath: string): ParsedScreenshotFile | null;
+/**
+ * Group screenshots by device type with ordering
+ */
+export declare function groupScreenshotsByDeviceType(screenshots: ParsedScreenshotFile[]): Record<string, ParsedScreenshotFile[]>;
+/**
+ * Get screenshot files for a locale
+ * @returns Array of PNG files in the directory, or empty array if directory doesn't exist
+ */
+export declare function getLocaleScreenshotFiles(screenshotsBaseDir: string, locale: string): string[];
+/**
+ * Check if locale has any screenshot files
+ */
+export declare function hasScreenshots(screenshotsBaseDir: string, locale: string): boolean;
+/**
+ * Parse and group App Store screenshots for a locale
+ */
+export declare function parseAppStoreScreenshots(screenshotsBaseDir: string, locale: string): {
+    valid: Record<string, ParsedScreenshotFile[]>;
+    invalid: string[];
+    unknown: string[];
+};
+/**
+ * Parse Google Play screenshot filenames
+ * Supports: phone-*.png, tablet7-*.png, tablet10-*.png, feature-graphic.png
+ */
+export interface GooglePlayScreenshotFiles {
+    phone: string[];
+    tablet7: string[];
+    tablet10: string[];
+    featureGraphic: string | null;
+}
+export declare function parseGooglePlayScreenshots(screenshotsBaseDir: string, locale: string): GooglePlayScreenshotFiles;

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

@@ -0,0 +1,122 @@
+/**
+ * Screenshot upload helper utilities
+ * Shared logic for Google Play and App Store screenshot operations
+ */
+import { existsSync, readdirSync } from "node:fs";
+/**
+ * Device type mappings for App Store screenshots
+ */
+export const APP_STORE_DEVICE_TYPES = {
+    iphone67: "APP_IPHONE_67",
+    iphone65: "APP_IPHONE_65",
+    iphone61: "APP_IPHONE_61",
+    iphone58: "APP_IPHONE_58",
+    iphone55: "APP_IPHONE_55",
+    iphone47: "APP_IPHONE_47",
+    iphone40: "APP_IPHONE_40",
+    ipadPro129: "APP_IPAD_PRO_3GEN_129",
+    ipadPro11: "APP_IPAD_PRO_11",
+    ipad105: "APP_IPAD_105",
+    ipad97: "APP_IPAD_97",
+};
+/**
+ * Parse App Store screenshot filename
+ * @param filename e.g., "iphone65-1.png"
+ * @returns Parsed info or null if invalid
+ */
+export function parseAppStoreScreenshotFilename(filename, basePath) {
+    const match = filename.match(/^([a-zA-Z0-9]+)-(\d+)\.png$/);
+    if (!match)
+        return null;
+    const [, deviceType, orderStr] = match;
+    const order = parseInt(orderStr, 10);
+    if (!APP_STORE_DEVICE_TYPES[deviceType]) {
+        return null;
+    }
+    return {
+        filename,
+        path: `${basePath}/${filename}`,
+        deviceType: APP_STORE_DEVICE_TYPES[deviceType],
+        order,
+    };
+}
+/**
+ * Group screenshots by device type with ordering
+ */
+export function groupScreenshotsByDeviceType(screenshots) {
+    const grouped = {};
+    for (const screenshot of screenshots) {
+        if (!grouped[screenshot.deviceType]) {
+            grouped[screenshot.deviceType] = [];
+        }
+        grouped[screenshot.deviceType].push(screenshot);
+    }
+    // Sort each group by order
+    for (const deviceType in grouped) {
+        grouped[deviceType].sort((a, b) => a.order - b.order);
+    }
+    return grouped;
+}
+/**
+ * Get screenshot files for a locale
+ * @returns Array of PNG files in the directory, or empty array if directory doesn't exist
+ */
+export function getLocaleScreenshotFiles(screenshotsBaseDir, locale) {
+    const localeDir = `${screenshotsBaseDir}/${locale}`;
+    if (!existsSync(localeDir)) {
+        return [];
+    }
+    return readdirSync(localeDir).filter((file) => file.endsWith(".png"));
+}
+/**
+ * Check if locale has any screenshot files
+ */
+export function hasScreenshots(screenshotsBaseDir, locale) {
+    const files = getLocaleScreenshotFiles(screenshotsBaseDir, locale);
+    return files.length > 0;
+}
+/**
+ * Parse and group App Store screenshots for a locale
+ */
+export function parseAppStoreScreenshots(screenshotsBaseDir, locale) {
+    const localeDir = `${screenshotsBaseDir}/${locale}`;
+    const files = getLocaleScreenshotFiles(screenshotsBaseDir, locale);
+    const validScreenshots = [];
+    const invalidFilenames = [];
+    const unknownDeviceTypes = [];
+    for (const file of files) {
+        const parsed = parseAppStoreScreenshotFilename(file, localeDir);
+        if (!parsed) {
+            invalidFilenames.push(file);
+            continue;
+        }
+        if (!parsed.deviceType) {
+            unknownDeviceTypes.push(file);
+            continue;
+        }
+        validScreenshots.push(parsed);
+    }
+    return {
+        valid: groupScreenshotsByDeviceType(validScreenshots),
+        invalid: invalidFilenames,
+        unknown: unknownDeviceTypes,
+    };
+}
+export function parseGooglePlayScreenshots(screenshotsBaseDir, locale) {
+    const localeDir = `${screenshotsBaseDir}/${locale}`;
+    const files = getLocaleScreenshotFiles(screenshotsBaseDir, locale);
+    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}`),
+        featureGraphic: files.includes("feature-graphic.png")
+            ? `${localeDir}/feature-graphic.png`
+            : null,
+    };
+}

package/dist/src/core/services/app-store-service.d.ts

@@ -27,11 +27,13 @@ export declare class AppStoreService {
     updateReleaseNotes(bundleId: string, releaseNotes: Record<string, string>, versionId?: string, supportedLocales?: string[]): Promise<ServiceResult<UpdatedReleaseNotesResult>>;
     pullReleaseNotes(bundleId: string): Promise<ServiceResult<AppStoreReleaseNote[]>>;
     createVersion(bundleId: string, versionString: string, autoIncrement?: boolean): Promise<ServiceResult<CreatedAppStoreVersion>>;
-    pushAsoData({ config, bundleId, localAsoData, appStoreDataPath, }: {
+    pushAsoData({ config, bundleId, localAsoData, appStoreDataPath, uploadImages, slug, }: {
         config: EnvConfig;
         bundleId?: string;
         localAsoData: PreparedAsoData;
         appStoreDataPath: string;
+        uploadImages?: boolean;
+        slug?: string;
     }): Promise<PushAsoResult>;
     verifyAuth(expirationSeconds?: number): Promise<VerifyAuthResult<{
         header: Record<string, unknown>;

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

@@ -161,7 +161,7 @@ export class AppStoreService {
             return serviceFailure(AppError.wrap(error, HTTP_STATUS.INTERNAL_SERVER_ERROR, ERROR_CODES.APP_STORE_CREATE_VERSION_FAILED, "Failed to create App Store version"));
         }
     }
-    async pushAsoData({ config, bundleId, localAsoData, appStoreDataPath, }) {
+    async pushAsoData({ config, bundleId, localAsoData, appStoreDataPath, uploadImages = false, slug, }) {
         const skip = checkPushPrerequisites({
             storeLabel: "App Store",
             configured: Boolean(config.appStore),
@@ -194,6 +194,80 @@ export class AppStoreService {
                     console.error(`[AppStore]   ✅ ${locale} uploaded successfully`);
                 }
             }
+            // Upload screenshots if enabled
+            if (uploadImages && slug) {
+                console.error(`[AppStore]   📤 Uploading screenshots...`);
+                const { getAsoPushDir } = await import("../../packages/configs/aso-config/utils.js");
+                const { parseAppStoreScreenshots, hasScreenshots } = await import("../../core/helpers/screenshot-helpers.js");
+                const pushDataDir = getAsoPushDir();
+                const screenshotsBaseDir = `${pushDataDir}/products/${slug}/store/app-store/screenshots`;
+                const uploadedLocales = [];
+                const skippedLocales = [];
+                const failedLocales = [];
+                for (const locale of localesToPush) {
+                    try {
+                        if (!hasScreenshots(screenshotsBaseDir, locale)) {
+                            console.error(`[AppStore]   ⏭️  Skipping ${locale} - no screenshots directory`);
+                            skippedLocales.push(locale);
+                            continue;
+                        }
+                        const result = parseAppStoreScreenshots(screenshotsBaseDir, locale);
+                        // Check if there are any valid screenshots
+                        const totalScreenshots = Object.values(result.valid).reduce((sum, screenshots) => sum + screenshots.length, 0);
+                        if (totalScreenshots === 0) {
+                            console.error(`[AppStore]   ⚠️  Skipping ${locale} - no valid screenshots found`);
+                            skippedLocales.push(locale);
+                            continue;
+                        }
+                        console.error(`[AppStore]   📤 Uploading screenshots for ${locale}...`);
+                        // Report parsing issues
+                        if (result.invalid.length > 0) {
+                            console.error(`[AppStore]     ⚠️  Invalid filenames: ${result.invalid.join(", ")}`);
+                        }
+                        if (result.unknown.length > 0) {
+                            console.error(`[AppStore]     ⚠️  Unknown device types: ${result.unknown.join(", ")}`);
+                        }
+                        // Upload screenshots for each device type
+                        for (const [displayType, screenshots] of Object.entries(result.valid)) {
+                            if (screenshots.length === 0)
+                                continue;
+                            console.error(`[AppStore]     📱 Uploading ${screenshots.length} screenshots for ${displayType}...`);
+                            for (const screenshot of screenshots) {
+                                try {
+                                    await client.uploadScreenshot({
+                                        imagePath: screenshot.path,
+                                        screenshotDisplayType: displayType,
+                                        locale,
+                                    });
+                                    console.error(`[AppStore]       ✅ ${screenshot.filename}`);
+                                }
+                                catch (uploadError) {
+                                    const msg = uploadError instanceof Error
+                                        ? uploadError.message
+                                        : String(uploadError);
+                                    console.error(`[AppStore]       ❌ ${screenshot.filename}: ${msg}`);
+                                }
+                            }
+                        }
+                        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)}`);
+                        failedLocales.push(locale);
+                    }
+                }
+                console.error(`[AppStore]   📊 Screenshot upload summary: ${uploadedLocales.length} succeeded, ${skippedLocales.length} skipped, ${failedLocales.length} failed`);
+                if (uploadedLocales.length > 0) {
+                    console.error(`[AppStore]     ✅ Uploaded: ${uploadedLocales.join(", ")}`);
+                }
+                if (skippedLocales.length > 0) {
+                    console.error(`[AppStore]     ⏭️  Skipped: ${skippedLocales.join(", ")}`);
+                }
+                if (failedLocales.length > 0) {
+                    console.error(`[AppStore]     ❌ Failed: ${failedLocales.join(", ")}`);
+                }
+            }
             try {
                 const updated = updateRegisteredLocales(ensuredBundleId, "appStore", localesToPush);
                 if (updated) {

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

@@ -22,11 +22,13 @@ export declare class GooglePlayService {
     updateReleaseNotes(packageName: string, releaseNotes: Record<string, string>, track?: string, supportedLocales?: string[]): Promise<ServiceResult<UpdatedReleaseNotesResult>>;
     pullReleaseNotes(packageName: string): Promise<ServiceResult<GooglePlayReleaseNote[]>>;
     createVersion(packageName: string, versionString: string, versionCodes: number[]): Promise<ServiceResult<CreatedGooglePlayVersion>>;
-    pushAsoData({ config, packageName, localAsoData, googlePlayDataPath, }: {
+    pushAsoData({ config, packageName, localAsoData, googlePlayDataPath, uploadImages, slug, }: {
         config: EnvConfig;
         packageName?: string;
         localAsoData: PreparedAsoData;
         googlePlayDataPath: string;
+        uploadImages?: boolean;
+        slug?: string;
     }): Promise<PushAsoResult>;
     verifyAuth(): Promise<VerifyAuthResult<{
         client_email: string;

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

@@ -146,7 +146,7 @@ export class GooglePlayService {
             return serviceFailure(AppError.wrap(error, HTTP_STATUS.INTERNAL_SERVER_ERROR, ERROR_CODES.GOOGLE_PLAY_CREATE_VERSION_FAILED, "Failed to create Google Play version"));
         }
     }
-    async pushAsoData({ config, packageName, localAsoData, googlePlayDataPath, }) {
+    async pushAsoData({ config, packageName, localAsoData, googlePlayDataPath, uploadImages = false, slug, }) {
         const skip = checkPushPrerequisites({
             storeLabel: "Google Play",
             configured: Boolean(config.playStore),
@@ -168,6 +168,99 @@ export class GooglePlayService {
                 console.error(`[GooglePlay]   📤 Preparing locale: ${locale}`);
             }
             await client.pushMultilingualAsoData(googlePlayData);
+            // Push app-level contact information
+            if (googlePlayData.contactEmail || googlePlayData.contactWebsite) {
+                console.error(`[GooglePlay]   📤 Pushing app details...`);
+                await client.pushAppDetails({
+                    contactEmail: googlePlayData.contactEmail,
+                    contactWebsite: googlePlayData.contactWebsite,
+                });
+                console.error(`[GooglePlay]   ✅ App details uploaded successfully`);
+            }
+            // Note: YouTube URL is pushed as part of listing data for each locale
+            // Upload screenshots if enabled
+            if (uploadImages && slug) {
+                console.error(`[GooglePlay]   📤 Uploading screenshots...`);
+                const { getAsoPushDir } = await import("../../packages/configs/aso-config/utils.js");
+                const { parseGooglePlayScreenshots, hasScreenshots } = await import("../../core/helpers/screenshot-helpers.js");
+                const pushDataDir = getAsoPushDir();
+                const screenshotsBaseDir = `${pushDataDir}/products/${slug}/store/google-play/screenshots`;
+                const uploadedLocales = [];
+                const skippedLocales = [];
+                const failedLocales = [];
+                for (const locale of localesToPush) {
+                    try {
+                        if (!hasScreenshots(screenshotsBaseDir, locale)) {
+                            console.error(`[GooglePlay]   ⏭️  Skipping ${locale} - no screenshots directory`);
+                            skippedLocales.push(locale);
+                            continue;
+                        }
+                        const screenshots = parseGooglePlayScreenshots(screenshotsBaseDir, locale);
+                        // Google Play requires minimum 2 phone screenshots
+                        const phoneCount = screenshots.phone.length + screenshots.tablet7.length;
+                        if (phoneCount < 2) {
+                            console.error(`[GooglePlay]   ⚠️  Skipping ${locale} - needs at least 2 phone/tablet7 screenshots (found ${phoneCount})`);
+                            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`);
+                        }
+                        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)}`);
+                        failedLocales.push(locale);
+                    }
+                }
+                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(", ")}`);
+                }
+                if (skippedLocales.length > 0) {
+                    console.error(`[GooglePlay]     ⏭️  Skipped: ${skippedLocales.join(", ")}`);
+                }
+                if (failedLocales.length > 0) {
+                    console.error(`[GooglePlay]     ❌ Failed: ${failedLocales.join(", ")}`);
+                }
+            }
             try {
                 const updated = updateRegisteredLocales(ensuredPackage, "googlePlay", localesToPush);
                 if (updated) {

package/dist/src/packages/configs/aso-config/types.d.ts

@@ -17,6 +17,7 @@ export interface GooglePlayAsoData {
     screenshots: GooglePlayScreenshots;
     featureGraphic?: string;
     promoGraphic?: string;
+    video?: string;
     category?: string;
     contentRating?: string;
     keywords?: string[];
@@ -29,6 +30,9 @@ export interface GooglePlayAsoData {
 export interface GooglePlayMultilingualAsoData {
     locales: Record<string, GooglePlayAsoData>;
     defaultLocale?: string;
+    contactEmail?: string;
+    contactWebsite?: string;
+    youtubeUrl?: string;
 }
 export interface GooglePlayReleaseNote {
     versionCode: number;
@@ -72,6 +76,11 @@ export interface AppStoreAsoData {
 export interface AppStoreMultilingualAsoData {
     locales: Record<string, AppStoreAsoData>;
     defaultLocale?: string;
+    contactEmail?: string;
+    supportUrl?: string;
+    marketingUrl?: string;
+    privacyPolicyUrl?: string;
+    termsUrl?: string;
 }
 export interface AppStoreReleaseNote {
     versionString: string;

package/dist/src/packages/configs/aso-config/utils.js

@@ -72,12 +72,18 @@ export function prepareAsoDataForPush(slug, configData, options) {
         const locales = isGooglePlayMultilingual(googlePlayData)
             ? googlePlayData.locales
             : { [googlePlayData.defaultLanguage || DEFAULT_LOCALE]: googlePlayData };
+        // Get app-level youtubeUrl if available
+        const appLevelYoutubeUrl = isGooglePlayMultilingual(googlePlayData)
+            ? googlePlayData.youtubeUrl
+            : undefined;
         const cleanedLocales = {};
         for (const [locale, localeData] of Object.entries(locales)) {
             const { screenshots, featureGraphic, ...rest } = localeData;
             cleanedLocales[locale] = {
                 ...rest,
                 contactWebsite: detailPageUrl,
+                // Apply app-level youtubeUrl to all locales if not already set
+                video: rest.video || appLevelYoutubeUrl,
             };
         }
         const gpDefaultLocale = isGooglePlayMultilingual(googlePlayData)
@@ -86,6 +92,11 @@ export function prepareAsoDataForPush(slug, configData, options) {
         storeData.googlePlay = {
             locales: cleanedLocales,
             defaultLocale: gpDefaultLocale || DEFAULT_LOCALE,
+            contactEmail: isGooglePlayMultilingual(googlePlayData)
+                ? googlePlayData.contactEmail
+                : undefined,
+            contactWebsite: detailPageUrl,
+            youtubeUrl: appLevelYoutubeUrl,
         };
     }
     if (configData.appStore) {

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

@@ -70,6 +70,35 @@ export declare class AppStoreClient {
     private createAppStoreVersionLocalization;
     private listScreenshotSets;
     private listScreenshots;
+    /**
+     * Upload a screenshot to App Store Connect
+     * Full implementation with 4-step process:
+     * 1. Find or create Screenshot Set for display type and locale
+     * 2. Create AppScreenshot with upload operation
+     * 3. Upload file to reserved URL
+     * 4. Commit upload operation
+     */
+    uploadScreenshot(options: {
+        imagePath: string;
+        screenshotDisplayType: string;
+        locale: string;
+    }): Promise<void>;
+    /**
+     * Find or create Screenshot Set for a specific display type
+     */
+    private findOrCreateScreenshotSet;
+    /**
+     * Create AppScreenshot with upload operation
+     */
+    private createAppScreenshot;
+    /**
+     * Upload file to reserved URL
+     */
+    private uploadFileToUrl;
+    /**
+     * Commit AppScreenshot after upload
+     */
+    private commitAppScreenshot;
     private getApi;
     private normalizeEndpoint;
     private requestCollection;

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

@@ -5,7 +5,7 @@
  * API Documentation: https://developer.apple.com/documentation/appstoreconnectapi
  */
 import { AppStoreConnectAPI } from "appstore-connect-sdk";
-import { AppsApi, AppInfosApi, AppInfoLocalizationsApi, AppScreenshotSetsApi, AppStoreVersionLocalizationsApi, AppStoreVersionsApi, ResponseError, } from "appstore-connect-sdk/openapi";
+import { AppsApi, AppInfosApi, AppInfoLocalizationsApi, AppScreenshotSetsApi, AppScreenshotsApi, AppStoreVersionLocalizationsApi, AppStoreVersionsApi, ResponseError, } from "appstore-connect-sdk/openapi";
 import { DEFAULT_LOCALE } from "../../../packages/configs/aso-config/constants.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";
@@ -565,6 +565,194 @@ export class AppStoreClient {
             return await this.handleSdkError(error);
         }
     }
+    /**
+     * Upload a screenshot to App Store Connect
+     * Full implementation with 4-step process:
+     * 1. Find or create Screenshot Set for display type and locale
+     * 2. Create AppScreenshot with upload operation
+     * 3. Upload file to reserved URL
+     * 4. Commit upload operation
+     */
+    async uploadScreenshot(options) {
+        const { imagePath, screenshotDisplayType, locale } = options;
+        const { readFileSync, statSync } = await import("node:fs");
+        const { basename } = await import("node:path");
+        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 localization for this locale
+            const localizationsResponse = await this.listAppStoreVersionLocalizations(version.id, locale);
+            let localizationId;
+            if (localizationsResponse.data?.[0]) {
+                localizationId = localizationsResponse.data[0].id;
+            }
+            else {
+                // Create localization if it doesn't exist
+                const createResponse = await this.createAppStoreVersionLocalization(version.id, locale, {});
+                localizationId = createResponse.data.id;
+            }
+            // Step 1: Find or create Screenshot Set
+            const screenshotSetId = await this.findOrCreateScreenshotSet(localizationId, screenshotDisplayType);
+            // Get file info
+            const fileBuffer = readFileSync(imagePath);
+            const fileSize = statSync(imagePath).size;
+            const fileName = basename(imagePath);
+            // Step 2: Create AppScreenshot with upload operation
+            const screenshot = await this.createAppScreenshot(screenshotSetId, fileName, fileSize);
+            // Step 3: Upload file to reserved URL
+            if (screenshot.uploadOperations &&
+                screenshot.uploadOperations.length > 0) {
+                const uploadOp = screenshot.uploadOperations[0];
+                await this.uploadFileToUrl(uploadOp.url, fileBuffer, uploadOp.method);
+            }
+            // Step 4: Commit screenshot
+            await this.commitAppScreenshot(screenshot.id);
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            console.error(`[AppStore] ❌ Screenshot upload failed for ${basename(imagePath)}: ${msg}`);
+            throw error;
+        }
+    }
+    /**
+     * Find or create Screenshot Set for a specific display type
+     */
+    async findOrCreateScreenshotSet(localizationId, screenshotDisplayType) {
+        // List existing screenshot sets
+        const setsResponse = await this.listScreenshotSets(localizationId);
+        const existingSet = (setsResponse.data || []).find((set) => set.attributes?.screenshotDisplayType === screenshotDisplayType);
+        if (existingSet) {
+            return existingSet.id;
+        }
+        // Create new screenshot set
+        const appScreenshotSetsApi = await this.getApi(AppScreenshotSetsApi);
+        try {
+            const response = await appScreenshotSetsApi.appScreenshotSetsCreateInstance({
+                appScreenshotSetCreateRequest: {
+                    data: {
+                        type: "appScreenshotSets",
+                        attributes: {
+                            screenshotDisplayType: screenshotDisplayType,
+                        },
+                        relationships: {
+                            appStoreVersionLocalization: {
+                                data: {
+                                    type: "appStoreVersionLocalizations",
+                                    id: localizationId,
+                                },
+                            },
+                        },
+                    },
+                },
+            });
+            return response.data.id;
+        }
+        catch (error) {
+            return await this.handleSdkError(error);
+        }
+    }
+    /**
+     * Create AppScreenshot with upload operation
+     */
+    async createAppScreenshot(screenshotSetId, fileName, fileSize) {
+        const appScreenshotsApi = await this.getApi(AppScreenshotsApi);
+        try {
+            const response = await appScreenshotsApi.appScreenshotsCreateInstance({
+                appScreenshotCreateRequest: {
+                    data: {
+                        type: "appScreenshots",
+                        attributes: {
+                            fileName,
+                            fileSize,
+                        },
+                        relationships: {
+                            appScreenshotSet: {
+                                data: {
+                                    type: "appScreenshotSets",
+                                    id: screenshotSetId,
+                                },
+                            },
+                        },
+                    },
+                },
+            });
+            const screenshot = response.data;
+            const uploadOps = screenshot.attributes?.uploadOperations || [];
+            return {
+                id: screenshot.id,
+                uploadOperations: uploadOps.map((op) => ({
+                    url: op.url,
+                    method: op.method || "PUT",
+                    length: op.length,
+                    offset: op.offset,
+                })),
+            };
+        }
+        catch (error) {
+            return await this.handleSdkError(error);
+        }
+    }
+    /**
+     * Upload file to reserved URL
+     */
+    async uploadFileToUrl(url, fileBuffer, method = "PUT") {
+        const https = await import("node:https");
+        const { URL } = await import("node:url");
+        return new Promise((resolve, reject) => {
+            const parsedUrl = new URL(url);
+            const options = {
+                hostname: parsedUrl.hostname,
+                port: parsedUrl.port,
+                path: parsedUrl.pathname + parsedUrl.search,
+                method,
+                headers: {
+                    "Content-Type": "image/png",
+                    "Content-Length": fileBuffer.length,
+                },
+            };
+            const req = https.request(options, (res) => {
+                if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`Upload failed with status ${res.statusCode}`));
+                }
+            });
+            req.on("error", reject);
+            req.write(fileBuffer);
+            req.end();
+        });
+    }
+    /**
+     * Commit AppScreenshot after upload
+     */
+    async commitAppScreenshot(screenshotId) {
+        const appScreenshotsApi = await this.getApi(AppScreenshotsApi);
+        try {
+            await appScreenshotsApi.appScreenshotsUpdateInstance({
+                id: screenshotId,
+                appScreenshotUpdateRequest: {
+                    data: {
+                        type: "appScreenshots",
+                        id: screenshotId,
+                        attributes: {
+                            uploaded: true,
+                        },
+                    },
+                },
+            });
+        }
+        catch (error) {
+            return await this.handleSdkError(error);
+        }
+    }
     async getApi(apiClass) {
         if (!this.apiCache.has(apiClass)) {
             this.apiCache.set(apiClass, this.sdk.create(apiClass));

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

@@ -31,6 +31,7 @@ export declare function buildListingRequestBody(data: {
     title?: string;
     shortDescription?: string;
     fullDescription?: string;
+    video?: string;
 }): ListingUpdateAttributes;
 /**
  * Build request body for app details update (only defined values)

package/dist/src/packages/stores/play-store/api-converters.js

@@ -121,6 +121,8 @@ export function buildListingRequestBody(data) {
         body.shortDescription = data.shortDescription;
     if (data.fullDescription)
         body.fullDescription = data.fullDescription;
+    if (data.video)
+        body.video = data.video;
     return body;
 }
 /**

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

@@ -138,11 +138,15 @@ export class GooglePlayClient {
         };
         try {
             const language = data.defaultLanguage || DEFAULT_LANGUAGE;
-            if (data.title || data.shortDescription || data.fullDescription) {
+            if (data.title ||
+                data.shortDescription ||
+                data.fullDescription ||
+                data.video) {
                 const listingBody = buildListingRequestBody({
                     title: data.title,
                     shortDescription: data.shortDescription,
                     fullDescription: data.fullDescription,
+                    video: data.video,
                 });
                 console.error(`[GooglePlayClient] Updating listing for ${language}:`, JSON.stringify(listingBody, null, 2));
                 try {
@@ -216,11 +220,13 @@ export class GooglePlayClient {
             for (const [language, localeData] of Object.entries(data.locales)) {
                 if (localeData.title ||
                     localeData.shortDescription ||
-                    localeData.fullDescription) {
+                    localeData.fullDescription ||
+                    localeData.video) {
                     const listingBody = buildListingRequestBody({
                         title: localeData.title,
                         shortDescription: localeData.shortDescription,
                         fullDescription: localeData.fullDescription,
+                        video: localeData.video,
                     });
                     console.error(`[GooglePlayClient] Updating listing for ${language}...`);
                     try {
@@ -295,6 +301,8 @@ export class GooglePlayClient {
             console.error(`[GooglePlayClient] No app details to update, skipping`);
             return;
         }
+        // Note: youtubeUrl is not part of AppDetails API
+        // YouTube URLs are managed at listing level (see pushMultilingualAsoData)
         const authClient = await this.auth.getClient();
         const editResponse = await this.createEdit(authClient, this.packageName);
         const editId = editResponse.data.id;

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

@@ -120,6 +120,7 @@ export interface UpdateReleaseNotesOptions {
  * App Details Data
  * Internal type for app details update operations
  * Based on AppDetails but with optional fields for partial updates
+ * Note: YouTube URLs are managed at listing level, not app details level
  */
 export interface AppDetailsData {
     contactEmail?: NonNullable<AppDetails["contactEmail"]>;

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

@@ -159,6 +159,8 @@ export async function handleAsoPush(options) {
                 packageName,
                 localAsoData,
                 googlePlayDataPath,
+                uploadImages,
+                slug,
             });
             results.push(formatPushResult("Google Play", result));
         }
@@ -174,6 +176,8 @@ export async function handleAsoPush(options) {
                 bundleId,
                 localAsoData,
                 appStoreDataPath,
+                uploadImages,
+                slug,
             });
             results.push(formatPushResult("App Store", appStoreResult));
         }

package/package.json

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