@onmyway133/asc-cli 1.0.1

package/src/commands/game-center.ts

@@ -0,0 +1,114 @@
+import { ascFetch, ascFetchAll } from "../api/client.ts"
+import { detectFormat, printJSON, printSuccess, printTable, truncate } from "../utils/output.ts"
+
+// ---- Achievements ----
+
+export async function achievementsList(opts: {
+  appId: string
+  output?: string
+}): Promise<void> {
+  const items = await ascFetchAll<{
+    id: string
+    attributes: {
+      referenceName?: string
+      points?: number
+      showBeforeEarned?: boolean
+      repeatable?: boolean
+      archived?: boolean
+    }
+  }>(`/v1/apps/${opts.appId}/gameCenterAchievements`, {
+    params: { "fields[gameCenterAchievements]": "referenceName,points,showBeforeEarned,repeatable,archived" },
+  })
+  const fmt = detectFormat(opts.output)
+  if (fmt === "json") { printJSON(items); return }
+  printTable(
+    ["ID", "Reference Name", "Points", "Repeatable"],
+    items.map(a => [
+      a.id,
+      a.attributes.referenceName ?? "-",
+      String(a.attributes.points ?? "-"),
+      String(a.attributes.repeatable ?? "-"),
+    ]),
+    `Game Center Achievements (${items.length})`,
+  )
+}
+
+export async function achievementGet(achievementId: string, opts: { output?: string } = {}): Promise<void> {
+  const result = await ascFetch<{
+    data: {
+      id: string
+      attributes: {
+        referenceName?: string
+        points?: number
+        showBeforeEarned?: boolean
+        repeatable?: boolean
+        archived?: boolean
+      }
+    }
+  }>(`/v1/gameCenterAchievements/${achievementId}`)
+  const fmt = detectFormat(opts.output)
+  if (fmt === "json") { printJSON(result.data.data); return }
+  const a = result.data.data.attributes
+  console.log(`ID:              ${result.data.data.id}`)
+  console.log(`Reference Name:  ${a.referenceName ?? "-"}`)
+  console.log(`Points:          ${a.points ?? "-"}`)
+  console.log(`Repeatable:      ${a.repeatable ?? false}`)
+  console.log(`Show Before Earn:${a.showBeforeEarned ?? false}`)
+  console.log(`Archived:        ${a.archived ?? false}`)
+}
+
+// ---- Leaderboards ----
+
+export async function leaderboardsList(opts: {
+  appId: string
+  output?: string
+}): Promise<void> {
+  const items = await ascFetchAll<{
+    id: string
+    attributes: {
+      referenceName?: string
+      defaultFormatter?: unknown
+      archived?: boolean
+    }
+  }>(`/v1/apps/${opts.appId}/gameCenterLeaderboards`, {
+    params: { "fields[gameCenterLeaderboards]": "referenceName,defaultFormatter,archived" },
+  })
+  const fmt = detectFormat(opts.output)
+  if (fmt === "json") { printJSON(items); return }
+  printTable(
+    ["ID", "Reference Name", "Archived"],
+    items.map(l => [l.id, l.attributes.referenceName ?? "-", String(l.attributes.archived ?? false)]),
+    `Leaderboards (${items.length})`,
+  )
+}
+
+// ---- Leaderboard Sets ----
+
+export async function leaderboardSetsList(opts: {
+  appId: string
+  output?: string
+}): Promise<void> {
+  const items = await ascFetchAll<{
+    id: string
+    attributes: { referenceName?: string; archived?: boolean }
+  }>(`/v1/apps/${opts.appId}/gameCenterLeaderboardSets`)
+  const fmt = detectFormat(opts.output)
+  if (fmt === "json") { printJSON(items); return }
+  printTable(
+    ["ID", "Reference Name", "Archived"],
+    items.map(s => [s.id, s.attributes.referenceName ?? "-", String(s.attributes.archived ?? false)]),
+    `Leaderboard Sets (${items.length})`,
+  )
+}
+
+// ---- Game Center Enable ----
+
+export async function gameCenterEnableCheck(appId: string, opts: { output?: string } = {}): Promise<void> {
+  const result = await ascFetch<{
+    data: { id: string; attributes: Record<string, unknown> }
+  }>(`/v1/apps/${appId}/gameCenterEnabledVersions`)
+  const fmt = detectFormat(opts.output)
+  if (fmt === "json") { printJSON(result.data); return }
+  console.log(`Game Center status for app ${appId}:`)
+  console.log(JSON.stringify(result.data.data, null, 2))
+}

