pabal-store-api-mcp 1.1.0

package/dist/src/tools/release/check-versions.js

@@ -0,0 +1,65 @@
+import { getStoreTargets } from "../../packages/configs/aso-config/store.js";
+import { AppResolutionService } from "../../core/services/app-resolution-service.js";
+import { getLatestVersions } from "../../core/workflows/version-info.js";
+const appResolutionService = new AppResolutionService();
+export async function handleCheckLatestVersions(options) {
+    const { app, store } = options;
+    let { packageName, bundleId } = options;
+    const { store: selectedStore, includeAppStore, includeGooglePlay, } = getStoreTargets(store);
+    console.error(`[MCP] 🔍 Checking latest versions (store: ${selectedStore})`);
+    const resolved = appResolutionService.resolve({
+        slug: app,
+        packageName,
+        bundleId,
+    });
+    if (!resolved.success) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: resolved.error.message,
+                },
+            ],
+        };
+    }
+    const { slug, bundleId: resolvedBundleId, packageName: resolvedPackageName, hasAppStore, hasGooglePlay, } = resolved.data;
+    bundleId = resolvedBundleId;
+    packageName = resolvedPackageName;
+    // Check latest versions (without prompt message since this is a dedicated check tool)
+    console.error(`[MCP]   App: ${slug}`);
+    if (bundleId)
+        console.error(`[MCP]   App Store bundleId: ${bundleId}`);
+    if (packageName)
+        console.error(`[MCP]   Google Play packageName: ${packageName}`);
+    const skips = [];
+    if (includeAppStore && !hasAppStore) {
+        skips.push(`⏭️  Skipping App Store (not registered for App Store)`);
+    }
+    else if (includeAppStore && !bundleId) {
+        skips.push(`⏭️  Skipping App Store (no bundleId provided)`);
+    }
+    if (includeGooglePlay && !hasGooglePlay) {
+        skips.push(`⏭️  Skipping Google Play (not registered for Google Play)`);
+    }
+    else if (includeGooglePlay && !packageName) {
+        skips.push(`⏭️  Skipping Google Play (no packageName provided)`);
+    }
+    const versionInfo = await getLatestVersions({
+        bundleId,
+        includePrompt: false,
+        store: selectedStore,
+        packageName,
+        hasAppStore,
+        hasGooglePlay,
+    });
+    console.error(`[MCP]   ✅ Version check completed`);
+    const contentLines = [...skips, ...versionInfo.messages];
+    return {
+        content: [
+            {
+                type: "text",
+                text: contentLines.join("\n"),
+            },
+        ],
+    };
+}

package/dist/src/tools/release/create.d.ts

@@ -0,0 +1,23 @@
+import { type StoreType } from "../../packages/configs/aso-config/types.js";
+interface AsoCreateVersionOptions {
+    app?: string;
+    packageName?: string;
+    bundleId?: string;
+    version?: string;
+    store?: StoreType;
+    versionCodes?: number[];
+}
+export declare function handleAsoCreateVersion(options: AsoCreateVersionOptions): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError?: undefined;
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: boolean;
+}>;
+export {};

package/dist/src/tools/release/create.js

