pabal-store-api-mcp 1.1.0

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

@@ -0,0 +1,146 @@
+/**
+ * Google Play Console API Types
+ *
+ * Type definitions for Google Play Store operations.
+ * Types are derived from googleapis library types.
+ *
+ * @see https://developers.google.com/android-publisher
+ */
+import type { androidpublisher_v3 } from "googleapis";
+/**
+ * Auth type from googleapis
+ * Used internally for EditSession
+ */
+type AuthType = androidpublisher_v3.Params$Resource$Edits$Insert["auth"];
+/**
+ * Schema types from googleapis
+ * Re-exported for use across the codebase
+ */
+export type AppEdit = androidpublisher_v3.Schema$AppEdit;
+export type AppDetails = androidpublisher_v3.Schema$AppDetails;
+export type Listing = androidpublisher_v3.Schema$Listing;
+export type Image = androidpublisher_v3.Schema$Image;
+export type Track = androidpublisher_v3.Schema$Track;
+export type TrackRelease = androidpublisher_v3.Schema$TrackRelease;
+export type ListingsListResponse = androidpublisher_v3.Schema$ListingsListResponse;
+export type ImagesListResponse = androidpublisher_v3.Schema$ImagesListResponse;
+export type TracksListResponse = androidpublisher_v3.Schema$TracksListResponse;
+export type ImagesUploadResponse = androidpublisher_v3.Schema$ImagesUploadResponse;
+/**
+ * Google Play Client Configuration
+ * Internal type for client initialization
+ */
+export interface GooglePlayClientConfig {
+    packageName: string;
+    serviceAccountKeyPath?: string;
+    serviceAccountKey?: object;
+}
+/**
+ * Edit Session
+ * Internal helper type that extends AppEdit with auth and packageName
+ * for convenience in API calls
+ */
+export interface EditSession extends Pick<AppEdit, "id"> {
+    auth: AuthType;
+    packageName: string;
+    editId: string;
+}
+/**
+ * Screenshot URLs grouped by device type
+ * Internal type for organizing screenshots by device category
+ */
+export interface ScreenshotUrls {
+    phone: string[];
+    tablet7: string[];
+    tablet10: string[];
+    tv: string[];
+    wear: string[];
+}
+/**
+ * App Access Information
+ * Internal type for app verification results
+ */
+export interface AppAccessInfo {
+    packageName: string;
+    title?: string;
+    defaultLanguage?: string;
+    supportedLocales?: string[];
+}
+/**
+ * Latest Release Information
+ * Internal type derived from TrackRelease for convenience
+ * Extracts and transforms TrackRelease data for easier consumption
+ */
+export interface LatestReleaseInfo {
+    versionCodes: number[];
+    status?: NonNullable<TrackRelease["status"]>;
+    versionName?: string;
+    releaseName?: NonNullable<TrackRelease["name"]>;
+    releaseDate?: string;
+}
+/**
+ * Release Update Result
+ * Internal type for tracking release note update operations
+ */
+export interface ReleaseUpdateResult {
+    updated: string[];
+    failed: Array<{
+        locale: string;
+        error: string;
+    }>;
+}
+/**
+ * Create Release Options
+ * Internal type for creating a new release
+ * Based on TrackRelease but with simplified versionCodes (number[])
+ */
+export interface CreateReleaseOptions {
+    versionCodes: number[];
+    releaseName?: NonNullable<TrackRelease["name"]>;
+    status?: NonNullable<TrackRelease["status"]>;
+}
+/**
+ * Upload Screenshot Options
+ * Internal type for screenshot upload operations
+ */
+export interface UploadScreenshotOptions {
+    imagePath: string;
+    imageType: "phoneScreenshots" | "sevenInchScreenshots" | "tenInchScreenshots" | "tvScreenshots" | "wearScreenshots" | "featureGraphic";
+    language?: string;
+}
+/**
+ * Update Release Notes Options
+ * Internal type for updating release notes
+ */
+export interface UpdateReleaseNotesOptions {
+    releaseNotes: Record<string, string>;
+    track?: string;
+}
+/**
+ * App Details Data
+ * Internal type for app details update operations
+ * Based on AppDetails but with optional fields for partial updates
+ */
+export interface AppDetailsData {
+    contactEmail?: NonNullable<AppDetails["contactEmail"]>;
+    contactPhone?: NonNullable<AppDetails["contactPhone"]>;
+    contactWebsite?: NonNullable<AppDetails["contactWebsite"]>;
+    defaultLanguage?: NonNullable<AppDetails["defaultLanguage"]>;
+}
+export type ImageType = "appImageTypeUnspecified" | "phoneScreenshots" | "sevenInchScreenshots" | "tenInchScreenshots" | "tvScreenshots" | "wearScreenshots" | "icon" | "featureGraphic" | "tvBanner";
+/**
+ * Listing Update Request Attributes
+ * @see https://developers.google.com/android-publisher/api-ref/rest/v3/edits.listings#Listing
+ */
+export type ListingUpdateAttributes = Partial<Pick<androidpublisher_v3.Schema$Listing, "language" | "title" | "shortDescription" | "fullDescription" | "video">>;
+/**
+ * App Details Update Request Attributes
+ * @see https://developers.google.com/android-publisher/api-ref/rest/v3/edits.details#AppDetails
+ */
+export type AppDetailsUpdateAttributes = Partial<Pick<androidpublisher_v3.Schema$AppDetails, "defaultLanguage" | "contactEmail" | "contactPhone" | "contactWebsite">>;
+/**
+ * Track Update Request Attributes
+ * @see https://developers.google.com/android-publisher/api-ref/rest/v3/edits.tracks#Track
+ */
+export type TrackUpdateAttributes = Partial<Pick<androidpublisher_v3.Schema$Track, "track" | "releases">>;
+export {};

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

