pabal-store-api-mcp 1.1.0

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

@@ -0,0 +1,266 @@
+import { AppError } from "../../packages/common/errors/app-error.js";
+import { ERROR_CODES } from "../../packages/common/errors/error-codes.js";
+import { HTTP_STATUS } from "../../packages/common/errors/status-codes.js";
+import { verifyAppStoreAuth } from "../../packages/stores/app-store/verify-auth.js";
+import { createAppStoreClient } from "../../core/clients/app-store-factory.js";
+import { checkPushPrerequisites, serviceFailure, toServiceResult, updateRegisteredLocales, } from "./service-helpers.js";
+/**
+ * App Store-facing service layer that wraps client creation and common operations.
+ * Keeps MCP tools independent from client factories and SDK details.
+ */
+export class AppStoreService {
+    getClientOrThrow(bundleId, existingClient) {
+        if (existingClient)
+            return existingClient;
+        const clientResult = this.createClient(bundleId);
+        if (!clientResult.success) {
+            throw clientResult.error;
+        }
+        return clientResult.data;
+    }
+    createClient(bundleId) {
+        return toServiceResult(createAppStoreClient({ bundleId }));
+    }
+    /**
+     * List released apps. Uses a fresh client to ensure working directory independence.
+     */
+    async listReleasedApps() {
+        try {
+            const client = this.getClientOrThrow("dummy");
+            const apps = await client.listAllApps({ onlyReleased: true });
+            return { success: true, data: apps };
+        }
+        catch (error) {
+            return serviceFailure(AppError.wrap(error, HTTP_STATUS.INTERNAL_SERVER_ERROR, ERROR_CODES.APP_STORE_LIST_APPS_FAILED));
+        }
+    }
+    /**
+     * Fetch a single app info (with locales) by bundleId.
+     */
+    async fetchAppInfo(bundleId, existingClient) {
+        try {
+            const client = this.getClientOrThrow(bundleId || "dummy", existingClient);
+            const apps = await client.listAllApps({ onlyReleased: true });
+            const app = apps.find((a) => a.bundleId === bundleId);
+            if (!app) {
+                return { found: false };
+            }
+            const supportedLocales = await client.getSupportedLocales(app.id);
+            return {
+                found: true,
+                appId: app.id,
+                name: app.name,
+                supportedLocales,
+            };
+        }
+        catch (error) {
+            return {
+                found: false,
+                error: AppError.wrap(error, HTTP_STATUS.INTERNAL_SERVER_ERROR, ERROR_CODES.APP_STORE_FETCH_APP_INFO_FAILED, "Failed to fetch App Store app info"),
+            };
+        }
+    }
+    async getLatestVersion(bundleId, existingClient) {
+        try {
+            const client = this.getClientOrThrow(bundleId, existingClient);
+            const latestVersion = await client.getLatestVersion();
+            if (!latestVersion) {
+                return { found: false };
+            }
+            const versionString = latestVersion.attributes?.versionString ?? "";
+            const appStoreState = latestVersion.attributes?.appStoreState;
+            return {
+                found: true,
+                versionString,
+                state: appStoreState ?? "UNKNOWN",
+            };
+        }
+        catch (error) {
+            return {
+                found: false,
+                error: AppError.wrap(error, HTTP_STATUS.INTERNAL_SERVER_ERROR, ERROR_CODES.APP_STORE_GET_LATEST_VERSION_FAILED, "Failed to fetch latest App Store version"),
+            };
+        }
+    }
+    async updateReleaseNotes(bundleId, releaseNotes, versionId, supportedLocales) {
+        try {
+            const client = this.getClientOrThrow(bundleId);
+            // Determine target versionId
+            let targetVersionId = versionId;
+            if (!targetVersionId) {
+                const versions = await client.getAllVersions();
+                const editableVersion = versions.find((v) => v.attributes?.appStoreState === "PREPARE_FOR_SUBMISSION");
+                if (!editableVersion) {
+                    return serviceFailure(AppError.notFound(ERROR_CODES.APP_STORE_VERSION_NOT_EDITABLE, "No editable version found for release notes update"));
+                }
+                targetVersionId = editableVersion.id;
+            }
+            // Filter locales if supportedLocales provided
+            const localesToUpdate = supportedLocales
+                ? Object.keys(releaseNotes).filter((locale) => supportedLocales.includes(locale))
+                : Object.keys(releaseNotes);
+            const updated = [];
+            const failed = [];
+            for (const locale of localesToUpdate) {
+                try {
+                    await client.updateWhatsNew({
+                        versionId: targetVersionId,
+                        locale,
+                        whatsNew: releaseNotes[locale],
+                    });
+                    updated.push(locale);
+                }
+                catch (error) {
+                    const msg = error instanceof Error ? error.message : String(error);
+                    failed.push({ locale, error: msg });
+                }
+            }
+            const success = failed.length === 0;
+            const partialError = !success
+                ? AppError.wrap(failed[0]?.error ?? "Failed to update some release notes", HTTP_STATUS.INTERNAL_SERVER_ERROR, ERROR_CODES.APP_STORE_UPDATE_RELEASE_NOTES_PARTIAL)
+                : undefined;
+            if (!success) {
+                return serviceFailure(partialError ??
+                    AppError.internal(ERROR_CODES.APP_STORE_UPDATE_RELEASE_NOTES_FAILED, "Failed to update App Store release notes"));
+            }
+            return {
+                success: true,
+                data: { updated, failed },
+            };
+        }
+        catch (error) {
+            return serviceFailure(AppError.wrap(error, HTTP_STATUS.INTERNAL_SERVER_ERROR, ERROR_CODES.APP_STORE_UPDATE_RELEASE_NOTES_FAILED, "Failed to update App Store release notes"));
+        }
+    }
+    async pullReleaseNotes(bundleId) {
+        try {
+            const client = this.getClientOrThrow(bundleId);
+            const releaseNotes = await client.pullReleaseNotes();
+            return { success: true, data: releaseNotes };
+        }
+        catch (error) {
+            return serviceFailure(AppError.wrap(error, HTTP_STATUS.INTERNAL_SERVER_ERROR, ERROR_CODES.APP_STORE_PULL_RELEASE_NOTES_FAILED, "Failed to pull App Store release notes"));
+        }
+    }
+    async createVersion(bundleId, versionString, autoIncrement) {
+        try {
+            const client = this.getClientOrThrow(bundleId);
+            const version = autoIncrement
+                ? await client.createNewVersionWithAutoIncrement(versionString)
+                : await client.createNewVersion(versionString);
+            return {
+                success: true,
+                data: {
+                    id: version.id,
+                    versionString: version.attributes?.versionString ?? "",
+                    state: version.attributes?.appStoreState,
+                },
+            };
+        }
+        catch (error) {
+            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, }) {
+        const skip = checkPushPrerequisites({
+            storeLabel: "App Store",
+            configured: Boolean(config.appStore),
+            identifierLabel: "bundleId",
+            identifier: bundleId,
+            hasData: Boolean(localAsoData.appStore),
+            dataPath: appStoreDataPath,
+        });
+        if (skip)
+            return { success: false, error: skip };
+        const ensuredBundleId = bundleId;
+        const appStoreData = localAsoData.appStore;
+        const client = this.getClientOrThrow(ensuredBundleId);
+        console.error(`[MCP]   📤 Pushing to App Store...`);
+        console.error(`[MCP]     Bundle ID: ${bundleId}`);
+        try {
+            const localesToPush = Object.keys(appStoreData.locales);
+            const failedFieldsList = [];
+            for (const [locale, localeData] of Object.entries(appStoreData.locales)) {
+                console.error(`[AppStore]   📤 Pushing ${locale}...`);
+                const localeResult = await client.pushAsoData(localeData);
+                if (localeResult.failedFields && localeResult.failedFields.length > 0) {
+                    failedFieldsList.push({
+                        locale,
+                        fields: localeResult.failedFields,
+                    });
+                    console.error(`[AppStore]   ⚠️  ${locale} partially updated (failed fields: ${localeResult.failedFields.join(", ")})`);
+                }
+                else {
+                    console.error(`[AppStore]   ✅ ${locale} uploaded successfully`);
+                }
+            }
+            try {
+                const updated = updateRegisteredLocales(ensuredBundleId, "appStore", localesToPush);
+                if (updated) {
+                    console.error(`[MCP]   ✅ Updated registered-apps.json with ${localesToPush.length} App Store locales`);
+                }
+            }
+            catch (updateError) {
+                console.error(`[MCP]   ⚠️ Failed to update registered-apps.json: ${updateError instanceof Error
+                    ? updateError.message
+                    : String(updateError)}`);
+            }
+            if (failedFieldsList.length > 0) {
+                return {
+                    success: true,
+                    localesPushed: localesToPush,
+                    failedFields: failedFieldsList,
+                };
+            }
+            return {
+                success: true,
+                localesPushed: localesToPush,
+            };
+        }
+        catch (error) {
+            const wrapped = AppError.wrap(error, HTTP_STATUS.INTERNAL_SERVER_ERROR, ERROR_CODES.APP_STORE_PUSH_FAILED, error instanceof Error ? error.message : String(error));
+            if (wrapped.message.includes("409 Conflict") &&
+                wrapped.message.includes("STATE_ERROR")) {
+                console.error(`[AppStore]   🔄 STATE_ERROR detected. New version needed.`);
+                try {
+                    const version = await client.createNewVersionWithAutoIncrement();
+                    const versionId = version.id;
+                    const versionString = version.attributes?.versionString ?? "";
+                    const locales = Object.keys(appStoreData.locales);
+                    console.error(`[AppStore]   ✅ New version ${versionString} created.`);
+                    return {
+                        success: false,
+                        error: AppError.conflict(ERROR_CODES.APP_STORE_STATE_ERROR, "New version required"),
+                        needsNewVersion: true,
+                        versionInfo: {
+                            versionId,
+                            versionString,
+                            locales,
+                        },
+                    };
+                }
+                catch (versionError) {
+                    const versionMsg = versionError instanceof Error
+                        ? versionError.message
+                        : String(versionError);
+                    return {
+                        success: false,
+                        error: AppError.wrap(versionError, HTTP_STATUS.INTERNAL_SERVER_ERROR, ERROR_CODES.APP_STORE_CREATE_VERSION_FOR_STATE_ERROR_FAILED, `Failed to create new version: ${versionMsg}`),
+                    };
+                }
+            }
+            console.error(`[AppStore]   ❌ Push failed`, error);
+            return { success: false, error: wrapped };
+        }
+    }
+    async verifyAuth(expirationSeconds = 300) {
+        const result = await verifyAppStoreAuth({ expirationSeconds });
+        if (!result.success) {
+            return {
+                success: false,
+                error: AppError.wrap(result.error ?? "Unknown error", HTTP_STATUS.INTERNAL_SERVER_ERROR, ERROR_CODES.APP_STORE_VERIFY_AUTH_FAILED, "Failed to verify App Store auth"),
+            };
+        }
+        return { success: true, data: result.data };
+    }
+}

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