package/src/commands/iap.ts

@@ -0,0 +1,105 @@
+import { ascFetch, ascFetchAll } from "../api/client.ts"
+import { detectFormat, printJSON, printSuccess, printTable, truncate } from "../utils/output.ts"
+
+// ---- In-App Purchases (non-subscription consumables, non-consumables, non-renewing subscriptions) ----
+
+export async function iapList(opts: { appId: string; output?: string }): Promise<void> {
+  const items = await ascFetchAll<{
+    id: string
+    attributes: {
+      name?: string
+      productId?: string
+      inAppPurchaseType?: string
+      state?: string
+    }
+  }>(`/v1/apps/${opts.appId}/inAppPurchasesV2`, {
+    params: { "fields[inAppPurchasesV2]": "name,productId,inAppPurchaseType,state" },
+  })
+  const fmt = detectFormat(opts.output)
+  if (fmt === "json") { printJSON(items); return }
+  printTable(
+    ["ID", "Name", "Product ID", "Type", "State"],
+    items.map(i => [
+      i.id,
+      truncate(i.attributes.name ?? "-", 30),
+      i.attributes.productId ?? "-",
+      i.attributes.inAppPurchaseType ?? "-",
+      i.attributes.state ?? "-",
+    ]),
+    `In-App Purchases (${items.length})`,
+  )
+}
+
+export async function iapGet(iapId: string, opts: { output?: string } = {}): Promise<void> {
+  const result = await ascFetch<{
+    data: {
+      id: string
+      attributes: {
+        name?: string
+        productId?: string
+        inAppPurchaseType?: string
+        state?: string
+        reviewNote?: string
+        familySharable?: boolean
+        contentHosting?: boolean
+        availableInAllTerritories?: boolean
+      }
+    }
+  }>(`/v1/inAppPurchasesV2/${iapId}`)
+  const fmt = detectFormat(opts.output)
+  if (fmt === "json") { printJSON(result.data); return }
+  const a = result.data.data.attributes
+  console.log(`ID:           ${result.data.data.id}`)
+  console.log(`Name:         ${a.name ?? "-"}`)
+  console.log(`Product ID:   ${a.productId ?? "-"}`)
+  console.log(`Type:         ${a.inAppPurchaseType ?? "-"}`)
+  console.log(`State:        ${a.state ?? "-"}`)
+  console.log(`Reviewable:   ${a.reviewNote ?? "(no review note)"}`)
+  console.log(`Family Share: ${a.familySharable ?? false}`)
+}
+
+export async function iapCreate(opts: {
+  appId: string
+  name: string
+  productId: string
+  type: string
+}): Promise<void> {
+  const result = await ascFetch<{ data: { id: string } }>("/v1/inAppPurchasesV2", {
+    method: "POST",
+    body: {
+      data: {
+        type: "inAppPurchasesV2",
+        attributes: {
+          name: opts.name,
+          productId: opts.productId,
+          inAppPurchaseType: opts.type,
+        },
+        relationships: {
+          app: { data: { type: "apps", id: opts.appId } },
+        },
+      },
+    },
+  })
+  printSuccess(`Created IAP: ${result.data.data.id} (${opts.productId})`)
+}
+
+export async function iapDelete(iapId: string): Promise<void> {
+  await ascFetch(`/v1/inAppPurchasesV2/${iapId}`, { method: "DELETE" })
+  printSuccess(`Deleted IAP ${iapId}`)
+}
+
+export async function iapLocalesList(iapId: string, opts: { output?: string } = {}): Promise<void> {
+  const items = await ascFetchAll<{
+    id: string
+    attributes: { locale?: string; name?: string; description?: string }
+  }>(`/v1/inAppPurchasesV2/${iapId}/iapPriceSchedule`, {
+    params: { "fields[inAppPurchaseLocalizations]": "locale,name,description" },
+  })
+  const fmt = detectFormat(opts.output)
+  if (fmt === "json") { printJSON(items); return }
+  printTable(
+    ["Locale", "Name", "Description"],
+    items.map(l => [l.attributes.locale ?? l.id, l.attributes.name ?? "-", truncate(l.attributes.description ?? "-", 40)]),
+    `IAP Localizations (${items.length})`,
+  )
+}

