pabal-store-api-mcp 1.1.0

package/dist/src/core/workflows/version-info.js

@@ -0,0 +1,100 @@
+import { loadConfig } from "../../packages/configs/secrets-config/config.js";
+import { getStoreTargets } from "../../packages/configs/aso-config/store.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();
+export async function getLatestVersions(input) {
+    const { store, bundleId, packageName, hasAppStore, hasGooglePlay, includePrompt = true, } = input;
+    const { includeAppStore, includeGooglePlay } = getStoreTargets(store);
+    const config = loadConfig();
+    const messages = [];
+    messages.push(`\n📋 Checking latest versions from stores...\n`);
+    const result = { messages };
+    if (includeAppStore) {
+        if (!hasAppStore) {
+            const skipped = `⏭️  Skipping App Store (not registered for App Store)`;
+            messages.push(skipped);
+            result.appStore = { found: false, skipped };
+        }
+        else if (!config.appStore) {
+            const skipped = `⏭️  Skipping App Store (not configured in ~/.config/pabal-mcp/config.json)`;
+            messages.push(skipped);
+            result.appStore = { found: false, skipped };
+        }
+        else if (!bundleId) {
+            const skipped = `⏭️  Skipping App Store (no bundleId provided)`;
+            messages.push(skipped);
+            result.appStore = { found: false, skipped };
+        }
+        else {
+            const latest = await appStoreService.getLatestVersion(bundleId);
+            if (!latest.found) {
+                const errMsg = latest.error instanceof Error
+                    ? latest.error.message
+                    : (latest.error ?? "");
+                const msg = errMsg
+                    ? `🍎 App Store: Check failed - ${errMsg}`
+                    : `🍎 App Store: No version found (can create first version)`;
+                messages.push(msg);
+                result.appStore = { found: false, error: errMsg || undefined };
+            }
+            else {
+                const state = latest.state?.toUpperCase() || "UNKNOWN";
+                messages.push(`🍎 App Store: ${latest.versionString} (${state})`);
+                result.appStore = {
+                    found: true,
+                    versionString: latest.versionString,
+                    state,
+                };
+            }
+        }
+    }
+    if (includeGooglePlay) {
+        if (!hasGooglePlay) {
+            const skipped = `⏭️  Skipping Google Play (not registered for Google Play)`;
+            messages.push(skipped);
+            result.googlePlay = { found: false, skipped };
+        }
+        else if (!config.playStore) {
+            const skipped = `⏭️  Skipping Google Play (not configured in ~/.config/pabal-mcp/config.json)`;
+            messages.push(skipped);
+            result.googlePlay = { found: false, skipped };
+        }
+        else if (!packageName) {
+            const skipped = `⏭️  Skipping Google Play (no packageName provided)`;
+            messages.push(skipped);
+            result.googlePlay = { found: false, skipped };
+        }
+        else {
+            const latest = await googlePlayService.getLatestProductionRelease(packageName);
+            if (!latest.found) {
+                const errMsg = latest.error instanceof Error
+                    ? latest.error.message
+                    : (latest.error ?? "");
+                const msg = errMsg
+                    ? `🤖 Google Play: Check failed - ${errMsg}`
+                    : `🤖 Google Play: No version found (can create first version)`;
+                messages.push(msg);
+                result.googlePlay = { found: false, error: errMsg || undefined };
+            }
+            else {
+                const versionName = latest.versionName || latest.releaseName || "N/A";
+                const status = latest.status?.toUpperCase() || "UNKNOWN";
+                messages.push(`🤖 Google Play: ${versionName} (versionCodes: ${latest.versionCodes.join(", ")}, ${status})`);
+                result.googlePlay = {
+                    found: true,
+                    versionName,
+                    versionCodes: latest.versionCodes,
+                    status,
+                    releaseName: latest.releaseName,
+                };
+            }
+        }
+    }
+    if (includePrompt) {
+        messages.push(`\n💡 To create a new version, please provide the 'version' parameter.`);
+        messages.push(`   Example: Call release-create tool with version="1.2.0".`);
+    }
+    return result;
+}