@@ -0,0 +1,36 @@
+import type { GooglePlayReleaseNote } from "../../packages/configs/aso-config/types.js";
+import type { PreparedAsoData } from "../../packages/configs/aso-config/utils.js";
+import type { EnvConfig } from "../../packages/configs/secrets-config/types.js";
+import type { GooglePlayClient } from "../../packages/stores/play-store/client.js";
+import { type MaybeResult, type ServiceResult, type GooglePlayReleaseInfo, type UpdatedReleaseNotesResult, type PushAsoResult, type CreatedGooglePlayVersion, type VerifyAuthResult } from "./types.js";
+interface GooglePlayAppInfo {
+    name?: string;
+    supportedLocales?: string[];
+}
+/**
+ * Google Play-facing service layer that wraps client creation and common operations.
+ * Keeps MCP tools independent from client factories and SDK details.
+ */
+export declare class GooglePlayService {
+    private getClientOrThrow;
+    createClient(packageName: string): ServiceResult<GooglePlayClient>;
+    /**
+     * Fetch a single app info (with locales) by packageName.
+     */
+    fetchAppInfo(packageName: string): Promise<MaybeResult<GooglePlayAppInfo>>;
+    getLatestProductionRelease(packageName: string): Promise<MaybeResult<GooglePlayReleaseInfo>>;
+    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, }: {
+        config: EnvConfig;
+        packageName?: string;
+        localAsoData: PreparedAsoData;
+        googlePlayDataPath: string;
+    }): Promise<PushAsoResult>;
+    verifyAuth(): Promise<VerifyAuthResult<{
+        client_email: string;
+        project_id: string;
+    }>>;
+}
+export {};

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

