asc-mcp 1.0.0

package/dist/index.js

@@ -0,0 +1,2813 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+
+// src/utils/errors.ts
+function getSensitivePatterns() {
+  return [
+    /Bearer [A-Za-z0-9\-_]+\.[A-Za-z0-9\-_]+\.[A-Za-z0-9\-_]+/gi,
+    // JWT tokens
+    /-----BEGIN.*?-----[\s\S]*?-----END.*?-----/g,
+    // PEM keys
+    /[A-Za-z0-9]{8}-[A-Za-z0-9]{4}-[A-Za-z0-9]{4}-[A-Za-z0-9]{4}-[A-Za-z0-9]{12}/gi
+    // UUIDs (issuer IDs)
+  ];
+}
+function sanitizeMessage(message) {
+  let sanitized = message;
+  for (const pattern of getSensitivePatterns()) {
+    sanitized = sanitized.replace(pattern, "[REDACTED]");
+  }
+  return sanitized;
+}
+var ASCError = class extends Error {
+  code;
+  status;
+  details;
+  constructor(message, code, status, details) {
+    super(sanitizeMessage(message));
+    this.name = "ASCError";
+    this.code = code;
+    this.status = status;
+    this.details = details;
+  }
+  toJSON() {
+    return {
+      success: false,
+      error: {
+        code: this.code,
+        message: this.message,
+        details: this.details
+      }
+    };
+  }
+};
+var AuthError = class extends ASCError {
+  constructor(message, details) {
+    super(message, "AUTH_ERROR", 401, details);
+    this.name = "AuthError";
+  }
+};
+var RateLimitError = class extends ASCError {
+  retryAfter;
+  constructor(retryAfter, details) {
+    super(`Rate limit exceeded. Retry after ${retryAfter} seconds.`, "RATE_LIMIT", 429, details);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+  toJSON() {
+    return {
+      success: false,
+      error: {
+        code: this.code,
+        message: this.message,
+        details: this.details,
+        retryAfter: this.retryAfter
+      }
+    };
+  }
+};
+var ValidationError = class extends ASCError {
+  field;
+  constructor(message, field) {
+    super(message, "VALIDATION_ERROR", 400);
+    this.name = "ValidationError";
+    this.field = field;
+  }
+  toJSON() {
+    return {
+      success: false,
+      error: {
+        code: this.code,
+        message: this.message,
+        details: this.details,
+        field: this.field
+      }
+    };
+  }
+};
+var ConfigError = class extends ASCError {
+  constructor(message) {
+    super(message, "CONFIG_ERROR", 500);
+    this.name = "ConfigError";
+  }
+};
+function parseAPIError(status, body) {
+  const errors = body?.errors;
+  if (status === 401) {
+    return new AuthError("Authentication failed", errors);
+  }
+  if (status === 429) {
+    return new RateLimitError(60, errors);
+  }
+  if (status === 404) {
+    const detail = errors?.[0]?.detail ?? "Resource not found";
+    return new ASCError(detail, "NOT_FOUND", 404, errors);
+  }
+  if (status === 403) {
+    return new ASCError(
+      "Access forbidden. Check your API key permissions.",
+      "FORBIDDEN",
+      403,
+      errors
+    );
+  }
+  if (status === 409) {
+    const detail = errors?.[0]?.detail ?? "Conflict with current state";
+    return new ASCError(detail, "CONFLICT", 409, errors);
+  }
+  const message = errors?.[0]?.detail ?? `API request failed with status ${status}`;
+  return new ASCError(message, "API_ERROR", status, errors);
+}
+function formatErrorResponse(error) {
+  if (error instanceof ASCError) {
+    return error.toJSON();
+  }
+  if (error instanceof Error) {
+    return {
+      success: false,
+      error: {
+        code: "INTERNAL_ERROR",
+        message: sanitizeMessage(error.message)
+      }
+    };
+  }
+  return {
+    success: false,
+    error: {
+      code: "UNKNOWN_ERROR",
+      message: "An unknown error occurred"
+    }
+  };
+}
+
+// src/api/client.ts
+var BASE_URL = "https://api.appstoreconnect.apple.com/v1";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var MAX_RETRIES = 3;
+var INITIAL_RETRY_DELAY_MS = 1e3;
+var RATE_LIMIT_WINDOW_MS = 6e4;
+var MAX_REQUESTS_PER_WINDOW = 50;
+var AppStoreConnectClient = class {
+  tokenManager;
+  baseUrl;
+  rateLimiter = { timestamps: [] };
+  constructor(tokenManager, baseUrl = BASE_URL) {
+    this.tokenManager = tokenManager;
+    this.baseUrl = baseUrl;
+  }
+  /**
+   * Make a GET request
+   */
+  async get(path2, params) {
+    return this.request({ method: "GET", path: path2, params });
+  }
+  /**
+   * Make a POST request
+   */
+  async post(path2, body) {
+    return this.request({ method: "POST", path: path2, body });
+  }
+  /**
+   * Make a PATCH request
+   */
+  async patch(path2, body) {
+    return this.request({ method: "PATCH", path: path2, body });
+  }
+  /**
+   * Make a DELETE request
+   */
+  async delete(path2, body) {
+    await this.request({ method: "DELETE", path: path2, body });
+  }
+  /**
+   * Make a raw request (for custom operations like file uploads)
+   */
+  async rawRequest(url, options) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), options.timeout ?? DEFAULT_TIMEOUT_MS);
+    try {
+      const response = await fetch(url, {
+        method: options.method,
+        headers: options.headers,
+        body: options.body,
+        signal: controller.signal
+      });
+      return response;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Paginate through all results
+   */
+  async *paginate(path2, params, maxItems) {
+    let cursor;
+    let itemsYielded = 0;
+    do {
+      const queryParams = { ...params };
+      if (cursor) {
+        if (cursor.includes("?")) {
+          try {
+            const url = new URL(cursor);
+            for (const [key, value] of url.searchParams) {
+              queryParams[key] = value;
+            }
+          } catch {
+            const queryString = cursor.split("?")[1];
+            if (queryString) {
+              const searchParams = new URLSearchParams(queryString);
+              for (const [key, value] of searchParams) {
+                queryParams[key] = value;
+              }
+            }
+          }
+        }
+      }
+      const response = await this.get(path2, queryParams);
+      for (const item of response.data) {
+        yield item;
+        itemsYielded++;
+        if (maxItems && itemsYielded >= maxItems) {
+          return;
+        }
+      }
+      cursor = response.links?.next;
+    } while (cursor);
+  }
+  /**
+   * Core request method with retry logic
+   */
+  async request(options) {
+    await this.enforceRateLimit();
+    let lastError;
+    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+      try {
+        return await this.executeRequest(options);
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (error instanceof ASCError && error.status >= 400 && error.status < 500) {
+          if (error instanceof RateLimitError) {
+            const waitMs = error.retryAfter * 1e3;
+            await this.sleep(waitMs);
+            continue;
+          }
+          throw error;
+        }
+        if (attempt < MAX_RETRIES - 1) {
+          const delay = INITIAL_RETRY_DELAY_MS * 2 ** attempt;
+          await this.sleep(delay);
+        }
+      }
+    }
+    throw lastError ?? new Error("Request failed after max retries");
+  }
+  /**
+   * Execute a single HTTP request
+   */
+  async executeRequest(options) {
+    const token = await this.tokenManager.getToken();
+    const url = this.buildUrl(options.path, options.params);
+    const headers = {
+      Authorization: `Bearer ${token}`
+    };
+    if (options.body) {
+      headers["Content-Type"] = "application/json";
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), options.timeout ?? DEFAULT_TIMEOUT_MS);
+    try {
+      const response = await fetch(url, {
+        method: options.method,
+        headers,
+        body: options.body ? JSON.stringify(options.body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (response.status === 429) {
+        const retryAfter = Number.parseInt(response.headers.get("Retry-After") ?? "60", 10);
+        throw new RateLimitError(retryAfter);
+      }
+      if (response.status === 204) {
+        return void 0;
+      }
+      const body = await response.json();
+      if (!response.ok) {
+        throw parseAPIError(response.status, body);
+      }
+      return body;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof ASCError) {
+        throw error;
+      }
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          throw new ASCError("Request timed out", "TIMEOUT", 408);
+        }
+        throw new ASCError(error.message, "NETWORK_ERROR", 0);
+      }
+      throw new ASCError("Unknown error occurred", "UNKNOWN", 0);
+    }
+  }
+  /**
+   * Build URL with query parameters
+   */
+  buildUrl(path2, params) {
+    const url = new URL(path2.startsWith("/") ? path2.slice(1) : path2, `${this.baseUrl}/`);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0) {
+          url.searchParams.append(key, String(value));
+        }
+      }
+    }
+    return url.toString();
+  }
+  /**
+   * Self-imposed rate limiting.
+   * Records the request timestamp before checking to prevent off-by-one errors.
+   */
+  async enforceRateLimit() {
+    const now = Date.now();
+    this.rateLimiter.timestamps = this.rateLimiter.timestamps.filter(
+      (ts) => now - ts < RATE_LIMIT_WINDOW_MS
+    );
+    if (this.rateLimiter.timestamps.length >= MAX_REQUESTS_PER_WINDOW) {
+      const oldestTimestamp = this.rateLimiter.timestamps[0];
+      if (oldestTimestamp) {
+        const waitTime = RATE_LIMIT_WINDOW_MS - (now - oldestTimestamp);
+        if (waitTime > 0) {
+          await this.sleep(waitTime);
+          const newNow = Date.now();
+          this.rateLimiter.timestamps = this.rateLimiter.timestamps.filter(
+            (ts) => newNow - ts < RATE_LIMIT_WINDOW_MS
+          );
+        }
+      }
+    }
+    this.rateLimiter.timestamps.push(Date.now());
+  }
+  /**
+   * Sleep helper
+   */
+  sleep(ms) {
+    return new Promise((resolve2) => setTimeout(resolve2, ms));
+  }
+};
+function createClient(tokenManager) {
+  return new AppStoreConnectClient(tokenManager);
+}
+
+// src/auth/jwt.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import { SignJWT, importPKCS8 } from "jose";
+var TOKEN_LIFETIME_SECONDS = 15 * 60;
+var TOKEN_REFRESH_BUFFER_SECONDS = 5 * 60;
+var AUDIENCE = "appstoreconnect-v1";
+var TokenManager = class {
+  keyId;
+  issuerId;
+  privateKeySource;
+  cachedToken = null;
+  tokenExpiresAt = 0;
+  privateKey = null;
+  pendingTokenGeneration = null;
+  constructor(config) {
+    this.keyId = config.keyId;
+    this.issuerId = config.issuerId;
+    if (config.privateKeyPath) {
+      if (config.privateKeyPath.includes("..")) {
+        throw new ConfigError("Private key path cannot contain '..'");
+      }
+      this.privateKeySource = { type: "path", path: config.privateKeyPath };
+    } else if (config.privateKeyContent) {
+      this.privateKeySource = { type: "content", content: config.privateKeyContent };
+    } else {
+      throw new ConfigError("Either privateKeyPath or privateKeyContent must be provided");
+    }
+  }
+  /**
+   * Get a valid JWT token, generating a new one if needed.
+   * Uses a pending promise pattern to prevent concurrent token generation.
+   */
+  async getToken() {
+    const now = Math.floor(Date.now() / 1e3);
+    if (this.cachedToken && this.tokenExpiresAt > now + TOKEN_REFRESH_BUFFER_SECONDS) {
+      return this.cachedToken;
+    }
+    if (this.pendingTokenGeneration) {
+      return this.pendingTokenGeneration;
+    }
+    this.pendingTokenGeneration = this.generateToken().finally(() => {
+      this.pendingTokenGeneration = null;
+    });
+    return this.pendingTokenGeneration;
+  }
+  /**
+   * Generate a new JWT token
+   */
+  async generateToken() {
+    const now = Math.floor(Date.now() / 1e3);
+    const expiresAt = now + TOKEN_LIFETIME_SECONDS;
+    if (!this.privateKey) {
+      await this.loadPrivateKey();
+    }
+    if (!this.privateKey) {
+      throw new AuthError("Failed to load private key");
+    }
+    try {
+      const jwt = await new SignJWT({}).setProtectedHeader({
+        alg: "ES256",
+        kid: this.keyId,
+        typ: "JWT"
+      }).setIssuer(this.issuerId).setIssuedAt(now).setExpirationTime(expiresAt).setAudience(AUDIENCE).sign(this.privateKey);
+      this.cachedToken = jwt;
+      this.tokenExpiresAt = expiresAt;
+      return jwt;
+    } catch (error) {
+      throw new AuthError(
+        `Failed to generate JWT: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Load the private key from file or content
+   */
+  async loadPrivateKey() {
+    let keyContent;
+    if (this.privateKeySource.type === "path") {
+      try {
+        const absolutePath = path.resolve(this.privateKeySource.path);
+        keyContent = await fs.readFile(absolutePath, "utf-8");
+      } catch (error) {
+        throw new ConfigError(
+          `Failed to read private key from ${this.privateKeySource.path}: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+      }
+    } else {
+      keyContent = this.privateKeySource.content;
+    }
+    keyContent = keyContent.trim();
+    if (!keyContent.startsWith("-----BEGIN")) {
+      keyContent = `-----BEGIN PRIVATE KEY-----
+${keyContent}
+-----END PRIVATE KEY-----`;
+    }
+    try {
+      this.privateKey = await importPKCS8(keyContent, "ES256");
+    } catch (error) {
+      throw new AuthError(
+        `Failed to parse private key: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Clear cached token (call on shutdown)
+   */
+  destroy() {
+    this.cachedToken = null;
+    this.tokenExpiresAt = 0;
+    this.privateKey = null;
+    this.pendingTokenGeneration = null;
+  }
+  /**
+   * Check if a token is currently cached and valid
+   */
+  hasValidToken() {
+    const now = Math.floor(Date.now() / 1e3);
+    return this.cachedToken !== null && this.tokenExpiresAt > now + TOKEN_REFRESH_BUFFER_SECONDS;
+  }
+};
+function createTokenManagerFromEnv() {
+  const keyId = process.env.APP_STORE_CONNECT_KEY_ID;
+  const issuerId = process.env.APP_STORE_CONNECT_ISSUER_ID;
+  const privateKeyPath = process.env.APP_STORE_CONNECT_P8_PATH;
+  const privateKeyContent = process.env.APP_STORE_CONNECT_P8_CONTENT;
+  if (!keyId) {
+    throw new ConfigError("APP_STORE_CONNECT_KEY_ID environment variable is required");
+  }
+  if (!issuerId) {
+    throw new ConfigError("APP_STORE_CONNECT_ISSUER_ID environment variable is required");
+  }
+  if (!privateKeyPath && !privateKeyContent) {
+    throw new ConfigError(
+      "Either APP_STORE_CONNECT_P8_PATH or APP_STORE_CONNECT_P8_CONTENT environment variable is required"
+    );
+  }
+  return new TokenManager({
+    keyId,
+    issuerId,
+    privateKeyPath,
+    privateKeyContent
+  });
+}
+
+// src/utils/validation.ts
+import { z } from "zod";
+var appIdSchema = z.string().regex(/^\d+$/, "App ID must be a numeric string").min(1, "App ID is required");
+var versionIdSchema = z.string().regex(/^\d+$/, "Version ID must be a numeric string").min(1, "Version ID is required");
+var localizationIdSchema = z.string().regex(/^\d+$/, "Localization ID must be a numeric string").min(1, "Localization ID is required");
+var buildIdSchema = z.string().min(1, "Build ID is required");
+var betaGroupIdSchema = z.string().min(1, "Beta Group ID is required");
+var localeSchema = z.string().regex(
+  /^[a-z]{2}([-_][A-Z][a-z]{3})?([-_][A-Z]{2})?$/,
+  "Invalid locale format (e.g., en-US, en_US, ja, zh-Hans)"
+).min(2, "Locale is required");
+var urlSchema = z.string().url("Must be a valid URL").refine((url) => url.startsWith("https://"), "URL must use HTTPS");
+var optionalUrlSchema = urlSchema.optional();
+var versionStringSchema = z.string().regex(/^(0|[1-9]\d*)(\.(0|[1-9]\d*))*$/, "Invalid version format (e.g., 1.0.0)").min(1, "Version string is required");
+var platformSchema = z.enum(["IOS", "MAC_OS", "TV_OS", "VISION_OS"]);
+var versionStateSchema = z.enum([
+  "DEVELOPER_REMOVED_FROM_SALE",
+  "DEVELOPER_REJECTED",
+  "IN_REVIEW",
+  "INVALID_BINARY",
+  "METADATA_REJECTED",
+  "PENDING_APPLE_RELEASE",
+  "PENDING_CONTRACT",
+  "PENDING_DEVELOPER_RELEASE",
+  "PREPARE_FOR_SUBMISSION",
+  "PREORDER_READY_FOR_SALE",
+  "PROCESSING_FOR_APP_STORE",
+  "READY_FOR_REVIEW",
+  "READY_FOR_SALE",
+  "REJECTED",
+  "REMOVED_FROM_SALE",
+  "WAITING_FOR_EXPORT_COMPLIANCE",
+  "WAITING_FOR_REVIEW",
+  "REPLACED_WITH_NEW_VERSION",
+  "NOT_APPLICABLE"
+]);
+var releaseTypeSchema = z.enum(["MANUAL", "AFTER_APPROVAL", "SCHEDULED"]);
+var paginationSchema = z.object({
+  limit: z.number().int().min(1).max(200).optional().default(50),
+  cursor: z.string().optional()
+});
+var listAppsInputSchema = z.object({
+  limit: z.number().int().min(1).max(200).optional()
+});
+var getAppInputSchema = z.object({
+  appId: appIdSchema
+});
+var listAppVersionsInputSchema = z.object({
+  appId: appIdSchema,
+  platform: platformSchema.optional(),
+  versionState: versionStateSchema.optional(),
+  limit: z.number().int().min(1).max(200).optional()
+});
+var getAppVersionInputSchema = z.object({
+  versionId: versionIdSchema
+});
+var createAppVersionInputSchema = z.object({
+  appId: appIdSchema,
+  platform: platformSchema,
+  versionString: versionStringSchema,
+  releaseType: releaseTypeSchema.optional(),
+  copyright: z.string().optional(),
+  earliestReleaseDate: z.string().datetime().optional()
+});
+var listVersionLocalizationsInputSchema = z.object({
+  versionId: versionIdSchema,
+  limit: z.number().int().min(1).max(200).optional()
+});
+var getVersionLocalizationInputSchema = z.object({
+  localizationId: localizationIdSchema
+});
+var createVersionLocalizationInputSchema = z.object({
+  versionId: versionIdSchema,
+  locale: localeSchema,
+  description: z.string().max(4e3).optional(),
+  keywords: z.string().max(100).optional(),
+  whatsNew: z.string().max(4e3).optional(),
+  promotionalText: z.string().max(170).optional(),
+  marketingUrl: optionalUrlSchema,
+  supportUrl: optionalUrlSchema
+});
+var updateVersionLocalizationInputSchema = z.object({
+  localizationId: localizationIdSchema,
+  description: z.string().max(4e3).optional(),
+  keywords: z.string().max(100).optional(),
+  whatsNew: z.string().max(4e3).optional(),
+  promotionalText: z.string().max(170).optional(),
+  marketingUrl: optionalUrlSchema,
+  supportUrl: optionalUrlSchema
+});
+var deleteVersionLocalizationInputSchema = z.object({
+  localizationId: localizationIdSchema
+});
+var getAppInfosInputSchema = z.object({
+  appId: appIdSchema,
+  limit: z.number().int().min(1).max(200).optional()
+});
+var listAppInfoLocalizationsInputSchema = z.object({
+  appInfoId: z.string().min(1, "App Info ID is required"),
+  limit: z.number().int().min(1).max(200).optional()
+});
+var updateAppInfoLocalizationInputSchema = z.object({
+  localizationId: localizationIdSchema,
+  name: z.string().max(30).optional(),
+  subtitle: z.string().max(30).optional(),
+  privacyPolicyUrl: optionalUrlSchema,
+  privacyChoicesUrl: optionalUrlSchema,
+  privacyPolicyText: z.string().optional()
+});
+var listBetaGroupsInputSchema = z.object({
+  appId: appIdSchema,
+  limit: z.number().int().min(1).max(200).optional()
+});
+var listBetaTestersInputSchema = z.object({
+  betaGroupId: betaGroupIdSchema,
+  limit: z.number().int().min(1).max(200).optional()
+});
+var addBetaTesterInputSchema = z.object({
+  betaGroupId: betaGroupIdSchema,
+  email: z.string().email("Invalid email address"),
+  firstName: z.string().min(1).optional(),
+  lastName: z.string().min(1).optional()
+});
+var listScreenshotSetsInputSchema = z.object({
+  localizationId: localizationIdSchema,
+  limit: z.number().int().min(1).max(200).optional()
+});
+var listScreenshotsInputSchema = z.object({
+  screenshotSetId: z.string().min(1, "Screenshot Set ID is required"),
+  limit: z.number().int().min(1).max(200).optional()
+});
+var uploadScreenshotInputSchema = z.object({
+  screenshotSetId: z.string().min(1, "Screenshot Set ID is required"),
+  fileName: z.string().min(1, "File name is required"),
+  fileSize: z.number().int().positive("File size must be positive"),
+  filePath: z.string().min(1, "File path is required")
+});
+function validateInput(schema, input) {
+  const result = schema.safeParse(input);
+  if (!result.success) {
+    const firstError = result.error.errors[0];
+    const field = firstError?.path.join(".");
+    const message = firstError?.message ?? "Invalid input";
+    throw new ValidationError(message, field || void 0);
+  }
+  return result.data;
+}
+var bundleIdIdentifierSchema = z.string().regex(
+  /^[a-zA-Z][a-zA-Z0-9.-]*$/,
+  "Bundle ID must start with a letter and contain only letters, numbers, dots, and hyphens"
+).min(1, "Bundle ID identifier is required");
+var listBundleIdsInputSchema = z.object({
+  limit: z.number().int().min(1).max(200).optional(),
+  platform: platformSchema.optional()
+});
+var getBundleIdInputSchema = z.object({
+  bundleIdId: z.string().min(1, "Bundle ID ID is required")
+});
+var createBundleIdInputSchema = z.object({
+  identifier: bundleIdIdentifierSchema,
+  name: z.string().min(1, "Name is required").max(255, "Name must be 255 characters or less"),
+  platform: platformSchema
+});
+var updateBundleIdInputSchema = z.object({
+  bundleIdId: z.string().min(1, "Bundle ID ID is required"),
+  name: z.string().min(1, "Name is required").max(255, "Name must be 255 characters or less")
+});
+var deleteBundleIdInputSchema = z.object({
+  bundleIdId: z.string().min(1, "Bundle ID ID is required")
+});
+var deviceStatusSchema = z.enum(["ENABLED", "DISABLED"]);
+var listDevicesInputSchema = z.object({
+  limit: z.number().int().min(1).max(200).optional(),
+  platform: platformSchema.optional(),
+  status: deviceStatusSchema.optional()
+});
+var getDeviceInputSchema = z.object({
+  deviceId: z.string().min(1, "Device ID is required")
+});
+var userRoleSchema = z.enum([
+  "ADMIN",
+  "FINANCE",
+  "TECHNICAL",
+  "SALES",
+  "DEVELOPER",
+  "MARKETING",
+  "APP_MANAGER",
+  "CUSTOMER_SUPPORT",
+  "ACCESS_TO_REPORTS",
+  "READ_ONLY"
+]);
+var listUsersInputSchema = z.object({
+  limit: z.number().int().min(1).max(200).optional(),
+  roles: z.array(userRoleSchema).optional()
+});
+var getUserInputSchema = z.object({
+  userId: z.string().min(1, "User ID is required")
+});
+var betaTesterIdSchema = z.string().min(1, "Beta Tester ID is required");
+var removeBetaTesterInputSchema = z.object({
+  betaGroupId: betaGroupIdSchema,
+  betaTesterId: betaTesterIdSchema
+});
+var listBuildsInputSchema = z.object({
+  appId: appIdSchema,
+  limit: z.number().int().min(1).max(200).optional()
+});
+var getBuildInputSchema = z.object({
+  buildId: buildIdSchema
+});
+var listBetaTesterInvitationsInputSchema = z.object({
+  betaGroupId: betaGroupIdSchema,
+  limit: z.number().int().min(1).max(200).optional()
+});
+var listAppCategoriesInputSchema = z.object({
+  limit: z.number().int().min(1).max(200).optional(),
+  platform: platformSchema.optional()
+});
+var getAppPriceScheduleInputSchema = z.object({
+  appId: appIdSchema
+});
+var getAppAvailabilityInputSchema = z.object({
+  appId: appIdSchema
+});
+
+// src/tools/app-info.tools.ts
+async function listAppInfos(client, input) {
+  try {
+    const params = validateInput(getAppInfosInputSchema, input);
+    const response = await client.get(`/apps/${params.appId}/appInfos`, {
+      limit: params.limit,
+      "fields[appInfos]": "appStoreState,appStoreAgeRating"
+    });
+    return {
+      success: true,
+      data: response.data.map((info) => ({
+        id: info.id,
+        appStoreState: info.attributes.appStoreState,
+        appStoreAgeRating: info.attributes.appStoreAgeRating
+      })),
+      meta: {
+        total: response.meta?.paging?.total,
+        returned: response.data.length
+      }
+    };
+  } catch (error) {
+    return formatErrorResponse(error);
+  }
+}
+async function listAppInfoLocalizations(client, input) {
+  try {
+    const params = validateInput(listAppInfoLocalizationsInputSchema, input);
+    const response = await client.get(
+      `/appInfos/${params.appInfoId}/appInfoLocalizations`,
+      {
+        limit: params.limit,
+        "fields[appInfoLocalizations]": "locale,name,subtitle,privacyPolicyUrl,privacyChoicesUrl,privacyPolicyText"
+      }
+    );
+    return {
+      success: true,
+      data: response.data.map((loc) => ({
+        id: loc.id,
+        locale: loc.attributes.locale,
+        name: loc.attributes.name,
+        subtitle: loc.attributes.subtitle,
+        privacyPolicyUrl: loc.attributes.privacyPolicyUrl,
+        privacyChoicesUrl: loc.attributes.privacyChoicesUrl,
+        privacyPolicyText: loc.attributes.privacyPolicyText
+      })),
+      meta: {
+        total: response.meta?.paging?.total,
+        returned: response.data.length
+      }
+    };
+  } catch (error) {
+    return formatErrorResponse(error);
+  }
+}
+async function updateAppInfoLocalization(client, input) {
+  try {
+    const params = validateInput(updateAppInfoLocalizationInputSchema, input);
+    const requestBody = {
+      data: {
+        type: "appInfoLocalizations",
+        id: params.localizationId,
+        attributes: {
+          name: params.name,
+          subtitle: params.subtitle,
+          privacyPolicyUrl: params.privacyPolicyUrl,
+          privacyChoicesUrl: params.privacyChoicesUrl,
+          privacyPolicyText: params.privacyPolicyText
+        }
+      }
+    };
+    const response = await client.patch(
+      `/appInfoLocalizations/${params.localizationId}`,
+      requestBody
+    );
+    const loc = response.data;
+    return {
+      success: true,
+      data: {
+        id: loc.id,
+        locale: loc.attributes.locale,
+        name: loc.attributes.name,
+        subtitle: loc.attributes.subtitle,
+        privacyPolicyUrl: loc.attributes.privacyPolicyUrl,
+        privacyChoicesUrl: loc.attributes.privacyChoicesUrl,
+        privacyPolicyText: loc.attributes.privacyPolicyText
+      }
+    };
+  } catch (error) {
+    return formatErrorResponse(error);
+  }
+}
+var appInfoToolDefinitions = [
+  {
+    name: "list_app_infos",
+    description: "List app info records for an app. Use this to get the appInfoId needed for localization operations.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        appId: {
+          type: "string",
+          description: "The App Store Connect app ID"
+        },
+        limit: {
+          type: "number",
+          description: "Maximum number of results to return (1-200)",
+          minimum: 1,
+          maximum: 200
+        }
+      },
+      required: ["appId"]
+    }
+  },
+  {
+    name: "list_app_info_localizations",
+    description: "List all localizations for an app info. Returns app name, subtitle, and privacy policy info for each locale.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        appInfoId: {
+          type: "string",
+          description: "The App Info ID (get this from list_app_infos)"
+        },
+        limit: {
+          type: "number",
+          description: "Maximum number of localizations to return (1-200)",
+          minimum: 1,
+          maximum: 200
+        }
+      },
+      required: ["appInfoId"]
+    }
+  },
+  {
+    name: "update_app_info_localization",
+    description: "Update an app info localization. Use this to change app name, subtitle, or privacy policy URL for a locale.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        localizationId: {
+          type: "string",
+          description: "The app info localization ID to update"
+        },
+        name: {
+          type: "string",
+          description: "App name (max 30 characters)"
+        },
+        subtitle: {
+          type: "string",
+          description: "App subtitle (max 30 characters)"
+        },
+        privacyPolicyUrl: {
+          type: "string",
+          description: "Privacy policy URL (HTTPS only)"
+        },
+        privacyChoicesUrl: {
+          type: "string",
+          description: "Privacy choices URL (HTTPS only)"
+        },
+        privacyPolicyText: {
+          type: "string",
+          description: "Privacy policy text (for apps without a URL)"
+        }
+      },
+      required: ["localizationId"]
+    }
+  }
+];
+
+// src/tools/apps.tools.ts
+async function listApps(client, input) {
+  try {
+    const params = validateInput(listAppsInputSchema, input);
+    const response = await client.get("/apps", {
+      limit: params.limit,
+      "fields[apps]": "name,bundleId,sku,primaryLocale"
+    });
+    return {
+      success: true,
+      data: response.data.map((app) => ({
+        id: app.id,
+        name: app.attributes.name,
+        bundleId: app.attributes.bundleId,
+        sku: app.attributes.sku,
+        primaryLocale: app.attributes.primaryLocale
+      })),
+      meta: {
+        total: response.meta?.paging?.total,
+        returned: response.data.length
+      }
+    };
+  } catch (error) {
+    return formatErrorResponse(error);
+  }
+}
+async function getApp(client, input) {
+  try {
+    const params = validateInput(getAppInputSchema, input);
+    const response = await client.get(`/apps/${params.appId}`, {
+      "fields[apps]": "name,bundleId,sku,primaryLocale,contentRightsDeclaration,isOrEverWasMadeForKids",
+      include: "appInfos,appStoreVersions"
+    });
+    const app = response.data;
+    return {
+      success: true,
+      data: {
+        id: app.id,
+        name: app.attributes.name,
+        bundleId: app.attributes.bundleId,
+        sku: app.attributes.sku,
+        primaryLocale: app.attributes.primaryLocale,
+        contentRightsDeclaration: app.attributes.contentRightsDeclaration,
+        isOrEverWasMadeForKids: app.attributes.isOrEverWasMadeForKids
+      }
+    };
+  } catch (error) {
+    return formatErrorResponse(error);
+  }
+}
+var appsToolDefinitions = [
+  {
+    name: "list_apps",
+    description: "List all apps in your App Store Connect account. Returns app IDs, names, bundle IDs, and SKUs.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: {
+          type: "number",
+          description: "Maximum number of apps to return (1-200)",
+          minimum: 1,
+          maximum: 200
+        }
+      }
+    }
+  },
+  {
+    name: "get_app",
+    description: "Get detailed information about a specific app by its ID.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        appId: {
+          type: "string",
+          description: "The App Store Connect app ID (numeric string)"
+        }
+      },
+      required: ["appId"]
+    }
+  }
+];
+
+// src/tools/beta.tools.ts
+async function listBetaGroups(client, input) {
+  try {
+    const params = validateInput(listBetaGroupsInputSchema, input);
+    const response = await client.get(
+      `/apps/${params.appId}/betaGroups`,
+      {
+        limit: params.limit,
+        "fields[betaGroups]": "name,createdDate,isInternalGroup,hasAccessToAllBuilds,publicLinkEnabled,publicLink,feedbackEnabled"
+      }
+    );
+    return {
+      success: true,
+      data: response.data.map((group) => ({
+        id: group.id,
+        name: group.attributes.name,
+        createdDate: group.attributes.createdDate,
+        isInternalGroup: group.attributes.isInternalGroup,
+        hasAccessToAllBuilds: group.attributes.hasAccessToAllBuilds,
+        publicLinkEnabled: group.attributes.publicLinkEnabled,
+        publicLink: group.attributes.publicLink,
+        feedbackEnabled: group.attributes.feedbackEnabled
+      })),
+      meta: {
+        total: response.meta?.paging?.total,
+        returned: response.data.length
+      }
+    };
+  } catch (error) {
+    return formatErrorResponse(error);
+  }
+}
+async function listBetaTesters(client, input) {
+  try {
+    const params = validateInput(listBetaTestersInputSchema, input);
+    const response = await client.get(
+      `/betaGroups/${params.betaGroupId}/betaTesters`,
+      {
+        limit: params.limit,
+        "fields[betaTesters]": "firstName,lastName,email,inviteType,state"
+      }
+    );
+    return {
+      success: true,
+      data: response.data.map((tester) => ({
+        id: tester.id,
+        firstName: tester.attributes.firstName,
+        lastName: tester.attributes.lastName,
+        email: tester.attributes.email,
+        inviteType: tester.attributes.inviteType,
+        state: tester.attributes.state
+      })),
+      meta: {
+        total: response.meta?.paging?.total,
+        returned: response.data.length
+      }
+    };
+  } catch (error) {
+    return formatErrorResponse(error);
+  }
+}
+async function addBetaTester(client, input) {
+  try {
+    const params = validateInput(addBetaTesterInputSchema, input);
+    const requestBody = {
+      data: {
+        type: "betaTesters",
+        attributes: {
+          email: params.email,
+          firstName: params.firstName,
+          lastName: params.lastName
+        },
+        relationships: {
+          betaGroups: {
+            data: [
+              {
+                type: "betaGroups",
+                id: params.betaGroupId
+              }
+            ]
+          }
+        }
+      }
+    };
+    const response = await client.post("/betaTesters", requestBody);
+    const tester = response.data;
+    return {
+      success: true,
+      data: {
+        id: tester.id,
+        firstName: tester.attributes.firstName,
+        lastName: tester.attributes.lastName,
+        email: tester.attributes.email,
+        inviteType: tester.attributes.inviteType,
+        state: tester.attributes.state
+      }
+    };
+  } catch (error) {
+    return formatErrorResponse(error);
+  }
+}
+async function removeBetaTester(client, input) {
+  try {
+    const params = validateInput(removeBetaTesterInputSchema, input);
+    const requestBody = {
+      data: [
+        {
+          type: "betaTesters",
+          id: params.betaTesterId
+        }
+      ]
+    };
+    await client.delete(`/betaGroups/${params.betaGroupId}/relationships/betaTesters`, requestBody);
+    return {
+      success: true,
+      data: {
+        removed: true,
+        betaGroupId: params.betaGroupId,
+        betaTesterId: params.betaTesterId
+      }
+    };
+  } catch (error) {
+    return formatErrorResponse(error);
+  }
+}
+var betaToolDefinitions = [
+  {
+    name: "list_beta_groups",
+    description: "List all beta groups for an app. Returns group names, public link info, and settings.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        appId: {
+          type: "string",
+          description: "The App Store Connect app ID"
+        },
+        limit: {
+          type: "number",
+          description: "Maximum number of groups to return (1-200)",
+          minimum: 1,
+          maximum: 200
+        }
+      },
+      required: ["appId"]
+    }
+  },
+  {
+    name: "list_beta_testers",
+    description: "List all beta testers in a specific beta group.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        betaGroupId: {
+          type: "string",
+          description: "The beta group ID"
+        },
+        limit: {
+          type: "number",
+          description: "Maximum number of testers to return (1-200)",
+          minimum: 1,
+          maximum: 200
+        }
+      },
+      required: ["betaGroupId"]
+    }
+  },
+  {
+    name: "add_beta_tester",
+    description: "Add a new beta tester to a beta group by email address.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        betaGroupId: {
+          type: "string",
+          description: "The beta group ID to add the tester to"
+        },
+        email: {
+          type: "string",
+          description: "Email address of the beta tester"
+        },
+        firstName: {
+          type: "string",
+          description: "First name of the beta tester (optional)"
+        },
+        lastName: {
+          type: "string",
+          description: "Last name of the beta tester (optional)"
+        }
+      },
+      required: ["betaGroupId", "email"]
+    }
+  },
+  {
+    name: "remove_beta_tester",
+    description: "Remove a beta tester from a beta group.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        betaGroupId: {
+          type: "string",
+          description: "The beta group ID to remove the tester from"
+        },
+        betaTesterId: {
+          type: "string",
+          description: "The beta tester ID to remove"
+        }
+      },
+      required: ["betaGroupId", "betaTesterId"]
+    }
+  }
+];
+
+// src/tools/builds.tools.ts
+async function listBuilds(client, input) {
+  try {
+    const params = validateInput(listBuildsInputSchema, input);
+    const response = await client.get(`/apps/${params.appId}/builds`, {
+      limit: params.limit,
+      "fields[builds]": "version,uploadedDate,expirationDate,expired,minOsVersion,processingState,buildAudienceType,usesNonExemptEncryption",
+      sort: "-uploadedDate"
+    });
+    return {
+      success: true,
+      data: response.data.map((build) => ({
+        id: build.id,
+        version: build.attributes.version,
+        uploadedDate: build.attributes.uploadedDate,
+        expirationDate: build.attributes.expirationDate,
+        expired: build.attributes.expired,
+        minOsVersion: build.attributes.minOsVersion,
+        processingState: build.attributes.processingState,
+        buildAudienceType: build.attributes.buildAudienceType,
+        usesNonExemptEncryption: build.attributes.usesNonExemptEncryption
+      })),
+      meta: {
+        total: response.meta?.paging?.total,
+        returned: response.data.length
+      }
+    };
+  } catch (error) {
+    return formatErrorResponse(error);
+  }
+}
+async function getBuild(client, input) {
+  try {
+    const params = validateInput(getBuildInputSchema, input);
+    const response = await client.get(`/builds/${params.buildId}`, {
+      "fields[builds]": "version,uploadedDate,expirationDate,expired,minOsVersion,processingState,buildAudienceType,usesNonExemptEncryption"
+    });
+    const build = response.data;
+    return {
+      success: true,
+      data: {
+        id: build.id,
+        version: build.attributes.version,
+        uploadedDate: build.attributes.uploadedDate,
+        expirationDate: build.attributes.expirationDate,
+        expired: build.attributes.expired,
+        minOsVersion: build.attributes.minOsVersion,
+        processingState: build.attributes.processingState,
+        buildAudienceType: build.attributes.buildAudienceType,
+        usesNonExemptEncryption: build.attributes.usesNonExemptEncryption
+      }
+    };
+  } catch (error) {
+    return formatErrorResponse(error);
+  }
+}
+async function listBetaTesterInvitations(client, input) {
+  try {
+    const params = validateInput(listBetaTesterInvitationsInputSchema, input);
+    const response = await client.get(
+      `/betaGroups/${params.betaGroupId}/betaTesterInvitations`,
+      {
+        limit: params.limit
+      }
+    );
+    return {
+      success: true,
+      data: response.data.map((invitation) => ({
+        id: invitation.id
+      })),
+      meta: {
+        total: response.meta?.paging?.total,
+        returned: response.data.length
+      }
+    };
+  } catch (error) {
+    return formatErrorResponse(error);
+  }
+}
+var buildsToolDefinitions = [
+  {
+    name: "list_builds",
+    description: "List all builds for an app, sorted by upload date (newest first).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        appId: {
+          type: "string",
+          description: "The App Store Connect app ID"
+        },
+        limit: {
+          type: "number",
+          description: "Maximum number of builds to return (1-200)",
+          minimum: 1,
+          maximum: 200
+        }
+      },
+      required: ["appId"]
+    }
+  },
+  {
+    name: "get_build",
+    description: "Get details of a specific build.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        buildId: {
+          type: "string",
+          description: "The build resource ID"
+        }
+      },
+      required: ["buildId"]
+    }
+  },
+  {
+    name: "list_beta_tester_invitations",
+    description: "List pending beta tester invitations for a beta group.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        betaGroupId: {
+          type: "string",
+          description: "The beta group ID"
+        },
+        limit: {
+          type: "number",
+          description: "Maximum number of invitations to return (1-200)",
+          minimum: 1,
+          maximum: 200
+        }
+      },
+      required: ["betaGroupId"]
+    }
+  }
+];
+
+// src/tools/bundle-ids.tools.ts
+async function listBundleIds(client, input) {
+  try {
+    const params = validateInput(listBundleIdsInputSchema, input);
+    const queryParams = {
+      limit: params.limit,
+      "fields[bundleIds]": "name,identifier,platform,seedId"
+    };
+    if (params.platform) {
+      queryParams["filter[platform]"] = params.platform;
+    }
+    const response = await client.get("/bundleIds", queryParams);
+    return {
+      success: true,
+      data: response.data.map((bundleId) => ({
+        id: bundleId.id,
+        name: bundleId.attributes.name,
+        identifier: bundleId.attributes.identifier,
+        platform: bundleId.attributes.platform,
+        seedId: bundleId.attributes.seedId
+      })),
+      meta: {
+        total: response.meta?.paging?.total,
+        returned: response.data.length
+      }
+    };
+  } catch (error) {
+    return formatErrorResponse(error);
+  }
+}
+async function getBundleId(client, input) {
+  try {
+    const params = validateInput(getBundleIdInputSchema, input);
+    const response = await client.get(`/bundleIds/${params.bundleIdId}`, {
+      "fields[bundleIds]": "name,identifier,platform,seedId"
+    });
+    const bundleId = response.data;
+    return {
+      success: true,
+      data: {
+        id: bundleId.id,
+        name: bundleId.attributes.name,
+        identifier: bundleId.attributes.identifier,
+        platform: bundleId.attributes.platform,
+        seedId: bundleId.attributes.seedId
+      }
+    };
+  } catch (error) {
+    return formatErrorResponse(error);
+  }
+}
+async function createBundleId(client, input) {
+  try {
+    const params = validateInput(createBundleIdInputSchema, input);
+    const requestBody = {
+      data: {
+        type: "bundleIds",
+        attributes: {
+          identifier: params.identifier,
+          name: params.name,
+          platform: params.platform
+        }
+      }
+    };
+    const response = await client.post("/bundleIds", requestBody);
+    const bundleId = response.data;
+    return {
+      success: true,
+      data: {
+        id: bundleId.id,
+        name: bundleId.attributes.name,
+        identifier: bundleId.attributes.identifier,
+        platform: bundleId.attributes.platform,
+        seedId: bundleId.attributes.seedId
+      }
+    };
+  } catch (error) {
+    return formatErrorResponse(error);
+  }
+}
+async function updateBundleId(client, input) {
+  try {
+    const params = validateInput(updateBundleIdInputSchema, input);
+    const requestBody = {
+      data: {
+        type: "bundleIds",
+        id: params.bundleIdId,
+        attributes: {
+          name: params.name
+        }
+      }
+    };
+    const response = await client.patch(
+      `/bundleIds/${params.bundleIdId}`,
+      requestBody
+    );
+    const bundleId = response.data;
+    return {
+      success: true,
+      data: {
+        id: bundleId.id,
+        name: bundleId.attributes.name,
+        identifier: bundleId.attributes.identifier,
+        platform: bundleId.attributes.platform,
+        seedId: bundleId.attributes.seedId
+      }
+    };
+  } catch (error) {
+    return formatErrorResponse(error);
+  }
+}
+async function deleteBundleId(client, input) {
+  try {
+    const params = validateInput(deleteBundleIdInputSchema, input);
+    await client.delete(`/bundleIds/${params.bundleIdId}`);
+    return {
+      success: true,
+      data: {
+        deleted: true,
+        bundleIdId: params.bundleIdId
+      }
+    };
+  } catch (error) {
+    return formatErrorResponse(error);
+  }
+}
+var bundleIdsToolDefinitions = [
+  {
+    name: "list_bundle_ids",
+    description: "List all bundle IDs registered in App Store Connect. Can filter by platform.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: {
+          type: "number",
+          description: "Maximum number of bundle IDs to return (1-200)",
+          minimum: 1,
+          maximum: 200
+        },
+        platform: {
+          type: "string",
+          enum: ["IOS", "MAC_OS", "TV_OS", "VISION_OS"],
+          description: "Filter by platform"
+        }
+      },
+      required: []
+    }
+  },
+  {
+    name: "get_bundle_id",
+    description: "Get details of a specific bundle ID.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        bundleIdId: {
+          type: "string",
+          description: "The bundle ID resource ID"
+        }
+      },
+      required: ["bundleIdId"]
+    }
+  },
+  {
+    name: "create_bundle_id",
+    description: "Register a new bundle ID in App Store Connect. The identifier must be unique and follow reverse-domain notation (e.g., com.example.app).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        identifier: {
+          type: "string",
+          description: "The bundle identifier (e.g., com.example.app)"
+        },
+        name: {
+          type: "string",
+          description: "A name for the bundle ID"
+        },
+        platform: {
+          type: "string",
+          enum: ["IOS", "MAC_OS", "TV_OS", "VISION_OS"],
+          description: "The platform for this bundle ID"
+        }
+      },
+      required: ["identifier", "name", "platform"]
+    }
+  },
+  {
+    name: "update_bundle_id",
+    description: "Update a bundle ID's name. Note: The identifier cannot be changed.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        bundleIdId: {
+          type: "string",
+          description: "The bundle ID resource ID"
+        },
+        name: {
+          type: "string",
+          description: "The new name for the bundle ID"
+        }
+      },
+      required: ["bundleIdId", "name"]
+    }
+  },
+  {
+    name: "delete_bundle_id",
+    description: "Delete a bundle ID. Note: This cannot be undone and may affect apps using this bundle ID.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        bundleIdId: {
+          type: "string",
+          description: "The bundle ID resource ID to delete"
+        }
+      },
+      required: ["bundleIdId"]
+    }
+  }
+];
+
+// src/tools/categories.tools.ts
+async function listAppCategories(client, input) {
+  try {
+    const params = validateInput(listAppCategoriesInputSchema, input);
+    const queryParams = {
+      limit: params.limit,
+      "fields[appCategories]": "platforms",
+      include: "subcategories"
+    };
+    if (params.platform) {
+      queryParams["filter[platforms]"] = params.platform;
+    }
+    const response = await client.get("/appCategories", queryParams);
+    const included = response.included ?? [];
+    const subcategoriesMap = /* @__PURE__ */ new Map();
+    for (const sub of included) {
+      if (sub.type === "appCategories") {
+        subcategoriesMap.set(sub.id, sub);
+      }
+    }
+    return {
+      success: true,
+      data: response.data.map((category) => {
+        const subcategoryData = category.relationships?.subcategories?.data;
+        const subcategoryIds = Array.isArray(subcategoryData) ? subcategoryData.map((s) => s.id) : [];
+        return {
+          id: category.id,
+          platforms: category.attributes.platforms,
+          subcategories: subcategoryIds.map((id) => {
+            const sub = subcategoriesMap.get(id);
+            return sub ? {
+              id: sub.id,
+              platforms: sub.attributes.platforms
+            } : { id };
+          })
+        };
+      }),
+      meta: {
+        total: response.meta?.paging?.total,
+        returned: response.data.length
+      }
+    };
+  } catch (error) {
+    return formatErrorResponse(error);
+  }
+}
+async function getAppPriceSchedule(client, input) {
+  try {
+    const params = validateInput(getAppPriceScheduleInputSchema, input);
+    const response = await client.get(
+      `/apps/${params.appId}/appPriceSchedule`,
+      {
+        include: "baseTerritory,manualPrices,automaticPrices"
+      }
+    );
+    const schedule = response.data;
+    const included = response.included ?? [];
+    let baseTerritory;
+    const baseTerritoryData = schedule.relationships?.baseTerritory?.data;
+    if (baseTerritoryData && !Array.isArray(baseTerritoryData)) {
+      const territory = included.find(
+        (item) => item.type === "territories" && item.id === baseTerritoryData.id
+      );
+      if (territory) {
+        baseTerritory = {
+          id: territory.id,
+          currency: territory.attributes.currency
+        };
+      }
+    }
+    return {
+      success: true,
+      data: {
+        id: schedule.id,
+        baseTerritory,
+        hasManualPrices: schedule.relationships?.manualPrices?.data !== void 0 && (Array.isArray(schedule.relationships.manualPrices.data) ? schedule.relationships.manualPrices.data.length > 0 : true),
+        hasAutomaticPrices: schedule.relationships?.automaticPrices?.data !== void 0 && (Array.isArray(schedule.relationships.automaticPrices.data) ? schedule.relationships.automaticPrices.data.length > 0 : true)
+      }
+    };
+  } catch (error) {
+    return formatErrorResponse(error);
+  }
+}
+async function getAppAvailability(client, input) {
+  try {
+    const params = validateInput(getAppAvailabilityInputSchema, input);
+    const response = await client.get(
+      `/apps/${params.appId}/appAvailability`,
+      {
+        include: "availableTerritories",
+        "fields[territories]": "currency"
+      }
+    );
+    const availability = response.data;
+    const included = response.included ?? [];
+    const territories = included.filter((item) => item.type === "territories").map((territory) => ({
+      id: territory.id,
+      currency: territory.attributes.currency
+    }));
+    return {
+      success: true,
+      data: {
+        id: availability.id,
+        availableInNewTerritories: availability.attributes.availableInNewTerritories,
+        territories,
+        territoryCount: territories.length
+      }
+    };
+  } catch (error) {
+    return formatErrorResponse(error);
+  }
+}
+var categoriesToolDefinitions = [
+  {
+    name: "list_app_categories",
+    description: "List all app categories available in the App Store. Can filter by platform.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: {
+          type: "number",
+          description: "Maximum number of categories to return (1-200)",
+          minimum: 1,
+          maximum: 200
+        },
+        platform: {
+          type: "string",
+          enum: ["IOS", "MAC_OS", "TV_OS", "VISION_OS"],
+          description: "Filter by platform"
+        }
+      },
+      required: []
+    }
+  },
+  {
+    name: "get_app_price_schedule",
+    description: "Get the price schedule for an app, including pricing information.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        appId: {
+          type: "string",
+          description: "The App Store Connect app ID"
+        }
+      },
+      required: ["appId"]
+    }
+  },
+  {
+    name: "get_app_availability",
+    description: "Get app availability information, including which territories the app is available in.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        appId: {
+          type: "string",
+          description: "The App Store Connect app ID"
+        }
+      },
+      required: ["appId"]
+    }
+  }
+];
+
+// src/tools/devices.tools.ts
+async function listDevices(client, input) {
+  try {
+    const params = validateInput(listDevicesInputSchema, input);
+    const queryParams = {
+      limit: params.limit,
+      "fields[devices]": "name,platform,udid,deviceClass,status,model,addedDate"
+    };
+    if (params.platform) {
+      queryParams["filter[platform]"] = params.platform;
+    }
+    if (params.status) {
+      queryParams["filter[status]"] = params.status;
+    }
+    const response = await client.get("/devices", queryParams);
+    return {
+      success: true,
+      data: response.data.map((device) => ({
+        id: device.id,
+        name: device.attributes.name,
+        platform: device.attributes.platform,
+        udid: device.attributes.udid,
+        deviceClass: device.attributes.deviceClass,
+        status: device.attributes.status,
+        model: device.attributes.model,
+        addedDate: device.attributes.addedDate
+      })),
+      meta: {
+        total: response.meta?.paging?.total,
+        returned: response.data.length
+      }
+    };
+  } catch (error) {
+    return formatErrorResponse(error);
+  }
+}
+async function getDevice(client, input) {
+  try {
+    const params = validateInput(getDeviceInputSchema, input);
+    const response = await client.get(`/devices/${params.deviceId}`, {
+      "fields[devices]": "name,platform,udid,deviceClass,status,model,addedDate"
+    });
+    const device = response.data;
+    return {
+      success: true,
+      data: {
+        id: device.id,
+        name: device.attributes.name,
+        platform: device.attributes.platform,
+        udid: device.attributes.udid,
+        deviceClass: device.attributes.deviceClass,
+        status: device.attributes.status,
+        model: device.attributes.model,
+        addedDate: device.attributes.addedDate
+      }
+    };
+  } catch (error) {
+    return formatErrorResponse(error);
+  }
+}
+var devicesToolDefinitions = [
+  {
+    name: "list_devices",
+    description: "List all registered devices in App Store Connect. Can filter by platform and status.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: {
+          type: "number",
+          description: "Maximum number of devices to return (1-200)",
+          minimum: 1,
+          maximum: 200
+        },
+        platform: {
+          type: "string",
+          enum: ["IOS", "MAC_OS", "TV_OS", "VISION_OS"],
+          description: "Filter by platform"
+        },
+        status: {
+          type: "string",
+          enum: ["ENABLED", "DISABLED"],
+          description: "Filter by device status"
+        }
+      },
+      required: []
+    }
+  },
+  {
+    name: "get_device",
+    description: "Get details of a specific registered device.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        deviceId: {
+          type: "string",
+          description: "The device resource ID"
+        }
+      },
+      required: ["deviceId"]
+    }
+  }
+];
+
+// src/tools/localizations.tools.ts
+async function listVersionLocalizations(client, input) {
+  try {
+    const params = validateInput(listVersionLocalizationsInputSchema, input);
+    const response = await client.get(
+      `/appStoreVersions/${params.versionId}/appStoreVersionLocalizations`,
+      {
+        limit: params.limit,
+        "fields[appStoreVersionLocalizations]": "locale,description,keywords,marketingUrl,promotionalText,supportUrl,whatsNew"
+      }
+    );
+    return {
+      success: true,
+      data: response.data.map((loc) => ({
+        id: loc.id,
+        locale: loc.attributes.locale,
+        description: loc.attributes.description,
+        keywords: loc.attributes.keywords,
+        marketingUrl: loc.attributes.marketingUrl,
+        promotionalText: loc.attributes.promotionalText,
+        supportUrl: loc.attributes.supportUrl,
+        whatsNew: loc.attributes.whatsNew
+      })),
+      meta: {
+        total: response.meta?.paging?.total,
+        returned: response.data.length
+      }
+    };
+  } catch (error) {
+    return formatErrorResponse(error);
+  }
+}
+async function getVersionLocalization(client, input) {
+  try {
+    const params = validateInput(getVersionLocalizationInputSchema, input);
+    const response = await client.get(
+      `/appStoreVersionLocalizations/${params.localizationId}`,
+      {
+        "fields[appStoreVersionLocalizations]": "locale,description,keywords,marketingUrl,promotionalText,supportUrl,whatsNew"
+      }
+    );
+    const loc = response.data;
+    return {
+      success: true,
+      data: {
+        id: loc.id,
+        locale: loc.attributes.locale,
+        description: loc.attributes.description,
+        keywords: loc.attributes.keywords,
+        marketingUrl: loc.attributes.marketingUrl,
+        promotionalText: loc.attributes.promotionalText,
+        supportUrl: loc.attributes.supportUrl,
+        whatsNew: loc.attributes.whatsNew
+      }
+    };
+  } catch (error) {
+    return formatErrorResponse(error);
+  }
+}
+async function createVersionLocalization(client, input) {
+  try {
+    const params = validateInput(createVersionLocalizationInputSchema, input);
+    const requestBody = {
+      data: {
+        type: "appStoreVersionLocalizations",
+        attributes: {
+          locale: params.locale,
+          description: params.description,
+          keywords: params.keywords,
+          marketingUrl: params.marketingUrl,
+          promotionalText: params.promotionalText,
+          supportUrl: params.supportUrl,
+          whatsNew: params.whatsNew
+        },
+        relationships: {
+          appStoreVersion: {
+            data: {
+              type: "appStoreVersions",
+              id: params.versionId
+            }
+          }
+        }
+      }
+    };
+    const response = await client.post(
+      "/appStoreVersionLocalizations",
+      requestBody
+    );
+    const loc = response.data;
+    return {
+      success: true,
+      data: {
+        id: loc.id,
+        locale: loc.attributes.locale,
+        description: loc.attributes.description,
+        keywords: loc.attributes.keywords,
+        marketingUrl: loc.attributes.marketingUrl,
+        promotionalText: loc.attributes.promotionalText,
+        supportUrl: loc.attributes.supportUrl,
+        whatsNew: loc.attributes.whatsNew
+      }
+    };
+  } catch (error) {
+    return formatErrorResponse(error);
+  }
+}
+async function updateVersionLocalization(client, input) {
+  try {
+    const params = validateInput(updateVersionLocalizationInputSchema, input);
+    const requestBody = {
+      data: {
+        type: "appStoreVersionLocalizations",
+        id: params.localizationId,
+        attributes: {
+          description: params.description,
+          keywords: params.keywords,
+          marketingUrl: params.marketingUrl,
+          promotionalText: params.promotionalText,
+          supportUrl: params.supportUrl,
+          whatsNew: params.whatsNew
+        }
+      }
+    };
+    const response = await client.patch(
+      `/appStoreVersionLocalizations/${params.localizationId}`,
+      requestBody
+    );
+    const loc = response.data;
+    return {
+      success: true,
+      data: {
+        id: loc.id,
+        locale: loc.attributes.locale,
+        description: loc.attributes.description,
+        keywords: loc.attributes.keywords,
+        marketingUrl: loc.attributes.marketingUrl,
+        promotionalText: loc.attributes.promotionalText,
+        supportUrl: loc.attributes.supportUrl,
+        whatsNew: loc.attributes.whatsNew
+      }
+    };
+  } catch (error) {
+    return formatErrorResponse(error);
+  }
+}
+async function deleteVersionLocalization(client, input) {
+  try {
+    const params = validateInput(deleteVersionLocalizationInputSchema, input);
+    await client.delete(`/appStoreVersionLocalizations/${params.localizationId}`);
+    return {
+      success: true,
+      data: {
+        deleted: true,
+        localizationId: params.localizationId
+      }
+    };
+  } catch (error) {
+    return formatErrorResponse(error);
+  }
+}
+var localizationsToolDefinitions = [
+  {
+    name: "list_version_localizations",
+    description: "List all localizations for an App Store version. Returns description, keywords, what's new, and URLs for each locale.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        versionId: {
+          type: "string",
+          description: "The App Store version ID"
+        },
+        limit: {
+          type: "number",
+          description: "Maximum number of localizations to return (1-200)",
+          minimum: 1,
+          maximum: 200
+        }
+      },
+      required: ["versionId"]
+    }
+  },
+  {
+    name: "get_version_localization",
+    description: "Get detailed information about a specific version localization.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        localizationId: {
+          type: "string",
+          description: "The localization ID"
+        }
+      },
+      required: ["localizationId"]
+    }
+  },
+  {
+    name: "create_version_localization",
+    description: "Create a new localization for an App Store version. Add descriptions, keywords, and other metadata in a specific locale.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        versionId: {
+          type: "string",
+          description: "The App Store version ID"
+        },
+        locale: {
+          type: "string",
+          description: "Locale code (e.g., 'en-US', 'ja', 'zh-Hans')"
+        },
+        description: {
+          type: "string",
+          description: "App description (max 4000 characters)"
+        },
+        keywords: {
+          type: "string",
+          description: "Keywords for search (max 100 characters, comma-separated)"
+        },
+        whatsNew: {
+          type: "string",
+          description: "What's new in this version (max 4000 characters)"
+        },
+        promotionalText: {
+          type: "string",
+          description: "Promotional text (max 170 characters)"
+        },
+        marketingUrl: {
+          type: "string",
+          description: "Marketing URL (HTTPS only)"
+        },
+        supportUrl: {
+          type: "string",
+          description: "Support URL (HTTPS only)"
+        }
+      },
+      required: ["versionId", "locale"]
+    }
+  },
+  {
+    name: "update_version_localization",
+    description: "Update an existing version localization. Only provided fields will be updated.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        localizationId: {
+          type: "string",
+          description: "The localization ID to update"
+        },
+        description: {
+          type: "string",
+          description: "App description (max 4000 characters)"
+        },
+        keywords: {
+          type: "string",
+          description: "Keywords for search (max 100 characters, comma-separated)"
+        },
+        whatsNew: {
+          type: "string",
+          description: "What's new in this version (max 4000 characters)"
+        },
+        promotionalText: {
+          type: "string",
+          description: "Promotional text (max 170 characters)"
+        },
+        marketingUrl: {
+          type: "string",
+          description: "Marketing URL (HTTPS only)"
+        },
+        supportUrl: {
+          type: "string",
+          description: "Support URL (HTTPS only)"
+        }
+      },
+      required: ["localizationId"]
+    }
+  },
+  {
+    name: "delete_version_localization",
+    description: "Delete a version localization. Cannot delete the primary locale.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        localizationId: {
+          type: "string",
+          description: "The localization ID to delete"
+        }
+      },
+      required: ["localizationId"]
+    }
+  }
+];
+
+// src/tools/screenshots.tools.ts
+import * as crypto from "crypto";
+import * as fs2 from "fs/promises";
+async function listScreenshotSets(client, input) {
+  try {
+    const params = validateInput(listScreenshotSetsInputSchema, input);
+    const response = await client.get(
+      `/appStoreVersionLocalizations/${params.localizationId}/appScreenshotSets`,
+      {
+        limit: params.limit,
+        "fields[appScreenshotSets]": "screenshotDisplayType"
+      }
+    );
+    return {
+      success: true,
+      data: response.data.map((set) => ({
+        id: set.id,
+        screenshotDisplayType: set.attributes.screenshotDisplayType
+      })),
+      meta: {
+        total: response.meta?.paging?.total,
+        returned: response.data.length
+      }
+    };
+  } catch (error) {
+    return formatErrorResponse(error);
+  }
+}
+async function listScreenshots(client, input) {
+  try {
+    const params = validateInput(listScreenshotsInputSchema, input);
+    const response = await client.get(
+      `/appScreenshotSets/${params.screenshotSetId}/appScreenshots`,
+      {
+        limit: params.limit,
+        "fields[appScreenshots]": "fileSize,fileName,sourceFileChecksum,imageAsset,assetDeliveryState"
+      }
+    );
+    return {
+      success: true,
+      data: response.data.map((screenshot) => ({
+        id: screenshot.id,
+        fileName: screenshot.attributes.fileName,
+        fileSize: screenshot.attributes.fileSize,
+        sourceFileChecksum: screenshot.attributes.sourceFileChecksum,
+        imageAsset: screenshot.attributes.imageAsset,
+        assetDeliveryState: screenshot.attributes.assetDeliveryState
+      })),
+      meta: {
+        total: response.meta?.paging?.total,
+        returned: response.data.length
+      }
+    };
+  } catch (error) {
+    return formatErrorResponse(error);
+  }
+}
+async function uploadScreenshot(client, input) {
+  try {
+    const params = validateInput(uploadScreenshotInputSchema, input);
+    let fileBuffer;
+    try {
+      fileBuffer = await fs2.readFile(params.filePath);
+    } catch (_error) {
+      throw new ASCError(`Failed to read file: ${params.filePath}`, "FILE_READ_ERROR", 400);
+    }
+    if (fileBuffer.length !== params.fileSize) {
+      throw new ASCError(
+        `File size mismatch: expected ${params.fileSize}, got ${fileBuffer.length}`,
+        "FILE_SIZE_MISMATCH",
+        400
+      );
+    }
+    const reserveRequest = {
+      data: {
+        type: "appScreenshots",
+        attributes: {
+          fileName: params.fileName,
+          fileSize: params.fileSize
+        },
+        relationships: {
+          appScreenshotSet: {
+            data: {
+              type: "appScreenshotSets",
+              id: params.screenshotSetId
+            }
+          }
+        }
+      }
+    };
+    const reserveResponse = await client.post(
+      "/appScreenshots",
+      reserveRequest
+    );
+    const screenshot = reserveResponse.data;
+    const uploadOperations = screenshot.attributes.uploadOperations;
+    if (!uploadOperations?.length) {
+      throw new ASCError("No upload operations provided", "UPLOAD_ERROR", 500);
+    }
+    for (const operation of uploadOperations) {
+      const chunk = fileBuffer.subarray(operation.offset, operation.offset + operation.length);
+      const headers = {};
+      for (const header of operation.requestHeaders) {
+        headers[header.name] = header.value;
+      }
+      const uploadResponse = await client.rawRequest(operation.url, {
+        method: operation.method,
+        headers,
+        body: chunk
+      });
+      if (!uploadResponse.ok) {
+        throw new ASCError(
+          `Chunk upload failed: ${uploadResponse.status}`,
+          "UPLOAD_ERROR",
+          uploadResponse.status
+        );
+      }
+    }
+    const checksum = crypto.createHash("md5").update(fileBuffer).digest("base64");
+    const commitRequest = {
+      data: {
+        type: "appScreenshots",
+        id: screenshot.id,
+        attributes: {
+          sourceFileChecksum: checksum,
+          uploaded: true
+        }
+      }
+    };
+    const commitResponse = await client.patch(
+      `/appScreenshots/${screenshot.id}`,
+      commitRequest
+    );
+    const finalScreenshot = commitResponse.data;
+    return {
+      success: true,
+      data: {
+        id: finalScreenshot.id,
+        fileName: finalScreenshot.attributes.fileName,
+        fileSize: finalScreenshot.attributes.fileSize,
+        sourceFileChecksum: finalScreenshot.attributes.sourceFileChecksum,
+        assetDeliveryState: finalScreenshot.attributes.assetDeliveryState
+      }
+    };
+  } catch (error) {
+    return formatErrorResponse(error);
+  }
+}
+var screenshotsToolDefinitions = [
+  {
+    name: "list_screenshot_sets",
+    description: "List all screenshot sets for a version localization. Each set represents a different display type (device size).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        localizationId: {
+          type: "string",
+          description: "The version localization ID"
+        },
+        limit: {
+          type: "number",
+          description: "Maximum number of sets to return (1-200)",
+          minimum: 1,
+          maximum: 200
+        }
+      },
+      required: ["localizationId"]
+    }
+  },
+  {
+    name: "list_screenshots",
+    description: "List all screenshots in a screenshot set.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        screenshotSetId: {
+          type: "string",
+          description: "The screenshot set ID"
+        },
+        limit: {
+          type: "number",
+          description: "Maximum number of screenshots to return (1-200)",
+          minimum: 1,
+          maximum: 200
+        }
+      },
+      required: ["screenshotSetId"]
+    }
+  },
+  {
+    name: "upload_screenshot",
+    description: "Upload a new screenshot to a screenshot set. Provide the local file path, and this tool will handle the multi-step upload process.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        screenshotSetId: {
+          type: "string",
+          description: "The screenshot set ID to upload to"
+        },
+        fileName: {
+          type: "string",
+          description: "Name for the screenshot file"
+        },
+        fileSize: {
+          type: "number",
+          description: "Size of the file in bytes"
+        },
+        filePath: {
+          type: "string",
+          description: "Local path to the screenshot file"
+        }
+      },
+      required: ["screenshotSetId", "fileName", "fileSize", "filePath"]
+    }
+  }
+];
+
+// src/tools/users.tools.ts
+async function listUsers(client, input) {
+  try {
+    const params = validateInput(listUsersInputSchema, input);
+    const queryParams = {
+      limit: params.limit,
+      "fields[users]": "username,firstName,lastName,email,roles,allAppsVisible,provisioningAllowed"
+    };
+    if (params.roles && params.roles.length > 0) {
+      queryParams["filter[roles]"] = params.roles.join(",");
+    }
+    const response = await client.get("/users", queryParams);
+    return {
+      success: true,
+      data: response.data.map((user) => ({
+        id: user.id,
+        username: user.attributes.username,
+        firstName: user.attributes.firstName,
+        lastName: user.attributes.lastName,
+        email: user.attributes.email,
+        roles: user.attributes.roles,
+        allAppsVisible: user.attributes.allAppsVisible,
+        provisioningAllowed: user.attributes.provisioningAllowed
+      })),
+      meta: {
+        total: response.meta?.paging?.total,
+        returned: response.data.length
+      }
+    };
+  } catch (error) {
+    return formatErrorResponse(error);
+  }
+}
+async function getUser(client, input) {
+  try {
+    const params = validateInput(getUserInputSchema, input);
+    const response = await client.get(`/users/${params.userId}`, {
+      "fields[users]": "username,firstName,lastName,email,roles,allAppsVisible,provisioningAllowed"
+    });
+    const user = response.data;
+    return {
+      success: true,
+      data: {
+        id: user.id,
+        username: user.attributes.username,
+        firstName: user.attributes.firstName,
+        lastName: user.attributes.lastName,
+        email: user.attributes.email,
+        roles: user.attributes.roles,
+        allAppsVisible: user.attributes.allAppsVisible,
+        provisioningAllowed: user.attributes.provisioningAllowed
+      }
+    };
+  } catch (error) {
+    return formatErrorResponse(error);
+  }
+}
+var usersToolDefinitions = [
+  {
+    name: "list_users",
+    description: "List all users in your App Store Connect team. Can filter by roles.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: {
+          type: "number",
+          description: "Maximum number of users to return (1-200)",
+          minimum: 1,
+          maximum: 200
+        },
+        roles: {
+          type: "array",
+          items: {
+            type: "string",
+            enum: [
+              "ADMIN",
+              "FINANCE",
+              "TECHNICAL",
+              "SALES",
+              "DEVELOPER",
+              "MARKETING",
+              "APP_MANAGER",
+              "CUSTOMER_SUPPORT",
+              "ACCESS_TO_REPORTS",
+              "READ_ONLY"
+            ]
+          },
+          description: "Filter by user roles"
+        }
+      },
+      required: []
+    }
+  },
+  {
+    name: "get_user",
+    description: "Get details of a specific team user.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        userId: {
+          type: "string",
+          description: "The user resource ID"
+        }
+      },
+      required: ["userId"]
+    }
+  }
+];
+
+// src/tools/versions.tools.ts
+async function listAppVersions(client, input) {
+  try {
+    const params = validateInput(listAppVersionsInputSchema, input);
+    const queryParams = {
+      limit: params.limit,
+      "fields[appStoreVersions]": "platform,versionString,appStoreState,copyright,releaseType,createdDate"
+    };
+    if (params.platform) {
+      queryParams["filter[platform]"] = params.platform;
+    }
+    if (params.versionState) {
+      queryParams["filter[appStoreState]"] = params.versionState;
+    }
+    const response = await client.get(
+      `/apps/${params.appId}/appStoreVersions`,
+      queryParams
+    );
+    return {
+      success: true,
+      data: response.data.map((version) => ({
+        id: version.id,
+        platform: version.attributes.platform,
+        versionString: version.attributes.versionString,
+        state: version.attributes.appStoreState,
+        copyright: version.attributes.copyright,
+        releaseType: version.attributes.releaseType,
+        createdDate: version.attributes.createdDate
+      })),
+      meta: {
+        total: response.meta?.paging?.total,
+        returned: response.data.length
+      }
+    };
+  } catch (error) {
+    return formatErrorResponse(error);
+  }
+}
+async function getAppVersion(client, input) {
+  try {
+    const params = validateInput(getAppVersionInputSchema, input);
+    const response = await client.get(
+      `/appStoreVersions/${params.versionId}`,
+      {
+        "fields[appStoreVersions]": "platform,versionString,appStoreState,copyright,releaseType,earliestReleaseDate,usesIdfa,downloadable,createdDate"
+      }
+    );
+    const version = response.data;
+    return {
+      success: true,
+      data: {
+        id: version.id,
+        platform: version.attributes.platform,
+        versionString: version.attributes.versionString,
+        state: version.attributes.appStoreState,
+        copyright: version.attributes.copyright,
+        releaseType: version.attributes.releaseType,
+        earliestReleaseDate: version.attributes.earliestReleaseDate,
+        usesIdfa: version.attributes.usesIdfa,
+        downloadable: version.attributes.downloadable,
+        createdDate: version.attributes.createdDate
+      }
+    };
+  } catch (error) {
+    return formatErrorResponse(error);
+  }
+}
+async function createAppVersion(client, input) {
+  try {
+    const params = validateInput(createAppVersionInputSchema, input);
+    const requestBody = {
+      data: {
+        type: "appStoreVersions",
+        attributes: {
+          platform: params.platform,
+          versionString: params.versionString,
+          copyright: params.copyright,
+          releaseType: params.releaseType,
+          earliestReleaseDate: params.earliestReleaseDate
+        },
+        relationships: {
+          app: {
+            data: {
+              type: "apps",
+              id: params.appId
+            }
+          }
+        }
+      }
+    };
+    const response = await client.post(
+      "/appStoreVersions",
+      requestBody
+    );
+    const version = response.data;
+    return {
+      success: true,
+      data: {
+        id: version.id,
+        platform: version.attributes.platform,
+        versionString: version.attributes.versionString,
+        state: version.attributes.appStoreState,
+        copyright: version.attributes.copyright,
+        releaseType: version.attributes.releaseType,
+        createdDate: version.attributes.createdDate
+      }
+    };
+  } catch (error) {
+    return formatErrorResponse(error);
+  }
+}
+var versionsToolDefinitions = [
+  {
+    name: "list_app_versions",
+    description: "List all App Store versions for an app. Can filter by platform and version state.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        appId: {
+          type: "string",
+          description: "The App Store Connect app ID"
+        },
+        platform: {
+          type: "string",
+          description: "Filter by platform (IOS, MAC_OS, TV_OS, VISION_OS)",
+          enum: ["IOS", "MAC_OS", "TV_OS", "VISION_OS"]
+        },
+        versionState: {
+          type: "string",
+          description: "Filter by version state (e.g., PREPARE_FOR_SUBMISSION, READY_FOR_SALE)"
+        },
+        limit: {
+          type: "number",
+          description: "Maximum number of versions to return (1-200)",
+          minimum: 1,
+          maximum: 200
+        }
+      },
+      required: ["appId"]
+    }
+  },
+  {
+    name: "get_app_version",
+    description: "Get detailed information about a specific app version.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        versionId: {
+          type: "string",
+          description: "The App Store version ID"
+        }
+      },
+      required: ["versionId"]
+    }
+  },
+  {
+    name: "create_app_version",
+    description: "Create a new App Store version for an app.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        appId: {
+          type: "string",
+          description: "The App Store Connect app ID"
+        },
+        platform: {
+          type: "string",
+          description: "Platform for the version",
+          enum: ["IOS", "MAC_OS", "TV_OS", "VISION_OS"]
+        },
+        versionString: {
+          type: "string",
+          description: "Version number (e.g., '1.0.0', '2.1')"
+        },
+        releaseType: {
+          type: "string",
+          description: "Release type",
+          enum: ["MANUAL", "AFTER_APPROVAL", "SCHEDULED"]
+        },
+        copyright: {
+          type: "string",
+          description: "Copyright text for the version"
+        },
+        earliestReleaseDate: {
+          type: "string",
+          description: "Earliest release date (ISO 8601 format) for SCHEDULED release type"
+        }
+      },
+      required: ["appId", "platform", "versionString"]
+    }
+  }
+];
+
+// src/tools/index.ts
+var toolHandlers = {
+  // Apps
+  list_apps: listApps,
+  get_app: getApp,
+  // Versions
+  list_app_versions: listAppVersions,
+  get_app_version: getAppVersion,
+  create_app_version: createAppVersion,
+  // Localizations
+  list_version_localizations: listVersionLocalizations,
+  get_version_localization: getVersionLocalization,
+  create_version_localization: createVersionLocalization,
+  update_version_localization: updateVersionLocalization,
+  delete_version_localization: deleteVersionLocalization,
+  // App Info
+  list_app_infos: listAppInfos,
+  list_app_info_localizations: listAppInfoLocalizations,
+  update_app_info_localization: updateAppInfoLocalization,
+  // Beta
+  list_beta_groups: listBetaGroups,
+  list_beta_testers: listBetaTesters,
+  add_beta_tester: addBetaTester,
+  remove_beta_tester: removeBetaTester,
+  // Screenshots
+  list_screenshot_sets: listScreenshotSets,
+  list_screenshots: listScreenshots,
+  upload_screenshot: uploadScreenshot,
+  // Bundle IDs
+  list_bundle_ids: listBundleIds,
+  get_bundle_id: getBundleId,
+  create_bundle_id: createBundleId,
+  update_bundle_id: updateBundleId,
+  delete_bundle_id: deleteBundleId,
+  // Devices
+  list_devices: listDevices,
+  get_device: getDevice,
+  // Users
+  list_users: listUsers,
+  get_user: getUser,
+  // Builds
+  list_builds: listBuilds,
+  get_build: getBuild,
+  list_beta_tester_invitations: listBetaTesterInvitations,
+  // Categories
+  list_app_categories: listAppCategories,
+  get_app_price_schedule: getAppPriceSchedule,
+  get_app_availability: getAppAvailability
+};
+var allToolDefinitions = [
+  ...appsToolDefinitions,
+  ...versionsToolDefinitions,
+  ...localizationsToolDefinitions,
+  ...appInfoToolDefinitions,
+  ...betaToolDefinitions,
+  ...screenshotsToolDefinitions,
+  ...bundleIdsToolDefinitions,
+  ...devicesToolDefinitions,
+  ...usersToolDefinitions,
+  ...buildsToolDefinitions,
+  ...categoriesToolDefinitions
+];
+function hasToolHandler(name) {
+  return name in toolHandlers;
+}
+async function executeTool(client, name, input) {
+  const handler = toolHandlers[name];
+  if (!handler) {
+    return {
+      success: false,
+      error: {
+        code: "UNKNOWN_TOOL",
+        message: `Unknown tool: ${name}`
+      }
+    };
+  }
+  return handler(client, input);
+}
+
+// src/index.ts
+var SERVER_NAME = "asc-mcp";
+var SERVER_VERSION = "1.0.0";
+async function main() {
+  let tokenManager;
+  let client;
+  try {
+    tokenManager = createTokenManagerFromEnv();
+    client = createClient(tokenManager);
+  } catch (error) {
+    if (error instanceof ConfigError) {
+      console.error(`Configuration error: ${error.message}`);
+      console.error("\nRequired environment variables:");
+      console.error("  APP_STORE_CONNECT_KEY_ID - Your API key ID");
+      console.error("  APP_STORE_CONNECT_ISSUER_ID - Your issuer ID");
+      console.error("  APP_STORE_CONNECT_P8_PATH - Path to your .p8 private key file");
+      console.error("  or APP_STORE_CONNECT_P8_CONTENT - Content of your .p8 private key");
+      process.exit(1);
+    }
+    throw error;
+  }
+  const server = new Server(
+    {
+      name: SERVER_NAME,
+      version: SERVER_VERSION
+    },
+    {
+      capabilities: {
+        tools: {}
+      }
+    }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+      tools: allToolDefinitions
+    };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    if (!hasToolHandler(name)) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: false,
+                error: {
+                  code: "UNKNOWN_TOOL",
+                  message: `Unknown tool: ${name}`
+                }
+              },
+              null,
+              2
+            )
+          }
+        ],
+        isError: true
+      };
+    }
+    try {
+      const result = await executeTool(client, name, args ?? {});
+      const isError = typeof result === "object" && result !== null && "success" in result && result.success === false;
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ],
+        isError
+      };
+    } catch (error) {
+      const errorResponse = formatErrorResponse(error);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(errorResponse, null, 2)
+          }
+        ],
+        isError: true
+      };
+    }
+  });
+  const shutdown = () => {
+    console.error("Shutting down...");
+    tokenManager.destroy();
+    setTimeout(() => {
+      process.exit(0);
+    }, 100);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error(`${SERVER_NAME} v${SERVER_VERSION} started`);
+}
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  if (error instanceof Error && error.stack) {
+    console.error(error.stack);
+  }
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map