@@ -0,0 +1,9 @@
+/**
+ * Google Play Console API Types
+ *
+ * Type definitions for Google Play Store operations.
+ * Types are derived from googleapis library types.
+ *
+ * @see https://developers.google.com/android-publisher
+ */
+export {};

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

@@ -0,0 +1,13 @@
+export interface VerifyPlayStoreAuthResult {
+    success: boolean;
+    error?: string;
+    data?: {
+        client_email: string;
+        project_id: string;
+    };
+}
+/**
+ * Verify Google Play Store service account authentication configuration.
+ * @returns Authentication verification result
+ */
+export declare function verifyPlayStoreAuth(): VerifyPlayStoreAuthResult;

package/dist/src/packages/stores/play-store/verify-auth.js

@@ -0,0 +1,31 @@
+import { loadConfig } from "../../../packages/configs/secrets-config/config.js";
+/**
+ * Verify Google Play Store service account authentication configuration.
+ * @returns Authentication verification result
+ */
+export function verifyPlayStoreAuth() {
+    try {
+        const cfg = loadConfig().playStore;
+        if (!cfg) {
+            return {
+                success: false,
+                error: "Play Store configuration not found in ~/.config/pabal-mcp/config.json file.",
+            };
+        }
+        const parsed = JSON.parse(cfg.serviceAccountJson);
+        return {
+            success: true,
+            data: {
+                client_email: parsed.client_email,
+                project_id: parsed.project_id,
+            },
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            success: false,
+            error: `Play Store authentication verification failed: ${message}`,
+        };
+    }
+}

package/dist/src/tools/apps/add.d.ts

@@ -0,0 +1,28 @@
+/**
+ * add-app: Register app by bundleId or packageName
+ */
+import { type RegisteredApp } from "../../packages/configs/secrets-config/registered-apps.js";
+interface AddAppOptions {
+    /** App identifier (bundleId or packageName) */
+    identifier: string;
+    /** Custom slug (if not specified, uses last part of identifier) */
+    slug?: string;
+    /** Target store (default: both - check both stores) */
+    store?: "appStore" | "googlePlay" | "both";
+}
+export declare function handleAddApp(options: AddAppOptions): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    _meta?: undefined;
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    _meta: {
+        app: RegisteredApp;
+    };
+}>;
+export {};