@@ -0,0 +1,203 @@
+import { AppError } from "../../packages/common/errors/app-error.js";
+import { ERROR_CODES } from "../../packages/common/errors/error-codes.js";
+import { HTTP_STATUS } from "../../packages/common/errors/status-codes.js";
+import { verifyPlayStoreAuth } from "../../packages/stores/play-store/verify-auth.js";
+import { createGooglePlayClient } from "../../core/clients/google-play-factory.js";
+import { checkPushPrerequisites, serviceFailure, toServiceResult, updateRegisteredLocales, } from "./service-helpers.js";
+/**
+ * Google Play-facing service layer that wraps client creation and common operations.
+ * Keeps MCP tools independent from client factories and SDK details.
+ */
+export class GooglePlayService {
+    getClientOrThrow(packageName, existingClient) {
+        if (existingClient)
+            return existingClient;
+        const clientResult = this.createClient(packageName);
+        if (!clientResult.success) {
+            throw clientResult.error;
+        }
+        return clientResult.data;
+    }
+    createClient(packageName) {
+        return toServiceResult(createGooglePlayClient({ packageName }));
+    }
+    /**
+     * Fetch a single app info (with locales) by packageName.
+     */
+    async fetchAppInfo(packageName) {
+        try {
+            const client = this.getClientOrThrow(packageName);
+            const appInfo = await client.verifyAppAccess();
+            return {
+                found: true,
+                name: appInfo.title,
+                supportedLocales: appInfo.supportedLocales,
+            };
+        }
+        catch (error) {
+            return {
+                found: false,
+                error: AppError.wrap(error, HTTP_STATUS.INTERNAL_SERVER_ERROR, ERROR_CODES.GOOGLE_PLAY_FETCH_APP_INFO_FAILED, "Failed to fetch Google Play app info"),
+            };
+        }
+    }
+    async getLatestProductionRelease(packageName) {
+        try {
+            const client = this.getClientOrThrow(packageName);
+            const latestRelease = await client.getLatestProductionRelease();
+            if (!latestRelease) {
+                return { found: false };
+            }
+            const { versionName, releaseName, status, versionCodes } = latestRelease;
+            return {
+                found: true,
+                versionName,
+                releaseName,
+                status,
+                versionCodes,
+            };
+        }
+        catch (error) {
+            return {
+                found: false,
+                error: AppError.wrap(error, HTTP_STATUS.INTERNAL_SERVER_ERROR, ERROR_CODES.GOOGLE_PLAY_GET_LATEST_RELEASE_FAILED, "Failed to fetch latest Google Play release"),
+            };
+        }
+    }
+    async updateReleaseNotes(packageName, releaseNotes, track, supportedLocales) {
+        try {
+            const client = this.getClientOrThrow(packageName);
+            const filteredReleaseNotes = {};
+            if (supportedLocales) {
+                for (const locale of supportedLocales) {
+                    if (releaseNotes[locale]) {
+                        filteredReleaseNotes[locale] = releaseNotes[locale];
+                    }
+                }
+            }
+            else {
+                Object.assign(filteredReleaseNotes, releaseNotes);
+            }
+            if (Object.keys(filteredReleaseNotes).length === 0) {
+                return serviceFailure(AppError.validation(ERROR_CODES.GOOGLE_PLAY_RELEASE_NOTES_EMPTY, "No supported locales found in release notes"));
+            }
+            try {
+                const updateResult = await client.updateReleaseNotes({
+                    releaseNotes: filteredReleaseNotes,
+                    track: track ?? "production",
+                });
+                const success = updateResult.failed.length === 0;
+                const partialError = !success
+                    ? AppError.wrap(updateResult.failed[0]?.error ??
+                        "Failed to update some release notes", HTTP_STATUS.INTERNAL_SERVER_ERROR, ERROR_CODES.GOOGLE_PLAY_UPDATE_RELEASE_NOTES_PARTIAL)
+                    : undefined;
+                if (!success) {
+                    return {
+                        success: false,
+                        error: partialError ??
+                            AppError.internal(ERROR_CODES.GOOGLE_PLAY_UPDATE_RELEASE_NOTES_FAILED, "Failed to update Google Play release notes"),
+                    };
+                }
+                return {
+                    success: true,
+                    data: {
+                        updated: updateResult.updated,
+                        failed: updateResult.failed,
+                    },
+                };
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                return serviceFailure(AppError.wrap(error, HTTP_STATUS.INTERNAL_SERVER_ERROR, ERROR_CODES.GOOGLE_PLAY_UPDATE_RELEASE_NOTES_FAILED, msg));
+            }
+        }
+        catch (error) {
+            return serviceFailure(AppError.wrap(error, HTTP_STATUS.INTERNAL_SERVER_ERROR, ERROR_CODES.GOOGLE_PLAY_UPDATE_RELEASE_NOTES_FAILED, "Failed to update Google Play release notes"));
+        }
+    }
+    async pullReleaseNotes(packageName) {
+        try {
+            const client = this.getClientOrThrow(packageName);
+            const releaseNotes = await client.pullProductionReleaseNotes();
+            return { success: true, data: releaseNotes };
+        }
+        catch (error) {
+            return serviceFailure(AppError.wrap(error, HTTP_STATUS.INTERNAL_SERVER_ERROR, ERROR_CODES.GOOGLE_PLAY_PULL_RELEASE_NOTES_FAILED, "Failed to pull Google Play release notes"));
+        }
+    }
+    async createVersion(packageName, versionString, versionCodes) {
+        try {
+            const client = this.getClientOrThrow(packageName);
+            await client.createProductionRelease({
+                versionCodes,
+                releaseName: versionString,
+                status: "draft",
+            });
+            return {
+                success: true,
+                data: {
+                    versionName: versionString,
+                    versionCodes,
+                    status: "DRAFT",
+                },
+            };
+        }
+        catch (error) {
+            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, }) {
+        const skip = checkPushPrerequisites({
+            storeLabel: "Google Play",
+            configured: Boolean(config.playStore),
+            identifierLabel: "packageName",
+            identifier: packageName,
+            hasData: Boolean(localAsoData.googlePlay),
+            dataPath: googlePlayDataPath,
+        });
+        if (skip)
+            return { success: false, error: skip };
+        const ensuredPackage = packageName;
+        const googlePlayData = localAsoData.googlePlay;
+        const client = this.getClientOrThrow(ensuredPackage);
+        console.error(`[MCP]   📤 Pushing to Google Play...`);
+        console.error(`[MCP]     Package: ${packageName}`);
+        try {
+            const localesToPush = Object.keys(googlePlayData.locales);
+            for (const locale of localesToPush) {
+                console.error(`[GooglePlay]   📤 Preparing locale: ${locale}`);
+            }
+            await client.pushMultilingualAsoData(googlePlayData);
+            try {
+                const updated = updateRegisteredLocales(ensuredPackage, "googlePlay", localesToPush);
+                if (updated) {
+                    console.error(`[MCP]   ✅ Updated registered-apps.json with ${localesToPush.length} Google Play locales`);
+                }
+            }
+            catch (updateError) {
+                console.error(`[MCP]   ⚠️ Failed to update registered-apps.json: ${updateError instanceof Error
+                    ? updateError.message
+                    : String(updateError)}`);
+            }
+            return {
+                success: true,
+                localesPushed: localesToPush,
+            };
+        }
+        catch (error) {
+            const wrapped = AppError.wrap(error, HTTP_STATUS.INTERNAL_SERVER_ERROR, ERROR_CODES.GOOGLE_PLAY_PUSH_FAILED, error instanceof Error ? error.message : String(error));
+            console.error(`[GooglePlay] ❌ Push failed: ${wrapped.message}`, error);
+            return { success: false, error: wrapped };
+        }
+    }
+    async verifyAuth() {
+        const result = verifyPlayStoreAuth();
+        if (!result.success) {
+            return {
+                success: false,
+                error: AppError.wrap(result.error ?? "Unknown error", HTTP_STATUS.INTERNAL_SERVER_ERROR, ERROR_CODES.GOOGLE_PLAY_VERIFY_AUTH_FAILED, "Failed to verify Google Play auth"),
+            };
+        }
+        return { success: true, data: result.data };
+    }
+}