package/dist/src/index.d.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+interface ToolInfo {
+    name: string;
+    description: string;
+    inputSchema?: z.ZodObject<any> | z.ZodTypeAny;
+    category?: string;
+}
+export declare function getToolInfos(): ToolInfo[];
+export declare function startServer(): Promise<void>;
+export {};

package/dist/src/index.js

@@ -0,0 +1,279 @@
+import { fileURLToPath } from "node:url";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { handleAuthCheck } from "./tools/auth/check.js";
+import { handleSetupApps } from "./tools/apps/init.js";
+import { handleAddApp } from "./tools/apps/add.js";
+import { handleSearchApps } from "./tools/apps/search.js";
+import { handleAsoPull } from "./tools/aso/pull.js";
+import { handleAsoPush } from "./tools/aso/push.js";
+import { handleAsoCreateVersion } from "./tools/release/create.js";
+import { handleAsoPullReleaseNotes } from "./tools/release/pull-notes.js";
+import { handleUpdateNotes } from "./tools/release/update-notes.js";
+import { handleCheckLatestVersions } from "./tools/release/check-versions.js";
+// MCP config sets cwd to project root, so we don't need to chdir
+// Just verify we're in the right place
+console.error(`[MCP] 📂 Working directory: ${process.cwd()}`);
+const server = new McpServer({ name: "pabal-mcp", version: "0.0.1" }, {
+    instructions: "Provides tools for App Store/Play Store ASO.",
+});
+// ============================================================================
+// Common Schemas
+// ============================================================================
+const storeSchema = z.enum(["appStore", "googlePlay", "both"]).optional();
+const toolInfos = [];
+/**
+ * Format parameters for logging (hide sensitive data)
+ */
+function formatParamsForLogging(params) {
+    if (!params || typeof params !== "object")
+        return "";
+    const safeParams = {};
+    const sensitiveKeys = [
+        "privateKey",
+        "serviceAccountJson",
+        "serviceAccountKey",
+    ];
+    for (const [key, value] of Object.entries(params)) {
+        if (sensitiveKeys.some((sk) => key.toLowerCase().includes(sk.toLowerCase()))) {
+            safeParams[key] = "[REDACTED]";
+        }
+        else if (typeof value === "object" && value !== null) {
+            safeParams[key] = formatParamsForLogging(value);
+        }
+        else {
+            safeParams[key] = value;
+        }
+    }
+    const entries = Object.entries(safeParams)
+        .filter(([_, v]) => v !== undefined && v !== null && v !== "")
+        .map(([k, v]) => `${k}=${typeof v === "object" ? JSON.stringify(v) : v}`)
+        .slice(0, 3); // Limit to first 3 params to keep it concise
+    return entries.length > 0 ? ` (${entries.join(", ")})` : "";
+}
+/**
+ * Wrap handler with logging
+ */
+function wrapHandlerWithLogging(name, handler) {
+    return async (params) => {
+        const paramsStr = formatParamsForLogging(params);
+        console.error(`[MCP] 🔧 ${name}${paramsStr}`);
+        const startTime = Date.now();
+        try {
+            const result = await handler(params);
+            const duration = Date.now() - startTime;
+            console.error(`[MCP] ✅ ${name} completed (${duration}ms)`);
+            return result;
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            console.error(`[MCP] ❌ ${name} failed (${duration}ms): ${errorMsg}`);
+            throw error;
+        }
+    };
+}
+function registerToolWithInfo(name, info, handler, category) {
+    // Store tool info for documentation (keep zod schema)
+    toolInfos.push({
+        name,
+        description: info.description,
+        inputSchema: info.inputSchema,
+        category,
+    });
+    // Convert zod schema to plain object for MCP SDK
+    const mcpInfo = {
+        description: info.description,
+    };
+    if (info.inputSchema && info.inputSchema instanceof z.ZodObject) {
+        // Convert ZodObject to plain object format expected by MCP SDK
+        const shape = info.inputSchema.shape;
+        const plainSchema = {};
+        for (const [key, value] of Object.entries(shape)) {
+            plainSchema[key] = value;
+        }
+        mcpInfo.inputSchema = plainSchema;
+    }
+    // Wrap handler with logging
+    const wrappedHandler = wrapHandlerWithLogging(name, handler);
+    server.registerTool(name, mcpInfo, wrappedHandler);
+}
+// Export tool info for documentation
+export function getToolInfos() {
+    return toolInfos;
+}
+// ============================================================================
+// Authentication (auth-*)
+// ============================================================================
+registerToolWithInfo("auth-check", {
+    description: "Check authentication status for App Store Connect / Google Play Console.",
+    inputSchema: z.object({
+        store: storeSchema.describe("Store to check (default: both)"),
+    }),
+}, handleAuthCheck, "Authentication");
+// ============================================================================
+// App Management (apps-*)
+// ============================================================================
+registerToolWithInfo("apps-init", {
+    description: "Query app list from store API and register automatically. App Store: auto-register all apps, Google Play: packageName required.",
+    inputSchema: z.object({
+        store: z
+            .enum(["appStore", "googlePlay"])
+            .optional()
+            .describe("Target store (default: appStore)"),
+        packageName: z
+            .string()
+            .optional()
+            .describe("Google Play package name (required when setting up Google Play)"),
+    }),
+}, handleSetupApps, "App Management");
+registerToolWithInfo("apps-add", {
+    description: "Register individual app by bundleId or packageName. Automatically checks both stores.",
+    inputSchema: z.object({
+        identifier: z
+            .string()
+            .describe("App identifier (bundleId or packageName, e.g., com.example.app)"),
+        slug: z
+            .string()
+            .optional()
+            .describe("Custom slug (if not specified, uses last part of identifier)"),
+        store: storeSchema.describe("Store to check (default: both)"),
+    }),
+}, handleAddApp, "App Management");
+registerToolWithInfo("apps-search", {
+    description: "Search registered apps. Returns all apps if called without query.",
+    inputSchema: z.object({
+        query: z
+            .string()
+            .optional()
+            .describe("Search term (slug, bundleId, packageName, name). Returns all apps if empty"),
+        store: z
+            .enum(["all", "appStore", "googlePlay"])
+            .optional()
+            .describe("Store filter (default: all)"),
+    }),
+}, handleSearchApps, "App Management");
+// ============================================================================
+// ASO Data Sync (aso-*)
+// ============================================================================
+registerToolWithInfo("aso-pull", {
+    description: "Fetch ASO data from App Store/Google Play and save to local cache.",
+    inputSchema: z.object({
+        app: z
+            .string()
+            .optional()
+            .describe("Registered app slug (app registered via apps-init)"),
+        packageName: z.string().optional().describe("Google Play package name"),
+        bundleId: z.string().optional().describe("App Store bundle ID"),
+        store: storeSchema.describe("Target store (default: both)"),
+        dryRun: z
+            .boolean()
+            .optional()
+            .describe("If true, only outputs result without actually saving"),
+    }),
+}, handleAsoPull, "ASO Data Sync");
+registerToolWithInfo("aso-push", {
+    description: "Push ASO data from local cache to App Store/Google Play.",
+    inputSchema: z.object({
+        app: z.string().optional().describe("Registered app slug"),
+        packageName: z.string().optional().describe("Google Play package name"),
+        bundleId: z.string().optional().describe("App Store bundle ID"),
+        store: storeSchema.describe("Target store (default: both)"),
+        uploadImages: z
+            .boolean()
+            .optional()
+            .describe("Whether to upload images as well"),
+        dryRun: z
+            .boolean()
+            .optional()
+            .describe("If true, only outputs result without actually pushing"),
+    }),
+}, handleAsoPush, "ASO Data Sync");
+// ============================================================================
+// Release Management (release-*)
+// ============================================================================
+registerToolWithInfo("release-check-versions", {
+    description: "Check latest versions from App Store/Google Play.",
+    inputSchema: z.object({
+        app: z.string().optional().describe("Registered app slug"),
+        packageName: z.string().optional().describe("Google Play package name"),
+        bundleId: z.string().optional().describe("App Store bundle ID"),
+        store: storeSchema.describe("Target store (default: both)"),
+    }),
+}, handleCheckLatestVersions, "Release Management");
+registerToolWithInfo("release-create", {
+    description: "Create a new version on App Store/Google Play. If version is not provided, checks and displays latest versions from each store.",
+    inputSchema: z.object({
+        app: z.string().optional().describe("Registered app slug"),
+        packageName: z.string().optional().describe("Google Play package name"),
+        bundleId: z.string().optional().describe("App Store bundle ID"),
+        version: z
+            .string()
+            .optional()
+            .describe("Version string to create (e.g., 1.2.0). If not provided, will check and display latest versions."),
+        store: storeSchema.describe("Target store (default: both)"),
+        versionCodes: z
+            .array(z.number())
+            .optional()
+            .describe("Version code array for Google Play (required when creating Google Play version)"),
+    }),
+}, handleAsoCreateVersion, "Release Management");
+registerToolWithInfo("release-pull-notes", {
+    description: "Fetch release notes from App Store/Google Play.",
+    inputSchema: z.object({
+        app: z.string().optional().describe("Registered app slug"),
+        packageName: z.string().optional().describe("Google Play package name"),
+        bundleId: z.string().optional().describe("App Store bundle ID"),
+        store: storeSchema.describe("Target store (default: both)"),
+        dryRun: z
+            .boolean()
+            .optional()
+            .describe("If true, only outputs result without actually saving"),
+    }),
+}, handleAsoPullReleaseNotes, "Release Management");
+registerToolWithInfo("release-update-notes", {
+    description: "Update release notes (What's New) for App Store/Google Play version.",
+    inputSchema: z.object({
+        app: z.string().optional().describe("Registered app slug"),
+        packageName: z.string().optional().describe("Google Play package name"),
+        bundleId: z.string().optional().describe("App Store bundle ID"),
+        store: storeSchema.describe("Target store (default: both)"),
+        versionId: z
+            .string()
+            .optional()
+            .describe("App Store version ID (auto-detects editable version if not specified)"),
+        whatsNew: z
+            .record(z.string(), z.string())
+            .optional()
+            .describe('Release notes by locale (e.g., { "en-US": "Bug fixes", "ko": "Bug fixes" })'),
+        text: z
+            .string()
+            .optional()
+            .describe("Source text to translate to all supported languages"),
+        sourceLocale: z
+            .string()
+            .optional()
+            .describe("Source locale (default: en-US)"),
+    }),
+}, handleUpdateNotes, "Release Management");
+async function main() {
+    console.error("[MCP] 🚀 Starting pabal-mcp server...");
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("[MCP] ✅ Server connected and ready");
+}
+// Exported for CLI entrypoint (bin/pabal-mcp.js) so npx can start the server
+export async function startServer() {
+    return main();
+}
+// Only start server if this file is run directly (not imported)
+// Check if the current file is the main module being executed
+const isMainModule = import.meta.url === `file://${process.argv[1]}` ||
+    fileURLToPath(import.meta.url) === process.argv[1];
+if (isMainModule) {
+    startServer().catch((error) => {
+        console.error("MCP server failed to start", error);
+        process.exit(1);
+    });
+}