package/src/commands/metadata.ts

@@ -0,0 +1,81 @@
+import { ascFetch, ascFetchAll } from "../api/client.ts"
+import type { AppStoreVersionLocalization } from "../api/types.ts"
+import { detectFormat, printJSON, printSuccess, printTable, truncate } from "../utils/output.ts"
+
+export async function metadataList(opts: {
+  versionId: string
+  output?: string
+}): Promise<void> {
+  const locs = await ascFetchAll<AppStoreVersionLocalization>(
+    `/v1/appStoreVersions/${opts.versionId}/appStoreVersionLocalizations`,
+  )
+
+  const fmt = detectFormat(opts.output)
+  if (fmt === "json") {
+    printJSON(locs.map((l) => ({ id: l.id, ...l.attributes })))
+    return
+  }
+
+  printTable(
+    ["ID", "Locale", "What's New", "Description"],
+    locs.map((l) => [
+      l.id,
+      l.attributes.locale,
+      truncate(l.attributes.whatsNew ?? "-", 50),
+      truncate(l.attributes.description ?? "-", 50),
+    ]),
+    `Localizations (${locs.length})`,
+  )
+}
+
+export async function metadataUpdate(opts: {
+  versionId: string
+  locale: string
+  whatsNew?: string
+  description?: string
+  keywords?: string
+  promotionalText?: string
+}): Promise<void> {
+  // Find existing localization for this locale
+  const locs = await ascFetchAll<AppStoreVersionLocalization>(
+    `/v1/appStoreVersions/${opts.versionId}/appStoreVersionLocalizations`,
+    { params: { "filter[locale]": opts.locale } },
+  )
+
+  const attributes: Record<string, string> = {}
+  if (opts.whatsNew !== undefined) attributes["whatsNew"] = opts.whatsNew
+  if (opts.description !== undefined) attributes["description"] = opts.description
+  if (opts.keywords !== undefined) attributes["keywords"] = opts.keywords
+  if (opts.promotionalText !== undefined) attributes["promotionalText"] = opts.promotionalText
+
+  if (locs.length > 0 && locs[0]) {
+    await ascFetch(`/v1/appStoreVersionLocalizations/${locs[0].id}`, {
+      method: "PATCH",
+      body: {
+        data: {
+          type: "appStoreVersionLocalizations",
+          id: locs[0].id,
+          attributes,
+        },
+      },
+    })
+    printSuccess(`Metadata updated for locale "${opts.locale}"`)
+  } else {
+    // Create new localization
+    await ascFetch("/v1/appStoreVersionLocalizations", {
+      method: "POST",
+      body: {
+        data: {
+          type: "appStoreVersionLocalizations",
+          attributes: { locale: opts.locale, ...attributes },
+          relationships: {
+            appStoreVersion: {
+              data: { type: "appStoreVersions", id: opts.versionId },
+            },
+          },
+        },
+      },
+    })
+    printSuccess(`Localization created for locale "${opts.locale}"`)
+  }
+}

package/src/commands/pricing.ts