package/dist/src/core/services/service-helpers.d.ts

@@ -0,0 +1,15 @@
+import { AppError } from "../../packages/common/errors/app-error.js";
+import type { ClientFactoryResult } from "../clients/types.js";
+import type { ServiceResult } from "./types.js";
+export declare const toServiceResult: <T>(clientResult: ClientFactoryResult<T>) => ServiceResult<T>;
+export declare const serviceSuccess: <T>(data: T) => ServiceResult<T>;
+export declare const serviceFailure: <T = never>(error: AppError) => ServiceResult<T>;
+export declare const updateRegisteredLocales: (identifier: string, store: "appStore" | "googlePlay", locales: string[]) => boolean;
+export declare const checkPushPrerequisites: ({ storeLabel, configured, identifierLabel, identifier, hasData, dataPath, }: {
+    storeLabel: string;
+    configured: boolean;
+    identifierLabel: string;
+    identifier?: string;
+    hasData: boolean;
+    dataPath?: string;
+}) => AppError | null;

package/dist/src/core/services/service-helpers.js

@@ -0,0 +1,31 @@
+import { AppError } from "../../packages/common/errors/app-error.js";
+import { ERROR_CODES } from "../../packages/common/errors/error-codes.js";
+import { updateAppSupportedLocales } from "../../packages/configs/secrets-config/registered-apps.js";
+export const toServiceResult = (clientResult) => clientResult.success
+    ? { success: true, data: clientResult.client }
+    : { success: false, error: clientResult.error };
+export const serviceSuccess = (data) => ({
+    success: true,
+    data,
+});
+export const serviceFailure = (error) => ({
+    success: false,
+    error,
+});
+export const updateRegisteredLocales = (identifier, store, locales) => updateAppSupportedLocales({ identifier, store, locales });
+export const checkPushPrerequisites = ({ storeLabel, configured, identifierLabel, identifier, hasData, dataPath, }) => {
+    if (!configured) {
+        return AppError.badRequest(ERROR_CODES.CONFIG_NOT_FOUND_SKIP, `⏭️  Skipping ${storeLabel} (not configured in ~/.config/pabal-mcp/config.json)`);
+    }
+    if (!identifier) {
+        return AppError.validation(ERROR_CODES.IDENTIFIER_MISSING, `⏭️  Skipping ${storeLabel} (no ${identifierLabel} provided)`);
+    }
+    if (!hasData) {
+        console.error(`[MCP]   ⏭️  Skipping ${storeLabel}: No data found after preparation`);
+        if (dataPath) {
+            console.error(`[MCP]     Check if data exists in: ${dataPath}`);
+        }
+        return AppError.validation(ERROR_CODES.NO_DATA_FOUND, `⏭️  Skipping ${storeLabel} (no data found)`);
+    }
+    return null;
+};

