pabal-store-api-mcp 1.1.0

package/dist/src/packages/stores/app-store/api-endpoints.js

@@ -0,0 +1,157 @@
+/**
+ * App Store Connect API Endpoints
+ *
+ * Centralized API endpoint management for App Store Connect
+ */
+import { APP_STORE_API_BASE_URL, APP_STORE_PLATFORM, DEFAULT_APP_LIST_LIMIT, DEFAULT_VERSIONS_FETCH_LIMIT, } from "./constants.js";
+export class AppStoreApiEndpoints {
+    generateToken;
+    issuerId;
+    keyId;
+    constructor(generateToken, issuerId, keyId) {
+        this.generateToken = generateToken;
+        this.issuerId = issuerId;
+        this.keyId = keyId;
+    }
+    normalizeNextLink(nextLink) {
+        if (!nextLink)
+            return null;
+        return nextLink.replace(APP_STORE_API_BASE_URL, "");
+    }
+    async request(endpoint, options = {}) {
+        const token = await this.generateToken();
+        const url = endpoint.startsWith("http")
+            ? endpoint
+            : `${APP_STORE_API_BASE_URL}${endpoint}`;
+        const response = await fetch(url, {
+            ...options,
+            headers: {
+                Authorization: `Bearer ${token}`,
+                "Content-Type": "application/json",
+                ...options.headers,
+            },
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ errors: [] }));
+            if (response.status === 401) {
+                throw new Error(`App Store Connect API authentication failed (401 Unauthorized)\n` +
+                    `Issuer ID: ${this.issuerId}\n` +
+                    `Key ID: ${this.keyId}\n` +
+                    `Error: ${JSON.stringify(error, null, 2)}`);
+            }
+            if (response.status === 409) {
+                const errorDetails = JSON.stringify(error, null, 2);
+                if (errorDetails.includes("STATE_ERROR")) {
+                    throw new Error(`App Store Connect API error: 409 Conflict (STATE_ERROR)\n` +
+                        `Metadata cannot be modified in current state. Please check app status.\n` +
+                        `Error: ${errorDetails}`);
+                }
+            }
+            throw new Error(`App Store Connect API error: ${response.status} ${response.statusText}\n${JSON.stringify(error, null, 2)}`);
+        }
+        return response.json();
+    }
+    async listApps(nextUrl = `/apps?limit=${DEFAULT_APP_LIST_LIMIT}`) {
+        return this.request(nextUrl);
+    }
+    async findAppByBundleId(bundleId) {
+        return this.request(`/apps?filter[bundleId]=${bundleId}`);
+    }
+    async getApp(appId) {
+        return this.request(`/apps/${appId}`);
+    }
+    async listAppInfos(appId) {
+        return this.request(`/apps/${appId}/appInfos?limit=1`);
+    }
+    async listAppInfoLocalizations(appInfoId, locale) {
+        const filter = locale ? `?filter[locale]=${locale}` : "";
+        return this.request(`/appInfos/${appInfoId}/appInfoLocalizations${filter}`);
+    }
+    async updateAppInfoLocalization(localizationId, attributes) {
+        await this.request(`/appInfoLocalizations/${localizationId}`, {
+            method: "PATCH",
+            body: JSON.stringify({
+                data: {
+                    type: "appInfoLocalizations",
+                    id: localizationId,
+                    attributes,
+                },
+            }),
+        });
+    }
+    async createAppInfoLocalization(appInfoId, locale, attributes) {
+        return this.request(`/appInfoLocalizations`, {
+            method: "POST",
+            body: JSON.stringify({
+                data: {
+                    type: "appInfoLocalizations",
+                    attributes: { locale, ...attributes },
+                    relationships: {
+                        appInfo: { data: { type: "appInfos", id: appInfoId } },
+                    },
+                },
+            }),
+        });
+    }
+    async listAppStoreVersions(appId, options = {}) {
+        const { platform = APP_STORE_PLATFORM, state, limit = DEFAULT_VERSIONS_FETCH_LIMIT, } = options;
+        const queryParts = [`filter[platform]=${platform}`, `limit=${limit}`];
+        if (state)
+            queryParts.push(`filter[appStoreState]=${state}`);
+        const query = queryParts.join("&");
+        return this.request(`/apps/${appId}/appStoreVersions?${query}`);
+    }
+    async createAppStoreVersion(appId, versionString, platform = APP_STORE_PLATFORM) {
+        return this.request(`/appStoreVersions`, {
+            method: "POST",
+            body: JSON.stringify({
+                data: {
+                    type: "appStoreVersions",
+                    attributes: { platform, versionString },
+                    relationships: { app: { data: { type: "apps", id: appId } } },
+                },
+            }),
+        });
+    }
+    async listAppStoreVersionLocalizations(versionId, locale) {
+        const filter = locale ? `?filter[locale]=${locale}` : "";
+        return this.request(`/appStoreVersions/${versionId}/appStoreVersionLocalizations${filter}`);
+    }
+    async getAppStoreVersionLocalization(localizationId) {
+        return this.request(`/appStoreVersionLocalizations/${localizationId}`);
+    }
+    async updateAppStoreVersionLocalization(localizationId, attributes) {
+        await this.request(`/appStoreVersionLocalizations/${localizationId}`, {
+            method: "PATCH",
+            body: JSON.stringify({
+                data: {
+                    type: "appStoreVersionLocalizations",
+                    id: localizationId,
+                    attributes,
+                },
+            }),
+        });
+    }
+    async createAppStoreVersionLocalization(versionId, locale, attributes) {
+        return this.request(`/appStoreVersionLocalizations`, {
+            method: "POST",
+            body: JSON.stringify({
+                data: {
+                    type: "appStoreVersionLocalizations",
+                    attributes: { locale, ...attributes },
+                    relationships: {
+                        appStoreVersion: {
+                            data: { type: "appStoreVersions", id: versionId },
+                        },
+                    },
+                },
+            }),
+        });
+    }
+    async listScreenshotSets(localizationId) {
+        return this.request(`/appStoreVersionLocalizations/${localizationId}/appScreenshotSets`);
+    }
+    async listScreenshots(screenshotSetId) {
+        return this.request(`/appScreenshotSets/${screenshotSetId}/appScreenshots`);
+    }
+}

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