@@ -0,0 +1,128 @@
+import { loadConfig } from "../../packages/configs/secrets-config/config.js";
+import { AppResolutionService } from "../../core/services/app-resolution-service.js";
+import { AppStoreService } from "../../core/services/app-store-service.js";
+import { GooglePlayService } from "../../core/services/google-play-service.js";
+import { getLatestVersions } from "../../core/workflows/version-info.js";
+const appStoreService = new AppStoreService();
+const googlePlayService = new GooglePlayService();
+const appResolutionService = new AppResolutionService();
+export async function handleAsoCreateVersion(options) {
+    const { app, version, store = "both", versionCodes } = options;
+    let { packageName, bundleId } = options;
+    const resolved = appResolutionService.resolve({
+        slug: app,
+        packageName,
+        bundleId,
+    });
+    if (!resolved.success) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: resolved.error.message,
+                },
+            ],
+        };
+    }
+    const { slug, bundleId: resolvedBundleId, packageName: resolvedPackageName, hasAppStore, hasGooglePlay, } = resolved.data;
+    bundleId = resolvedBundleId;
+    packageName = resolvedPackageName;
+    let config;
+    try {
+        config = loadConfig();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `❌ Failed to load config: ${message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+    // If version is not provided, check latest versions and prompt user
+    if (!version) {
+        const versionInfo = await getLatestVersions({
+            store,
+            bundleId,
+            packageName,
+            hasAppStore,
+            hasGooglePlay,
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: versionInfo.messages.join("\n"),
+                },
+            ],
+        };
+    }
+    // Version is provided, proceed with creation
+    console.error(`[MCP] 📦 Creating version: ${version}`);
+    console.error(`[MCP]   Store: ${store}`);
+    console.error(`[MCP]   App: ${slug}`);
+    if (packageName)
+        console.error(`[MCP]   Package Name: ${packageName}`);
+    if (bundleId)
+        console.error(`[MCP]   Bundle ID: ${bundleId}`);
+    if (versionCodes) {
+        console.error(`[MCP]   Version Codes: ${versionCodes.join(", ")}`);
+    }
+    const results = [];
+    if (store === "appStore" || store === "both") {
+        if (!hasAppStore) {
+            results.push(`⏭️  Skipping App Store (not registered for App Store)`);
+        }
+        else if (!config.appStore) {
+            results.push(`⏭️  Skipping App Store (not configured in ~/.config/pabal-mcp/config.json)`);
+        }
+        else if (!bundleId) {
+            results.push(`⏭️  Skipping App Store (no bundleId provided)`);
+        }
+        else {
+            const createResult = await appStoreService.createVersion(bundleId, version);
+            if (!createResult.success) {
+                results.push(`❌ App Store version creation failed: ${createResult.error.message}`);
+            }
+            else {
+                const state = createResult.data.state?.toUpperCase() || "UNKNOWN";
+                results.push(`✅ App Store version ${createResult.data.versionString} created (${state})`);
+            }
+        }
+    }
+    if (store === "googlePlay" || store === "both") {
+        if (!hasGooglePlay) {
+            results.push(`⏭️  Skipping Google Play (not registered for Google Play)`);
+        }
+        else if (!config.playStore) {
+            results.push(`⏭️  Skipping Google Play (not configured in ~/.config/pabal-mcp/config.json)`);
+        }
+        else if (!packageName) {
+            results.push(`⏭️  Skipping Google Play (no packageName provided)`);
+        }
+        else if (!versionCodes || versionCodes.length === 0) {
+            results.push(`⏭️  Skipping Google Play (no version codes provided)`);
+        }
+        else {
+            const createResult = await googlePlayService.createVersion(packageName, version, versionCodes);
+            if (!createResult.success) {
+                results.push(`❌ Google Play version creation failed: ${createResult.error.message}`);
+            }
+            else {
+                results.push(`✅ Google Play production draft created with versionCodes: ${versionCodes.join(", ")}`);
+            }
+        }
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: `📦 Version Creation Results:\n${results.join("\n")}`,
+            },
+        ],
+    };
+}

package/dist/src/tools/release/pull-notes.d.ts

@@ -0,0 +1,22 @@
+import type { StoreType } from "../../packages/configs/aso-config/types.js";
+interface AsoPullReleaseNotesOptions {
+    app?: string;
+    packageName?: string;
+    bundleId?: string;
+    store?: StoreType;
+    dryRun?: boolean;
+}
+export declare function handleAsoPullReleaseNotes(options: AsoPullReleaseNotesOptions): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError?: undefined;
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: boolean;
+}>;
+export {};

package/dist/src/tools/release/pull-notes.js

@@ -0,0 +1,151 @@
+import { ensureDir, getAsoPullDir, getPullProductAsoDir, getStoreDir, getReleaseNotesPath, } from "../../packages/configs/aso-config/utils.js";
+import { getStoreTargets } from "../../packages/configs/aso-config/store.js";
+import { loadConfig } from "../../packages/configs/secrets-config/config.js";
+import { AppResolutionService } from "../../core/services/app-resolution-service.js";
+import { AppStoreService } from "../../core/services/app-store-service.js";
+import { GooglePlayService } from "../../core/services/google-play-service.js";
+import { writeFileSync } from "node:fs";
+const appStoreService = new AppStoreService();
+const googlePlayService = new GooglePlayService();
+const appResolutionService = new AppResolutionService();
+export async function handleAsoPullReleaseNotes(options) {
+    const { app, store, dryRun = false } = options;
+    let { packageName, bundleId } = options;
+    const { store: targetStore, includeAppStore, includeGooglePlay, } = getStoreTargets(store);
+    const resolved = appResolutionService.resolve({
+        slug: app,
+        packageName,
+        bundleId,
+    });
+    if (!resolved.success) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: resolved.error.message,
+                },
+            ],
+        };
+    }
+    const { slug, bundleId: resolvedBundleId, packageName: resolvedPackageName, hasAppStore, hasGooglePlay, } = resolved.data;
+    bundleId = resolvedBundleId;
+    packageName = resolvedPackageName;
+    console.error(`[MCP] 📥 Pulling release notes`);
+    console.error(`[MCP]   Store: ${targetStore}`);
+    console.error(`[MCP]   App: ${slug}`);
+    if (packageName)
+        console.error(`[MCP]   Package Name: ${packageName}`);
+    if (bundleId)
+        console.error(`[MCP]   Bundle ID: ${bundleId}`);
+    console.error(`[MCP]   Mode: ${dryRun ? "Dry run" : "Actual fetch"}`);
+    let config;
+    try {
+        config = loadConfig();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `❌ Failed to load config: ${message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+    const releaseNotes = {};
+    if (includeGooglePlay) {
+        if (!hasGooglePlay) {
+            console.error(`[MCP]   ⏭️  Skipping Google Play (not registered for Google Play)`);
+        }
+        else if (!config.playStore) {
+            console.error(`[MCP]   ⏭️  Skipping Google Play (not configured in ~/.config/pabal-mcp/config.json)`);
+        }
+        else if (!packageName) {
+            console.error(`[MCP]   ⏭️  Skipping Google Play (no packageName provided)`);
+        }
+        else {
+            const notesResult = await googlePlayService.pullReleaseNotes(packageName);
+            if (!notesResult.success) {
+                console.error(`[MCP]   ❌ Failed to fetch Google Play release notes: ${notesResult.error.message}`);
+            }
+            else {
+                releaseNotes.googlePlay = notesResult.data;
+                console.error(`[MCP]   📊 Google Play Release Notes:`);
+                console.error(`[MCP]     Total versions: ${notesResult.data.length}`);
+                for (const rn of notesResult.data) {
+                    const code = rn.versionCode ?? "N/A";
+                    console.error(`[MCP]     Version ${rn.versionName} (${code}): ${Object.keys(rn.releaseNotes).length} languages`);
+                }
+                console.error(`[MCP]   ✅ Google Play release notes fetched`);
+            }
+        }
+    }
+    if (includeAppStore) {
+        if (!hasAppStore) {
+            console.error(`[MCP]   ⏭️  Skipping App Store (not registered for App Store)`);
+        }
+        else if (!config.appStore) {
+            console.error(`[MCP]   ⏭️  Skipping App Store (not configured in ~/.config/pabal-mcp/config.json)`);
+        }
+        else if (!bundleId) {
+            console.error(`[MCP]   ⏭️  Skipping App Store (no bundleId provided)`);
+        }
+        else {
+            const notesResult = await appStoreService.pullReleaseNotes(bundleId);
+            if (!notesResult.success) {
+                console.error(`[MCP]   ❌ Failed to fetch App Store release notes: ${notesResult.error.message}`);
+            }
+            else {
+                releaseNotes.appStore = notesResult.data;
+                console.error(`[MCP]   📊 App Store Release Notes:`);
+                console.error(`[MCP]     Total versions: ${notesResult.data.length}`);
+                for (const rn of notesResult.data) {
+                    console.error(`[MCP]     Version ${rn.versionString}: ${Object.keys(rn.releaseNotes).length} locales`);
+                }
+                console.error(`[MCP]   ✅ App Store release notes fetched`);
+            }
+        }
+    }
+    if (dryRun) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `📋 Dry run - Release notes:\n${JSON.stringify(releaseNotes, null, 2)}`,
+                },
+            ],
+        };
+    }
+    // Save to ASO directory
+    const asoDir = getPullProductAsoDir(slug, getAsoPullDir());
+    if (releaseNotes.googlePlay) {
+        const googlePlayDir = getStoreDir(asoDir, "google-play");
+        ensureDir(googlePlayDir);
+        const filePath = getReleaseNotesPath(googlePlayDir);
+        writeFileSync(filePath, JSON.stringify(releaseNotes.googlePlay, null, 2));
+        console.error(`[MCP]   💾 Google Play release notes saved to ${filePath}`);
+    }
+    if (releaseNotes.appStore) {
+        const appStoreDir = getStoreDir(asoDir, "app-store");
+        ensureDir(appStoreDir);
+        const filePath = getReleaseNotesPath(appStoreDir);
+        writeFileSync(filePath, JSON.stringify(releaseNotes.appStore, null, 2));
+        console.error(`[MCP]   💾 App Store release notes saved to ${filePath}`);
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: `✅ Release notes pulled\n` +
+                    `   Google Play: ${releaseNotes.googlePlay
+                        ? `${releaseNotes.googlePlay.length} versions`
+                        : "✗"}\n` +
+                    `   App Store: ${releaseNotes.appStore
+                        ? `${releaseNotes.appStore.length} versions`
+                        : "✗"}`,
+            },
+        ],
+    };
+}