package/dist/src/core/services/types.d.ts

@@ -0,0 +1,81 @@
+import type { AppError } from "../../packages/common/errors/app-error.js";
+import type { RegisteredApp } from "../../packages/configs/secrets-config/registered-apps.js";
+export type ServiceResult<T> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: AppError;
+};
+export type MaybeResult<T> = ({
+    found: true;
+} & T) | {
+    found: false;
+    error?: AppError;
+};
+export interface StoreAppSummary {
+    id: string;
+    name: string;
+    bundleId: string;
+    sku: string;
+    isReleased: boolean;
+}
+export interface AppStoreVersionInfo {
+    versionString: string;
+    state: string;
+}
+export interface GooglePlayReleaseInfo {
+    versionName?: string;
+    releaseName?: string;
+    status?: string;
+    versionCodes: number[];
+}
+export interface CreatedAppStoreVersion {
+    id: string;
+    versionString: string;
+    state?: string;
+}
+export interface CreatedGooglePlayVersion {
+    versionName: string;
+    versionCodes: number[];
+    status: string;
+    releaseName?: string;
+}
+export interface UpdatedReleaseNotesResult {
+    updated: string[];
+    failed: Array<{
+        locale: string;
+        error: string;
+    }>;
+}
+export interface PushFailedFields {
+    locale: string;
+    fields: string[];
+}
+export type PushAsoResult = {
+    success: true;
+    localesPushed: string[];
+    failedFields?: PushFailedFields[];
+} | {
+    success: false;
+    error: AppError;
+    needsNewVersion?: boolean;
+    versionInfo?: {
+        versionId: string;
+        versionString: string;
+        locales: string[];
+    };
+};
+export interface VerifyAuthResult<TPayload = Record<string, unknown>> {
+    success: boolean;
+    error?: AppError;
+    data?: TPayload;
+}
+export interface ResolvedAppContext {
+    app: RegisteredApp;
+    slug: string;
+    bundleId?: string;
+    packageName?: string;
+    hasAppStore: boolean;
+    hasGooglePlay: boolean;
+}

package/dist/src/core/services/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/core/workflows/version-info.d.ts

@@ -0,0 +1,29 @@
+import { type StoreType } from "../../packages/configs/aso-config/types.js";
+export interface LatestVersionsInput {
+    store?: StoreType;
+    bundleId?: string;
+    packageName?: string;
+    hasAppStore: boolean;
+    hasGooglePlay: boolean;
+    includePrompt?: boolean;
+}
+export interface LatestVersionsResult {
+    messages: string[];
+    appStore?: {
+        found: boolean;
+        versionString?: string;
+        state?: string;
+        error?: string;
+        skipped?: string;
+    };
+    googlePlay?: {
+        found: boolean;
+        versionName?: string;
+        versionCodes?: number[];
+        status?: string;
+        releaseName?: string;
+        error?: string;
+        skipped?: string;
+    };
+}
+export declare function getLatestVersions(input: LatestVersionsInput): Promise<LatestVersionsResult>;