package/dist/src/packages/common/errors/app-error.d.ts

@@ -0,0 +1,39 @@
+export interface AppErrorJSON {
+    status: number;
+    code: string;
+    message: string;
+    details?: unknown;
+}
+type AppErrorParams = {
+    status: number;
+    code: string;
+    message: string;
+    details?: unknown;
+    cause?: unknown;
+};
+/**
+ * Standardized application error with HTTP-style status codes.
+ * Use factory methods (e.g. AppError.notFound) for consistency.
+ */
+export declare class AppError extends Error {
+    status: number;
+    code: string;
+    details?: unknown;
+    constructor({ status, code, message, details, cause }: AppErrorParams);
+    static badRequest(code: string, message: string, details?: unknown): AppError;
+    static validation(code: string, message: string, details?: unknown): AppError;
+    static unauthorized(code: string, message: string, details?: unknown): AppError;
+    static forbidden(code: string, message: string, details?: unknown): AppError;
+    static notFound(code: string, message: string, details?: unknown): AppError;
+    static conflict(code: string, message: string, details?: unknown): AppError;
+    static configMissing(code: string, message: string, details?: unknown): AppError;
+    static io(code: string, message: string, details?: unknown): AppError;
+    static fileNotFound(code: string, message: string, details?: unknown): AppError;
+    static internal(code: string, message: string, details?: unknown, cause?: unknown): AppError;
+    /**
+     * Wrap an unknown error into an AppError while preserving the message.
+     */
+    static wrap(error: unknown, fallbackStatus?: number, fallbackCode?: string, overrideMessage?: string): AppError;
+    toJSON(): AppErrorJSON;
+}
+export {};