@@ -0,0 +1,110 @@
+import { ascFetch, ascFetchAll } from "../api/client.ts"
+import { detectFormat, formatDate, printJSON, printSuccess, printTable } from "../utils/output.ts"
+
+export async function pricingScheduleGet(appId: string, opts: { output?: string } = {}): Promise<void> {
+  // Fetch price schedule with related resources included
+  const result = await ascFetch<{
+    data: { id: string; type: string }
+    included?: Array<{ type: string; id: string; attributes?: Record<string, unknown> }>
+  }>(`/v1/apps/${appId}/appPriceSchedule`, {
+    params: {
+      include: "manualPrices,automaticPrices,baseTerritory",
+      "fields[territories]": "currency,name",
+    },
+  })
+  const body = result.data
+  const fmt = detectFormat(opts.output)
+  if (fmt === "json") { printJSON(body); return }
+  console.log(`Schedule ID:    ${body.data.id}`)
+  const included = body.included ?? []
+  const base = included.find(r => r.type === "territories")
+  if (base) {
+    const attrs = base.attributes as { currency?: string; name?: string } | undefined
+    console.log(`Base Territory: ${attrs?.name ?? base.id} (${attrs?.currency ?? "?"})`)
+  }
+  const manual = included.filter(r => r.type === "appPrices")
+  if (manual.length) {
+    printTable(
+      ["Price ID", "Territory", "Start Date"],
+      manual.map(p => {
+        const a = p.attributes as { territory?: string; startDate?: string } | undefined
+        return [p.id, a?.territory ?? "-", formatDate(a?.startDate ?? "")]
+      }),
+      `Manual Prices (${manual.length})`,
+    )
+  }
+}
+
+export async function pricingScheduleSet(opts: {
+  appId: string
+  baseTerritory: string
+  pricePointId: string
+}): Promise<void> {
+  await ascFetch("/v1/appPriceSchedules", {
+    method: "POST",
+    body: {
+      data: {
+        type: "appPriceSchedules",
+        relationships: {
+          app: { data: { type: "apps", id: opts.appId } },
+          manualPrices: { data: [{ type: "appPrices", id: "${price}" }] },
+          baseTerritory: { data: { type: "territories", id: opts.baseTerritory } },
+        },
+      },
+      included: [
+        {
+          type: "appPrices",
+          id: "${price}",
+          attributes: { startDate: null },
+          relationships: {
+            appPricePoint: { data: { type: "appPricePoints", id: opts.pricePointId } },
+            territory: { data: { type: "territories", id: opts.baseTerritory } },
+          },
+        },
+      ],
+    },
+  })
+  printSuccess(`Price schedule updated for app ${opts.appId}`)
+}
+
+export async function pricingPointsList(opts: {
+  appId: string
+  territory?: string
+  output?: string
+}): Promise<void> {
+  const params: Record<string, string> = {
+    "fields[appPricePoints]": "customerPrice,proceeds,territory",
+    limit: "200",
+  }
+  if (opts.territory) params["filter[territory]"] = opts.territory
+  const items = await ascFetchAll<{
+    id: string
+    attributes: { customerPrice?: string; proceeds?: string; territory?: unknown }
+  }>(`/v1/apps/${opts.appId}/appPricePoints`, { params })
+  const fmt = detectFormat(opts.output)
+  if (fmt === "json") { printJSON(items); return }
+  printTable(
+    ["ID", "Customer Price", "Proceeds", "Territory"],
+    items.map(p => [
+      p.id,
+      p.attributes.customerPrice ?? "-",
+      p.attributes.proceeds ?? "-",
+      String(p.attributes.territory ?? "-"),
+    ]),
+    `Price Points (${items.length})`,
+  )
+}
+
+export async function territoriesList(opts: { output?: string } = {}): Promise<void> {
+  const items = await ascFetchAll<{
+    id: string
+    attributes: { currency?: string; name?: string }
+  }>("/v1/territories")
+  const fmt = detectFormat(opts.output)
+  if (fmt === "json") { printJSON(items); return }
+  printTable(
+    ["Territory Code", "Name", "Currency"],
+    items.map(t => [t.id, t.attributes.name ?? "-", t.attributes.currency ?? "-"]),
+    `Territories (${items.length})`,
+  )
+}

package/src/commands/reports.ts