package/dist/src/tools/apps/add.js

@@ -0,0 +1,307 @@
+/**
+ * add-app: Register app by bundleId or packageName
+ */
+import { registerApp, findApp, loadRegisteredApps, saveRegisteredApps, } from "../../packages/configs/secrets-config/registered-apps.js";
+import { toRegisteredAppStoreInfo, toRegisteredGooglePlayInfo, } from "../../core/helpers/registration.js";
+import { AppStoreService } from "../../core/services/app-store-service.js";
+import { GooglePlayService } from "../../core/services/google-play-service.js";
+const appStoreService = new AppStoreService();
+const googlePlayService = new GooglePlayService();
+/**
+ * Generate slug (last part of identifier)
+ */
+function generateSlug(identifier) {
+    const parts = identifier.split(".");
+    return parts[parts.length - 1].toLowerCase();
+}
+export async function handleAddApp(options) {
+    const { identifier, slug: customSlug, store = "both" } = options;
+    console.error(`[MCP] 📱 Adding app: ${identifier} (store: ${store})`);
+    if (!identifier) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `❌ identifier is required.
+
+Usage:
+\`\`\`json
+{ "identifier": "com.example.app" }
+{ "identifier": "com.example.app", "slug": "myapp" }
+{ "identifier": "com.example.app", "store": "googlePlay" }
+\`\`\``,
+                },
+            ],
+        };
+    }
+    // Check if already registered
+    let existing;
+    try {
+        existing = findApp(identifier);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `❌ Failed to load registered apps: ${message}`,
+                },
+            ],
+        };
+    }
+    if (existing) {
+        // Update language info for existing apps
+        let appsConfig;
+        try {
+            appsConfig = loadRegisteredApps();
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `❌ Failed to load registered apps: ${message}`,
+                    },
+                ],
+            };
+        }
+        const appIndex = appsConfig.apps.findIndex((a) => a.slug === existing.slug);
+        if (appIndex >= 0) {
+            let updated = false;
+            const updateResults = [];
+            // Update App Store language info
+            if (store === "both" || store === "appStore") {
+                if (existing.appStore) {
+                    const asResult = await appStoreService.fetchAppInfo(identifier);
+                    if (asResult.found && asResult.supportedLocales) {
+                        if (!appsConfig.apps[appIndex].appStore) {
+                            appsConfig.apps[appIndex].appStore = {
+                                bundleId: identifier,
+                                appId: asResult.appId,
+                                name: asResult.name,
+                            };
+                        }
+                        appsConfig.apps[appIndex].appStore.supportedLocales =
+                            asResult.supportedLocales;
+                        updated = true;
+                        updateResults.push(`🍎 App Store: Updated locales (${asResult.supportedLocales.length})`);
+                    }
+                }
+            }
+            // Update Google Play language info
+            if (store === "both" || store === "googlePlay") {
+                if (existing.googlePlay || store === "googlePlay") {
+                    const gpResult = await googlePlayService.fetchAppInfo(identifier);
+                    if (gpResult.found && gpResult.supportedLocales) {
+                        if (!appsConfig.apps[appIndex].googlePlay) {
+                            appsConfig.apps[appIndex].googlePlay = {
+                                packageName: identifier,
+                                name: gpResult.name,
+                            };
+                        }
+                        appsConfig.apps[appIndex].googlePlay.supportedLocales =
+                            gpResult.supportedLocales;
+                        if (gpResult.name) {
+                            appsConfig.apps[appIndex].googlePlay.name = gpResult.name;
+                        }
+                        updated = true;
+                        updateResults.push(`🤖 Google Play: Updated locales (${gpResult.supportedLocales.length})`);
+                    }
+                }
+            }
+            if (updated) {
+                saveRegisteredApps(appsConfig);
+                const updatedApp = appsConfig.apps[appIndex];
+                const localeInfo = [];
+                if (updatedApp.appStore?.supportedLocales &&
+                    updatedApp.appStore.supportedLocales.length > 0) {
+                    localeInfo.push(`• App Store locales: ${updatedApp.appStore.supportedLocales.join(", ")}`);
+                }
+                if (updatedApp.googlePlay?.supportedLocales &&
+                    updatedApp.googlePlay.supportedLocales.length > 0) {
+                    localeInfo.push(`• Google Play locales: ${updatedApp.googlePlay.supportedLocales.join(", ")}`);
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `✅ App language info updated
+
+• Slug: \`${updatedApp.slug}\`
+• Name: ${updatedApp.name}
+• App Store: ${updatedApp.appStore ? `✅ ${updatedApp.appStore.bundleId}` : "❌"}
+• Google Play: ${updatedApp.googlePlay ? `✅ ${updatedApp.googlePlay.packageName}` : "❌"}
+${updateResults.length > 0 ? `\n**Updates:**\n${updateResults.map((r) => `  • ${r}`).join("\n")}` : ""}
+${localeInfo.length > 0 ? `\n**Supported Languages:**\n${localeInfo.map((l) => `  ${l}`).join("\n")}` : ""}`,
+                        },
+                    ],
+                    _meta: { app: updatedApp },
+                };
+            }
+        }
+        // If no updates were made, return existing info
+        const localeInfo = [];
+        if (existing.appStore?.supportedLocales &&
+            existing.appStore.supportedLocales.length > 0) {
+            localeInfo.push(`• App Store locales: ${existing.appStore.supportedLocales.join(", ")}`);
+        }
+        if (existing.googlePlay?.supportedLocales &&
+            existing.googlePlay.supportedLocales.length > 0) {
+            localeInfo.push(`• Google Play locales: ${existing.googlePlay.supportedLocales.join(", ")}`);
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `⏭️ App is already registered.
+
+• Slug: \`${existing.slug}\`
+• Name: ${existing.name}
+• App Store: ${existing.appStore ? `✅ ${existing.appStore.bundleId}` : "❌"}
+• Google Play: ${existing.googlePlay ? `✅ ${existing.googlePlay.packageName}` : "❌"}
+${localeInfo.length > 0 ? `\n**Supported Languages:**\n${localeInfo.map((l) => `  ${l}`).join("\n")}` : ""}`,
+                },
+            ],
+            _meta: { app: existing },
+        };
+    }
+    const slug = customSlug || generateSlug(identifier);
+    // Check for slug duplicates
+    const slugExists = findApp(slug);
+    if (slugExists) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `❌ slug "${slug}" is already in use. Please specify a different slug.
+
+\`\`\`json
+{ "identifier": "${identifier}", "slug": "different-slug" }
+\`\`\``,
+                },
+            ],
+        };
+    }
+    // Fetch app information by store (언어 정보 포함)
+    let appStoreInfo = undefined;
+    let googlePlayInfo = undefined;
+    let appName = identifier;
+    const results = [];
+    // Check App Store
+    if (store === "both" || store === "appStore") {
+        console.error(`[MCP]   🔍 Searching App Store for: ${identifier}`);
+        const asResult = await appStoreService.fetchAppInfo(identifier);
+        if (asResult.found) {
+            appStoreInfo = toRegisteredAppStoreInfo({
+                bundleId: identifier,
+                appInfo: asResult,
+            });
+            appName = asResult.name || appName;
+            const localeInfo = asResult.supportedLocales && asResult.supportedLocales.length > 0
+                ? ` (${asResult.supportedLocales.length} locales)`
+                : "";
+            results.push(`🍎 App Store: ✅ Found (${asResult.name})${localeInfo}`);
+        }
+        else {
+            results.push(`🍎 App Store: ❌ Not found`);
+        }
+    }
+    // Check Google Play
+    if (store === "both" || store === "googlePlay") {
+        console.error(`[MCP]   🔍 Searching Google Play for: ${identifier}`);
+        const gpResult = await googlePlayService.fetchAppInfo(identifier);
+        if (gpResult.found) {
+            googlePlayInfo = toRegisteredGooglePlayInfo({
+                packageName: identifier,
+                appInfo: gpResult,
+            });
+            appName = gpResult.name || appName;
+            const localeInfo = gpResult.supportedLocales && gpResult.supportedLocales.length > 0
+                ? ` (${gpResult.supportedLocales.length} locales)`
+                : "";
+            results.push(`🤖 Google Play: ✅ Found (${gpResult.name})${localeInfo}`);
+        }
+        else {
+            results.push(`🤖 Google Play: ❌ Not found`);
+        }
+    }
+    // Must be found in at least one store
+    if (!appStoreInfo && !googlePlayInfo) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `❌ App not found.
+
+**Search Results:**
+${results.map((r) => `  • ${r}`).join("\n")}
+
+**Things to Check:**
+• Verify identifier is correct: \`${identifier}\`
+• Verify app is registered in the store
+• Verify authentication settings are correct (use auth-check tool)`,
+                },
+            ],
+        };
+    }
+    // Register app
+    try {
+        console.error(`[MCP]   💾 Registering app with slug: ${slug}`);
+        const newApp = registerApp({
+            slug,
+            name: appName,
+            appStore: appStoreInfo,
+            googlePlay: googlePlayInfo,
+        });
+        console.error(`[MCP]   ✅ App registered successfully`);
+        const storeIcons = [
+            appStoreInfo ? "🍎" : null,
+            googlePlayInfo ? "🤖" : null,
+        ]
+            .filter(Boolean)
+            .join("+");
+        const localeInfo = [];
+        if (appStoreInfo?.supportedLocales &&
+            appStoreInfo.supportedLocales.length > 0) {
+            localeInfo.push(`• App Store locales: ${appStoreInfo.supportedLocales.join(", ")}`);
+        }
+        if (googlePlayInfo?.supportedLocales &&
+            googlePlayInfo.supportedLocales.length > 0) {
+            localeInfo.push(`• Google Play locales: ${googlePlayInfo.supportedLocales.join(", ")}`);
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `✅ App registration complete (${storeIcons})
+
+**Registration Info:**
+• Slug: \`${newApp.slug}\`
+• Name: ${newApp.name}
+${appStoreInfo ? `• App Store: ${appStoreInfo.bundleId} (ID: ${appStoreInfo.appId})` : ""}
+${googlePlayInfo ? `• Google Play: ${googlePlayInfo.packageName}` : ""}
+${localeInfo.length > 0 ? `\n**Supported Languages:**\n${localeInfo.map((l) => `  ${l}`).join("\n")}` : ""}
+
+**Search Results:**
+${results.map((r) => `  • ${r}`).join("\n")}
+
+You can now reference this app in other tools using the \`app: "${slug}"\` parameter.`,
+                },
+            ],
+            _meta: { app: newApp },
+        };
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `❌ App registration failed: ${msg}`,
+                },
+            ],
+        };
+    }
+}

package/dist/src/tools/apps/init.d.ts

@@ -0,0 +1,58 @@
+/**
+ * setup-apps: Query apps from store and auto-register
+ */
+import { type RegisteredApp } from "../../packages/configs/secrets-config/registered-apps.js";
+interface SetupAppsOptions {
+    store?: "appStore" | "googlePlay" | "both";
+    packageName?: string;
+}
+export declare function handleSetupApps(options: SetupAppsOptions): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: boolean;
+    _meta?: undefined;
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError?: undefined;
+    _meta?: undefined;
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    _meta: {
+        registered: number;
+        skipped: number;
+        playStoreFound: number;
+        playStoreNotFound: number;
+        apps: {
+            id: string;
+            name: string;
+            bundleId: string;
+            sku: string;
+            isReleased: boolean;
+        }[];
+        app?: undefined;
+    };
+    isError?: undefined;
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    _meta: {
+        app: RegisteredApp;
+        registered?: undefined;
+        skipped?: undefined;
+        playStoreFound?: undefined;
+        playStoreNotFound?: undefined;
+        apps?: undefined;
+    };
+    isError?: undefined;
+}>;
+export {};