package/dist/src/tools/release/update-notes.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Release notes update tool
+ *
+ * Supports both App Store and Google Play.
+ * Automatically translates to all supported languages if text is provided.
+ */
+import { type StoreType } from "../../packages/configs/aso-config/types.js";
+interface UpdateNotesOptions {
+    app?: string;
+    bundleId?: string;
+    packageName?: string;
+    store?: StoreType;
+    versionId?: string;
+    whatsNew?: Record<string, string>;
+    text?: string;
+    sourceLocale?: string;
+}
+export declare function handleUpdateNotes(options: UpdateNotesOptions): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError?: undefined;
+    _meta?: undefined;
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: boolean;
+    _meta?: undefined;
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    _meta: {
+        translationPipeline: {
+            step: number;
+            detectedLocale: string;
+            sourceLocale: string;
+            providedText: string;
+            providedLocales: string[];
+            missingLocales: string[];
+            allSupportedLocales: string[];
+            appStoreLocales: string[];
+            googlePlayLocales: string[];
+            sourceText?: undefined;
+        };
+        registeredApp: import("../../packages/configs/secrets-config/registered-apps.js").RegisteredApp;
+        slug: string;
+        store: StoreType;
+        versionId: string | undefined;
+        translationRequests?: undefined;
+    };
+    isError?: undefined;
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    _meta: {
+        translationPipeline: {
+            step: number;
+            sourceLocale: string;
+            sourceText: string;
+            providedLocales: string[];
+            missingLocales: string[];
+            allSupportedLocales: string[];
+            appStoreLocales: string[];
+            googlePlayLocales: string[];
+            detectedLocale?: undefined;
+            providedText?: undefined;
+        };
+        registeredApp: import("../../packages/configs/secrets-config/registered-apps.js").RegisteredApp;
+        slug: string;
+        store: StoreType;
+        versionId: string | undefined;
+        translationRequests?: undefined;
+    };
+    isError?: undefined;
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    _meta: {
+        translationRequests: {
+            appStore: {
+                sourceText: string;
+                sourceLocale: string;
+                targetLocales: string[];
+                store: "appStore";
+            } | undefined;
+            googlePlay: {
+                sourceText: string;
+                sourceLocale: string;
+                targetLocales: string[];
+                store: "googlePlay";
+            } | undefined;
+        };
+        registeredApp: import("../../packages/configs/secrets-config/registered-apps.js").RegisteredApp;
+        slug: string;
+        store: StoreType;
+        versionId: string | undefined;
+        translationPipeline?: undefined;
+    };
+    isError?: undefined;
+}>;
+export {};