@@ -0,0 +1,116 @@
+import { ascFetch, ascFetchAll } from "../api/client.ts"
+import { detectFormat, formatDate, printJSON, printTable } from "../utils/output.ts"
+
+// ---- Sales and Finance Reports ----
+
+export async function salesReportDownload(opts: {
+  vendorNumber: string
+  frequency: string
+  reportDate: string
+  reportType?: string
+  reportSubType?: string
+  output?: string
+}): Promise<void> {
+  const params: Record<string, string> = {
+    "filter[vendorNumber]": opts.vendorNumber,
+    "filter[frequency]": opts.frequency,
+    "filter[reportDate]": opts.reportDate,
+    "filter[reportType]": opts.reportType ?? "SALES",
+    "filter[reportSubType]": opts.reportSubType ?? "SUMMARY",
+  }
+
+  // Sales reports return gzipped TSV, not JSON:API
+  const profile = (await import("../auth/credentials.ts")).getActiveProfile()
+  if (!profile) throw new Error("No active profile. Run: asc auth login")
+  const token = await (await import("../auth/jwt.ts")).generateJWT(profile)
+
+  const url = new URL("https://api.appstoreconnect.apple.com/v1/salesReports")
+  for (const [k, v] of Object.entries(params)) url.searchParams.set(k, v)
+
+  const res = await fetch(url.toString(), {
+    headers: { Authorization: `Bearer ${token}`, "Accept-Encoding": "gzip" },
+  })
+
+  if (!res.ok) {
+    const err = await res.json() as { errors?: Array<{ detail?: string }> }
+    const msg = err.errors?.[0]?.detail ?? `HTTP ${res.status}`
+    throw new Error(msg)
+  }
+
+  const text = await res.text()
+  const fmt = detectFormat(opts.output)
+  if (fmt === "json") {
+    // Parse TSV to JSON
+    const lines = text.trim().split("\n")
+    const headers = (lines[0] ?? "").split("\t")
+    const rows = lines.slice(1).map(line => {
+      const cols = line.split("\t")
+      return Object.fromEntries(headers.map((h, i) => [h, cols[i] ?? ""]))
+    })
+    console.log(JSON.stringify(rows, null, 2))
+  } else {
+    process.stdout.write(text)
+  }
+}
+
+export async function financeReportDownload(opts: {
+  vendorNumber: string
+  regionCode: string
+  reportDate: string
+  output?: string
+}): Promise<void> {
+  const profile = (await import("../auth/credentials.ts")).getActiveProfile()
+  if (!profile) throw new Error("No active profile. Run: asc auth login")
+  const token = await (await import("../auth/jwt.ts")).generateJWT(profile)
+
+  const url = new URL("https://api.appstoreconnect.apple.com/v1/financeReports")
+  url.searchParams.set("filter[vendorNumber]", opts.vendorNumber)
+  url.searchParams.set("filter[regionCode]", opts.regionCode)
+  url.searchParams.set("filter[reportDate]", opts.reportDate)
+  url.searchParams.set("filter[reportType]", "FINANCIAL")
+
+  const res = await fetch(url.toString(), { headers: { Authorization: `Bearer ${token}` } })
+
+  if (!res.ok) {
+    const err = await res.json() as { errors?: Array<{ detail?: string }> }
+    const msg = err.errors?.[0]?.detail ?? `HTTP ${res.status}`
+    throw new Error(msg)
+  }
+
+  process.stdout.write(await res.text())
+}
+
+export async function analyticsReportsList(opts: {
+  appId: string
+  output?: string
+}): Promise<void> {
+  const items = await ascFetchAll<{
+    id: string
+    attributes: { name?: string; category?: string }
+  }>(`/v1/apps/${opts.appId}/analyticsReportRequests`)
+  const fmt = detectFormat(opts.output)
+  if (fmt === "json") { printJSON(items); return }
+  printTable(
+    ["Request ID", "State"],
+    items.map(r => [r.id, String(r.attributes.name ?? r.id)]),
+    `Analytics Report Requests (${items.length})`,
+  )
+}
+
+export async function analyticsReportRequest(opts: {
+  appId: string
+  category: string
+}): Promise<void> {
+  const result = await ascFetch<{ data: { id: string } }>("/v1/analyticsReportRequests", {
+    method: "POST",
+    body: {
+      data: {
+        type: "analyticsReportRequests",
+        attributes: { accessType: opts.category },
+        relationships: { app: { data: { type: "apps", id: opts.appId } } },
+      },
+    },
+  })
+  console.log(`Analytics report request created: ${result.data.data.id}`)
+  console.log("Check back later with: asc reports analytics-list --app-id <id>")
+}