@@ -0,0 +1,12 @@
+import type { AppStoreConfig } from "../../../packages/configs/secrets-config/types.js";
+type JwtOptions = {
+    now?: number;
+    expirationSeconds?: number;
+};
+export declare function createAppStoreJWT(config: AppStoreConfig, options?: JwtOptions): Promise<string>;
+export declare function decodeJwt(token: string): {
+    header: Record<string, unknown>;
+    payload: Record<string, unknown>;
+    signature: string;
+};
+export {};

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

@@ -0,0 +1,36 @@
+import { SignJWT, importPKCS8 } from "jose";
+const AUDIENCE = "appstoreconnect-v1";
+const MAX_EXP_SECONDS = 60 * 20;
+const DEFAULT_EXP_SECONDS = 60 * 10;
+export async function createAppStoreJWT(config, options = {}) {
+    const nowSeconds = options.now ?? Math.floor(Date.now() / 1000);
+    const expSeconds = Math.min(options.expirationSeconds ?? DEFAULT_EXP_SECONDS, MAX_EXP_SECONDS);
+    // Normalize private key
+    const normalizedKey = config.privateKey.replace(/\\n/g, "\n").trim();
+    // Import private key in PKCS8 format
+    const privateKey = await importPKCS8(normalizedKey, "ES256");
+    // Create JWT (App Store Connect API does not require iat)
+    const jwt = await new SignJWT({
+        iss: config.issuerId,
+        aud: AUDIENCE,
+    })
+        .setProtectedHeader({
+        alg: "ES256",
+        kid: config.keyId,
+        typ: "JWT",
+    })
+        .setExpirationTime(nowSeconds + expSeconds)
+        .sign(privateKey);
+    return jwt;
+}
+export function decodeJwt(token) {
+    const [header, payload, signature] = token.split(".");
+    if (!header || !payload || !signature) {
+        throw new Error("Invalid JWT format");
+    }
+    return {
+        header: JSON.parse(Buffer.from(header, "base64url").toString("utf-8")),
+        payload: JSON.parse(Buffer.from(payload, "base64url").toString("utf-8")),
+        signature,
+    };
+}

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

@@ -0,0 +1,78 @@
+/**
+ * App Store Connect API Client
+ *
+ * Authentication: API Key (Issuer ID, Key ID, Private Key) required
+ * API Documentation: https://developer.apple.com/documentation/appstoreconnectapi
+ */
+import type { AppStoreAsoData, AppStoreMultilingualAsoData, AppStoreReleaseNote } from "../../../packages/configs/aso-config/types.js";
+import type { AppStoreClientConfig, AppStoreVersion } from "./types.js";
+export declare class AppStoreClient {
+    private issuerId;
+    private keyId;
+    private privateKey;
+    private bundleId;
+    private sdk;
+    private apiCache;
+    constructor(config: AppStoreClientConfig);
+    private normalizePrivateKey;
+    /**
+     * List all apps registered in the account
+     * @param options.onlyReleased - If true, returns only released apps (apps with READY_FOR_SALE status)
+     */
+    listAllApps(options?: {
+        onlyReleased?: boolean;
+    }): Promise<Array<{
+        id: string;
+        name: string;
+        bundleId: string;
+        sku: string;
+        isReleased: boolean;
+    }>>;
+    private checkAppReleased;
+    private getEnglishAppName;
+    /**
+     * Get supported locales for an app
+     */
+    getSupportedLocales(appId: string): Promise<string[]>;
+    private findAppId;
+    private findAppInfoId;
+    pullAsoData(options?: {
+        locale?: string;
+    }): Promise<AppStoreAsoData>;
+    pullAllLocalesAsoData(): Promise<AppStoreMultilingualAsoData>;
+    pushAsoData(data: Partial<AppStoreAsoData>): Promise<{
+        failedFields?: string[];
+    }>;
+    getAllVersions(limit?: number): Promise<AppStoreVersion[]>;
+    getLatestVersion(): Promise<AppStoreVersion | null>;
+    incrementVersion(versionString: string): string;
+    createNewVersion(versionString: string): Promise<AppStoreVersion>;
+    createNewVersionWithAutoIncrement(baseVersion?: string): Promise<AppStoreVersion>;
+    updateWhatsNew(options: {
+        versionId: string;
+        locale: string;
+        whatsNew: string;
+    }): Promise<void>;
+    pullReleaseNotes(): Promise<AppStoreReleaseNote[]>;
+    private normalizeNextLink;
+    private listApps;
+    private findAppByBundleId;
+    private getApp;
+    private listAppInfos;
+    private listAppInfoLocalizations;
+    private updateAppInfoLocalization;
+    private createAppInfoLocalization;
+    private listAppStoreVersions;
+    private createAppStoreVersion;
+    private listAppStoreVersionLocalizations;
+    private getAppStoreVersionLocalization;
+    private updateAppStoreVersionLocalization;
+    private createAppStoreVersionLocalization;
+    private listScreenshotSets;
+    private listScreenshots;
+    private getApi;
+    private normalizeEndpoint;
+    private requestCollection;
+    private formatErrorPayload;
+    private handleSdkError;
+}