package/dist/src/packages/common/errors/app-error.js

@@ -0,0 +1,134 @@
+import { ERROR_CODES } from "./error-codes.js";
+import { HTTP_STATUS } from "./status-codes.js";
+/**
+ * Standardized application error with HTTP-style status codes.
+ * Use factory methods (e.g. AppError.notFound) for consistency.
+ */
+export class AppError extends Error {
+    status;
+    code;
+    details;
+    constructor({ status, code, message, details, cause }) {
+        super(message);
+        this.name = "AppError";
+        this.status = status;
+        this.code = code;
+        this.details = details;
+        if (cause !== undefined) {
+            // Preserve original error for debugging without leaking in toJSON
+            this.cause = cause;
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Factory helpers
+    // ---------------------------------------------------------------------------
+    static badRequest(code, message, details) {
+        return new AppError({
+            status: HTTP_STATUS.BAD_REQUEST,
+            code,
+            message,
+            details,
+        });
+    }
+    static validation(code, message, details) {
+        return new AppError({
+            status: HTTP_STATUS.UNPROCESSABLE_ENTITY,
+            code,
+            message,
+            details,
+        });
+    }
+    static unauthorized(code, message, details) {
+        return new AppError({
+            status: HTTP_STATUS.UNAUTHORIZED,
+            code,
+            message,
+            details,
+        });
+    }
+    static forbidden(code, message, details) {
+        return new AppError({
+            status: HTTP_STATUS.FORBIDDEN,
+            code,
+            message,
+            details,
+        });
+    }
+    static notFound(code, message, details) {
+        return new AppError({
+            status: HTTP_STATUS.NOT_FOUND,
+            code,
+            message,
+            details,
+        });
+    }
+    static conflict(code, message, details) {
+        return new AppError({
+            status: HTTP_STATUS.CONFLICT,
+            code,
+            message,
+            details,
+        });
+    }
+    static configMissing(code, message, details) {
+        return new AppError({
+            status: HTTP_STATUS.INTERNAL_SERVER_ERROR,
+            code,
+            message,
+            details,
+        });
+    }
+    static io(code, message, details) {
+        return new AppError({
+            status: HTTP_STATUS.INTERNAL_SERVER_ERROR,
+            code,
+            message,
+            details,
+        });
+    }
+    static fileNotFound(code, message, details) {
+        return new AppError({
+            status: HTTP_STATUS.NOT_FOUND,
+            code,
+            message,
+            details,
+        });
+    }
+    static internal(code, message, details, cause) {
+        return new AppError({
+            status: HTTP_STATUS.INTERNAL_SERVER_ERROR,
+            code,
+            message,
+            details,
+            cause,
+        });
+    }
+    /**
+     * Wrap an unknown error into an AppError while preserving the message.
+     */
+    static wrap(error, fallbackStatus = HTTP_STATUS.INTERNAL_SERVER_ERROR, fallbackCode = ERROR_CODES.INTERNAL_ERROR, overrideMessage) {
+        if (error instanceof AppError)
+            return error;
+        if (error instanceof Error) {
+            return new AppError({
+                status: fallbackStatus,
+                code: fallbackCode,
+                message: overrideMessage ?? error.message,
+                cause: error,
+            });
+        }
+        return new AppError({
+            status: fallbackStatus,
+            code: fallbackCode,
+            message: overrideMessage ?? String(error),
+        });
+    }
+    toJSON() {
+        return {
+            status: this.status,
+            code: this.code,
+            message: this.message,
+            ...(this.details ? { details: this.details } : {}),
+        };
+    }
+}

package/dist/src/packages/common/errors/error-codes.d.ts

@@ -0,0 +1,63 @@
+export declare const ERROR_CODES: {
+    readonly INTERNAL_ERROR: "INTERNAL_ERROR";
+    readonly CLIENT_FACTORY_ERROR: "CLIENT_FACTORY_ERROR";
+    readonly CONFIG_ERROR: "CONFIG_ERROR";
+    readonly CONFIG_NOT_FOUND: "CONFIG_NOT_FOUND";
+    readonly CONFIG_AUTH_NOT_FOUND: "CONFIG_AUTH_NOT_FOUND";
+    readonly CONFIG_READ_FAILED: "CONFIG_READ_FAILED";
+    readonly REGISTERED_APPS_READ_FAILED: "REGISTERED_APPS_READ_FAILED";
+    readonly REGISTERED_APPS_WRITE_FAILED: "REGISTERED_APPS_WRITE_FAILED";
+    readonly REGISTERED_APP_DUPLICATE: "REGISTERED_APP_DUPLICATE";
+    readonly REGISTERED_APP_NOT_FOUND: "REGISTERED_APP_NOT_FOUND";
+    readonly REGISTERED_APP_STORE_INFO_MISSING: "REGISTERED_APP_STORE_INFO_MISSING";
+    readonly CONFIG_NOT_FOUND_SKIP: "CONFIG_NOT_FOUND";
+    readonly IDENTIFIER_MISSING: "IDENTIFIER_MISSING";
+    readonly NO_DATA_FOUND: "NO_DATA_FOUND";
+    readonly APP_IDENTIFIER_MISSING: "APP_IDENTIFIER_MISSING";
+    readonly APP_NOT_FOUND: "APP_NOT_FOUND";
+    readonly APP_RESOLUTION_FAILED: "APP_RESOLUTION_FAILED";
+    readonly APP_STORE_CLIENT_CONFIG_MISSING: "APP_STORE_CLIENT_CONFIG_MISSING";
+    readonly APP_STORE_BUNDLE_ID_INVALID: "APP_STORE_BUNDLE_ID_INVALID";
+    readonly APP_STORE_CONFIG_LOAD_FAILED: "APP_STORE_CONFIG_LOAD_FAILED";
+    readonly APP_STORE_CONFIG_MISSING: "APP_STORE_CONFIG_MISSING";
+    readonly APP_STORE_ISSUER_ID_INVALID: "APP_STORE_ISSUER_ID_INVALID";
+    readonly APP_STORE_KEY_ID_INVALID: "APP_STORE_KEY_ID_INVALID";
+    readonly APP_STORE_PRIVATE_KEY_INVALID: "APP_STORE_PRIVATE_KEY_INVALID";
+    readonly APP_STORE_PRIVATE_KEY_FORMAT_INVALID: "APP_STORE_PRIVATE_KEY_FORMAT_INVALID";
+    readonly APP_STORE_CLIENT_CREATE_FAILED: "APP_STORE_CLIENT_CREATE_FAILED";
+    readonly GOOGLE_PLAY_CLIENT_CONFIG_MISSING: "GOOGLE_PLAY_CLIENT_CONFIG_MISSING";
+    readonly GOOGLE_PLAY_PACKAGE_NAME_INVALID: "GOOGLE_PLAY_PACKAGE_NAME_INVALID";
+    readonly GOOGLE_PLAY_CONFIG_LOAD_FAILED: "GOOGLE_PLAY_CONFIG_LOAD_FAILED";
+    readonly GOOGLE_PLAY_CONFIG_MISSING: "GOOGLE_PLAY_CONFIG_MISSING";
+    readonly GOOGLE_PLAY_SERVICE_ACCOUNT_JSON_INVALID: "GOOGLE_PLAY_SERVICE_ACCOUNT_JSON_INVALID";
+    readonly GOOGLE_PLAY_SERVICE_ACCOUNT_JSON_FORMAT_INVALID: "GOOGLE_PLAY_SERVICE_ACCOUNT_JSON_FORMAT_INVALID";
+    readonly GOOGLE_PLAY_SERVICE_ACCOUNT_JSON_PARSE_FAILED: "GOOGLE_PLAY_SERVICE_ACCOUNT_JSON_PARSE_FAILED";
+    readonly GOOGLE_PLAY_CLIENT_CREATE_FAILED: "GOOGLE_PLAY_CLIENT_CREATE_FAILED";
+    readonly APP_STORE_LIST_APPS_FAILED: "APP_STORE_LIST_APPS_FAILED";
+    readonly APP_STORE_FETCH_APP_INFO_FAILED: "APP_STORE_FETCH_APP_INFO_FAILED";
+    readonly APP_STORE_GET_LATEST_VERSION_FAILED: "APP_STORE_GET_LATEST_VERSION_FAILED";
+    readonly APP_STORE_VERSION_NOT_EDITABLE: "APP_STORE_VERSION_NOT_EDITABLE";
+    readonly APP_STORE_UPDATE_RELEASE_NOTES_PARTIAL: "APP_STORE_UPDATE_RELEASE_NOTES_PARTIAL";
+    readonly APP_STORE_UPDATE_RELEASE_NOTES_FAILED: "APP_STORE_UPDATE_RELEASE_NOTES_FAILED";
+    readonly APP_STORE_PULL_RELEASE_NOTES_FAILED: "APP_STORE_PULL_RELEASE_NOTES_FAILED";
+    readonly APP_STORE_CREATE_VERSION_FAILED: "APP_STORE_CREATE_VERSION_FAILED";
+    readonly APP_STORE_PUSH_FAILED: "APP_STORE_PUSH_FAILED";
+    readonly APP_STORE_STATE_ERROR: "APP_STORE_STATE_ERROR";
+    readonly APP_STORE_CREATE_VERSION_FOR_STATE_ERROR_FAILED: "APP_STORE_CREATE_VERSION_FOR_STATE_ERROR_FAILED";
+    readonly APP_STORE_VERIFY_AUTH_FAILED: "APP_STORE_VERIFY_AUTH_FAILED";
+    readonly GOOGLE_PLAY_FETCH_APP_INFO_FAILED: "GOOGLE_PLAY_FETCH_APP_INFO_FAILED";
+    readonly GOOGLE_PLAY_GET_LATEST_RELEASE_FAILED: "GOOGLE_PLAY_GET_LATEST_RELEASE_FAILED";
+    readonly GOOGLE_PLAY_RELEASE_NOTES_EMPTY: "GOOGLE_PLAY_RELEASE_NOTES_EMPTY";
+    readonly GOOGLE_PLAY_UPDATE_RELEASE_NOTES_PARTIAL: "GOOGLE_PLAY_UPDATE_RELEASE_NOTES_PARTIAL";
+    readonly GOOGLE_PLAY_UPDATE_RELEASE_NOTES_FAILED: "GOOGLE_PLAY_UPDATE_RELEASE_NOTES_FAILED";
+    readonly GOOGLE_PLAY_PULL_RELEASE_NOTES_FAILED: "GOOGLE_PLAY_PULL_RELEASE_NOTES_FAILED";
+    readonly GOOGLE_PLAY_CREATE_VERSION_FAILED: "GOOGLE_PLAY_CREATE_VERSION_FAILED";
+    readonly GOOGLE_PLAY_PUSH_FAILED: "GOOGLE_PLAY_PUSH_FAILED";
+    readonly GOOGLE_PLAY_VERIFY_AUTH_FAILED: "GOOGLE_PLAY_VERIFY_AUTH_FAILED";
+    readonly ASO_GOOGLE_PLAY_DATA_PARSE_FAILED: "ASO_GOOGLE_PLAY_DATA_PARSE_FAILED";
+    readonly ASO_APP_STORE_DATA_PARSE_FAILED: "ASO_APP_STORE_DATA_PARSE_FAILED";
+    readonly ASO_DATA_SAVE_FAILED: "ASO_DATA_SAVE_FAILED";
+    readonly ASO_IMAGE_DOWNLOAD_FAILED: "ASO_IMAGE_DOWNLOAD_FAILED";
+    readonly ASO_LOCAL_ASSET_NOT_FOUND: "ASO_LOCAL_ASSET_NOT_FOUND";
+};
+export type ErrorCode = (typeof ERROR_CODES)[keyof typeof ERROR_CODES];