package/src/commands/reviews.ts

@@ -0,0 +1,93 @@
+import { ascFetch, ascFetchAll } from "../api/client.ts"
+import type { CustomerReview, CustomerReviewResponse } from "../api/types.ts"
+import { detectFormat, formatDate, printJSON, printSuccess, printTable, truncate } from "../utils/output.ts"
+
+export async function reviewsList(opts: {
+  appId: string
+  output?: string
+}): Promise<void> {
+  const reviews = await ascFetchAll<CustomerReview>(
+    `/v1/apps/${opts.appId}/customerReviews`,
+    {
+      params: {
+        "fields[customerReviews]": "rating,title,body,reviewerNickname,createdDate,territory",
+        "sort": "-createdDate",
+      },
+    },
+  )
+
+  const fmt = detectFormat(opts.output)
+  if (fmt === "json") {
+    printJSON(reviews.map((r) => ({ id: r.id, ...r.attributes })))
+    return
+  }
+
+  printTable(
+    ["ID", "Rating", "Title", "Body", "Date"],
+    reviews.map((r) => [
+      r.id,
+      "★".repeat(r.attributes.rating) + "☆".repeat(5 - r.attributes.rating),
+      truncate(r.attributes.title ?? "-", 30),
+      truncate(r.attributes.body ?? "-", 50),
+      formatDate(r.attributes.createdDate),
+    ]),
+    `Reviews (${reviews.length})`,
+  )
+}
+
+export async function reviewsGet(reviewId: string, opts: { output?: string } = {}): Promise<void> {
+  const res = await ascFetch<CustomerReview>(`/v1/customerReviews/${reviewId}`)
+  const r = res.data
+
+  const fmt = detectFormat(opts.output)
+  if (fmt === "json") {
+    printJSON({ id: r.id, ...r.attributes })
+    return
+  }
+
+  console.log(`ID:       ${r.id}`)
+  console.log(`Rating:   ${"★".repeat(r.attributes.rating)}${"☆".repeat(5 - r.attributes.rating)}`)
+  console.log(`Title:    ${r.attributes.title ?? "-"}`)
+  console.log(`Body:     ${r.attributes.body ?? "-"}`)
+  console.log(`Author:   ${r.attributes.reviewerNickname ?? "-"}`)
+  console.log(`Date:     ${formatDate(r.attributes.createdDate)}`)
+  console.log(`Territory:${r.attributes.territory ?? "-"}`)
+}
+
+export async function reviewsRespond(opts: {
+  reviewId: string
+  message: string
+}): Promise<void> {
+  // Check if a response already exists
+  const existingRes = await ascFetch<CustomerReviewResponse | null>(
+    `/v1/customerReviews/${opts.reviewId}/response`,
+  ).catch(() => null)
+
+  if (existingRes?.data) {
+    await ascFetch(`/v1/customerReviewResponses/${existingRes.data.id}`, {
+      method: "PATCH",
+      body: {
+        data: {
+          type: "customerReviewResponses",
+          id: existingRes.data.id,
+          attributes: { responseBody: opts.message },
+        },
+      },
+    })
+    printSuccess("Review response updated")
+  } else {
+    await ascFetch("/v1/customerReviewResponses", {
+      method: "POST",
+      body: {
+        data: {
+          type: "customerReviewResponses",
+          attributes: { responseBody: opts.message },
+          relationships: {
+            review: { data: { type: "customerReviews", id: opts.reviewId } },
+          },
+        },
+      },
+    })
+    printSuccess("Review response posted")
+  }
+}