Pabal MCP

Instructions

Implementation Reference

• src/tools/release/create.ts:21-167 (handler)

  The `handleAsoCreateVersion` function is the main handler for the 'release-create' tool. It resolves app identifiers, loads config, optionally prompts for version if not provided, and creates new versions on App Store and/or Google Play using the respective services.

  export async function handleAsoCreateVersion(options: AsoCreateVersionOptions) {
    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" as const,
            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" as const,
            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" as const,
            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: string[] = [];
  
    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" as const,
          text: `📦 Version Creation Results:\n${results.join("\n")}`,
        },
      ],
    };
  }

• src/index.ts:299-325 (registration)

  The 'release-create' tool is registered here using `registerToolWithInfo`, which adds it to the MCP server, provides the description, input schema, and links to the `handleAsoCreateVersion` handler.

  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"
  );

• src/tools/release/create.ts:12-19 (schema)

  TypeScript interface defining the input options for the handler, matching the Zod schema used in registration.

  interface AsoCreateVersionOptions {
    app?: string; // Registered app slug
    packageName?: string; // For Google Play
    bundleId?: string; // For App Store
    version?: string; // Optional: if not provided, will check latest versions and prompt
    store?: StoreType;
    versionCodes?: number[]; // For Google Play
  }