@onmyway133/asc-cli 1.0.1

package/src/commands/screenshots.ts

@@ -0,0 +1,139 @@
+import { ascFetch, ascFetchAll } from "../api/client.ts"
+import { readFileSync } from "fs"
+import { detectFormat, printJSON, printSuccess, printTable } from "../utils/output.ts"
+
+// ---- App Screenshots ----
+
+export async function screenshotSetsList(opts: {
+  versionLocalizationId: string
+  output?: string
+}): Promise<void> {
+  const items = await ascFetchAll<{
+    id: string
+    attributes: {
+      screenshotDisplayType?: string
+      appScreenshots?: { meta?: { total?: number } }
+    }
+  }>(`/v1/appStoreVersionLocalizations/${opts.versionLocalizationId}/appScreenshotSets`, {
+    params: { "fields[appScreenshotSets]": "screenshotDisplayType,appScreenshots" },
+  })
+  const fmt = detectFormat(opts.output)
+  if (fmt === "json") { printJSON(items); return }
+  printTable(
+    ["Set ID", "Display Type"],
+    items.map(s => [s.id, s.attributes.screenshotDisplayType ?? "-"]),
+    `Screenshot Sets (${items.length})`,
+  )
+}
+
+export async function screenshotsList(opts: {
+  setId: string
+  output?: string
+}): Promise<void> {
+  const items = await ascFetchAll<{
+    id: string
+    attributes: {
+      fileName?: string
+      fileSize?: number
+      sourceFileChecksum?: string
+      assetDeliveryState?: { state?: string }
+      imageAsset?: { templateUrl?: string; width?: number; height?: number }
+    }
+  }>(`/v1/appScreenshotSets/${opts.setId}/appScreenshots`)
+  const fmt = detectFormat(opts.output)
+  if (fmt === "json") { printJSON(items); return }
+  printTable(
+    ["ID", "File Name", "State"],
+    items.map(s => [
+      s.id,
+      s.attributes.fileName ?? "-",
+      s.attributes.assetDeliveryState?.state ?? "-",
+    ]),
+    `Screenshots (${items.length})`,
+  )
+}
+
+export async function screenshotCreate(opts: {
+  setId: string
+  filePath: string
+}): Promise<void> {
+  const fileData = readFileSync(opts.filePath)
+  const fileName = opts.filePath.split("/").pop() ?? "screenshot.png"
+  const fileSize = fileData.length
+
+  // Step 1: Reserve asset
+  const reserve = await ascFetch<{
+    data: {
+      id: string
+      attributes: {
+        uploadOperations?: Array<{
+          url: string
+          method: string
+          offset: number
+          length: number
+          requestHeaders?: Array<{ name: string; value: string }>
+        }>
+      }
+    }
+  }>("/v1/appScreenshots", {
+    method: "POST",
+    body: {
+      data: {
+        type: "appScreenshots",
+        attributes: { fileName, fileSize },
+        relationships: {
+          appScreenshotSet: { data: { type: "appScreenshotSets", id: opts.setId } },
+        },
+      },
+    },
+  })
+
+  const screenshotId = reserve.data.data.id
+  const uploads = reserve.data.data.attributes.uploadOperations ?? []
+
+  // Step 2: Upload parts
+  for (const op of uploads) {
+    const chunk = fileData.subarray(op.offset, op.offset + op.length)
+    const headers: Record<string, string> = { "Content-Type": "image/png" }
+    for (const h of op.requestHeaders ?? []) headers[h.name] = h.value
+    await fetch(op.url, { method: op.method, headers, body: chunk })
+  }
+
+  // Step 3: Commit
+  await ascFetch(`/v1/appScreenshots/${screenshotId}`, {
+    method: "PATCH",
+    body: {
+      data: {
+        type: "appScreenshots",
+        id: screenshotId,
+        attributes: { uploaded: true },
+      },
+    },
+  })
+
+  printSuccess(`Screenshot uploaded: ${screenshotId}`)
+}
+
+export async function screenshotDelete(screenshotId: string): Promise<void> {
+  await ascFetch(`/v1/appScreenshots/${screenshotId}`, { method: "DELETE" })
+  printSuccess(`Screenshot ${screenshotId} deleted`)
+}
+
+// ---- App Preview Sets ----
+
+export async function previewSetsList(opts: {
+  versionLocalizationId: string
+  output?: string
+}): Promise<void> {
+  const items = await ascFetchAll<{
+    id: string
+    attributes: { previewType?: string }
+  }>(`/v1/appStoreVersionLocalizations/${opts.versionLocalizationId}/appPreviewSets`)
+  const fmt = detectFormat(opts.output)
+  if (fmt === "json") { printJSON(items); return }
+  printTable(
+    ["Set ID", "Preview Type"],
+    items.map(s => [s.id, s.attributes.previewType ?? "-"]),
+    `Preview Sets (${items.length})`,
+  )
+}

package/src/commands/signing.ts

@@ -0,0 +1,214 @@
+import { ascFetch, ascFetchAll } from "../api/client.ts"
+import { detectFormat, formatDate, printJSON, printSuccess, printTable } from "../utils/output.ts"
+
+// ---- Certificates ----
+
+export async function certificatesList(opts: {
+  type?: string
+  output?: string
+} = {}): Promise<void> {
+  const params: Record<string, string> = {
+    "fields[certificates]": "certificateType,displayName,expirationDate,serialNumber,platform",
+  }
+  if (opts.type) params["filter[certificateType]"] = opts.type
+  const items = await ascFetchAll<{
+    id: string
+    attributes: {
+      certificateType?: string
+      displayName?: string
+      expirationDate?: string
+      serialNumber?: string
+      platform?: string
+    }
+  }>("/v1/certificates", { params })
+  const fmt = detectFormat(opts.output)
+  if (fmt === "json") { printJSON(items); return }
+  printTable(
+    ["ID", "Name", "Type", "Expires", "Serial"],
+    items.map(c => [
+      c.id,
+      c.attributes.displayName ?? "-",
+      c.attributes.certificateType ?? "-",
+      formatDate(c.attributes.expirationDate ?? ""),
+      c.attributes.serialNumber ?? "-",
+    ]),
+    `Certificates (${items.length})`,
+  )
+}
+
+export async function certificateGet(certId: string, opts: { output?: string } = {}): Promise<void> {
+  const result = await ascFetch<{
+    data: {
+      id: string
+      attributes: {
+        certificateType?: string
+        displayName?: string
+        expirationDate?: string
+        serialNumber?: string
+        platform?: string
+        certificateContent?: string
+      }
+    }
+  }>(`/v1/certificates/${certId}`)
+  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(`Name:        ${a.displayName ?? "-"}`)
+  console.log(`Type:        ${a.certificateType ?? "-"}`)
+  console.log(`Expires:     ${formatDate(a.expirationDate ?? "")}`)
+  console.log(`Serial:      ${a.serialNumber ?? "-"}`)
+  console.log(`Platform:    ${a.platform ?? "-"}`)
+}
+
+export async function certificateRevoke(certId: string): Promise<void> {
+  await ascFetch(`/v1/certificates/${certId}`, { method: "DELETE" })
+  printSuccess(`Certificate ${certId} revoked`)
+}
+
+// ---- Devices ----
+
+export async function devicesList(opts: {
+  platform?: string
+  status?: string
+  output?: string
+} = {}): Promise<void> {
+  const params: Record<string, string> = {
+    "fields[devices]": "name,deviceClass,model,udid,platform,status,addedDate",
+  }
+  if (opts.platform) params["filter[platform]"] = opts.platform
+  if (opts.status) params["filter[status]"] = opts.status
+  const items = await ascFetchAll<{
+    id: string
+    attributes: {
+      name?: string
+      deviceClass?: string
+      model?: string
+      udid?: string
+      platform?: string
+      status?: string
+      addedDate?: string
+    }
+  }>("/v1/devices", { params })
+  const fmt = detectFormat(opts.output)
+  if (fmt === "json") { printJSON(items); return }
+  printTable(
+    ["ID", "Name", "Model", "Platform", "Status", "UDID"],
+    items.map(d => [
+      d.id,
+      d.attributes.name ?? "-",
+      d.attributes.model ?? d.attributes.deviceClass ?? "-",
+      d.attributes.platform ?? "-",
+      d.attributes.status ?? "-",
+      d.attributes.udid ?? "-",
+    ]),
+    `Devices (${items.length})`,
+  )
+}
+
+export async function deviceRegister(opts: {
+  name: string
+  udid: string
+  platform: string
+}): Promise<void> {
+  const result = await ascFetch<{ data: { id: string } }>("/v1/devices", {
+    method: "POST",
+    body: {
+      data: {
+        type: "devices",
+        attributes: { name: opts.name, udid: opts.udid, platform: opts.platform },
+      },
+    },
+  })
+  printSuccess(`Device registered: ${result.data.data.id} (${opts.udid})`)
+}
+
+// ---- Bundle IDs ----
+
+export async function bundleIdsList(opts: {
+  platform?: string
+  identifier?: string
+  output?: string
+} = {}): Promise<void> {
+  const params: Record<string, string> = {
+    "fields[bundleIds]": "name,identifier,platform,seedId",
+  }
+  if (opts.platform) params["filter[platform]"] = opts.platform
+  if (opts.identifier) params["filter[identifier]"] = opts.identifier
+  const items = await ascFetchAll<{
+    id: string
+    attributes: { name?: string; identifier?: string; platform?: string; seedId?: string }
+  }>("/v1/bundleIds", { params })
+  const fmt = detectFormat(opts.output)
+  if (fmt === "json") { printJSON(items); return }
+  printTable(
+    ["ID", "Name", "Identifier", "Platform", "Seed ID"],
+    items.map(b => [
+      b.id,
+      b.attributes.name ?? "-",
+      b.attributes.identifier ?? "-",
+      b.attributes.platform ?? "-",
+      b.attributes.seedId ?? "-",
+    ]),
+    `Bundle IDs (${items.length})`,
+  )
+}
+
+export async function bundleIdRegister(opts: {
+  name: string
+  identifier: string
+  platform: string
+}): Promise<void> {
+  const result = await ascFetch<{ data: { id: string } }>("/v1/bundleIds", {
+    method: "POST",
+    body: {
+      data: {
+        type: "bundleIds",
+        attributes: { name: opts.name, identifier: opts.identifier, platform: opts.platform },
+      },
+    },
+  })
+  printSuccess(`Bundle ID registered: ${result.data.data.id} (${opts.identifier})`)
+}
+
+// ---- Provisioning Profiles ----
+
+export async function profilesList(opts: {
+  type?: string
+  name?: string
+  output?: string
+} = {}): Promise<void> {
+  const params: Record<string, string> = {
+    "fields[profiles]": "name,profileType,profileState,expirationDate,uuid",
+  }
+  if (opts.type) params["filter[profileType]"] = opts.type
+  if (opts.name) params["filter[name]"] = opts.name
+  const items = await ascFetchAll<{
+    id: string
+    attributes: {
+      name?: string
+      profileType?: string
+      profileState?: string
+      expirationDate?: string
+      uuid?: string
+    }
+  }>("/v1/profiles", { params })
+  const fmt = detectFormat(opts.output)
+  if (fmt === "json") { printJSON(items); return }
+  printTable(
+    ["ID", "Name", "Type", "State", "Expires"],
+    items.map(p => [
+      p.id,
+      p.attributes.name ?? "-",
+      p.attributes.profileType ?? "-",
+      p.attributes.profileState ?? "-",
+      formatDate(p.attributes.expirationDate ?? ""),
+    ]),
+    `Provisioning Profiles (${items.length})`,
+  )
+}
+
+export async function profileDelete(profileId: string): Promise<void> {
+  await ascFetch(`/v1/profiles/${profileId}`, { method: "DELETE" })
+  printSuccess(`Profile ${profileId} deleted`)
+}

package/src/commands/subscriptions.ts

@@ -0,0 +1,144 @@
+import { ascFetch, ascFetchAll } from "../api/client.ts"
+import { detectFormat, printJSON, printSuccess, printTable, truncate } from "../utils/output.ts"
+
+// ---- Subscription Groups ----
+
+export async function subscriptionGroupsList(opts: { appId: string; output?: string }): Promise<void> {
+  const items = await ascFetchAll<{
+    id: string
+    attributes: { referenceName?: string; subscriptions?: number }
+  }>(`/v1/apps/${opts.appId}/subscriptionGroups`, {
+    params: { "fields[subscriptionGroups]": "referenceName,subscriptions" },
+  })
+  const fmt = detectFormat(opts.output)
+  if (fmt === "json") { printJSON(items); return }
+  printTable(
+    ["Group ID", "Reference Name"],
+    items.map(g => [g.id, g.attributes.referenceName ?? "-"]),
+    `Subscription Groups (${items.length})`,
+  )
+}
+
+export async function subscriptionGroupCreate(opts: {
+  appId: string
+  referenceName: string
+}): Promise<void> {
+  const result = await ascFetch<{ data: { id: string } }>("/v1/subscriptionGroups", {
+    method: "POST",
+    body: {
+      data: {
+        type: "subscriptionGroups",
+        attributes: { referenceName: opts.referenceName },
+        relationships: { app: { data: { type: "apps", id: opts.appId } } },
+      },
+    },
+  })
+  printSuccess(`Created subscription group: ${result.data.data.id}`)
+}
+
+// ---- Subscriptions ----
+
+export async function subscriptionsList(opts: { groupId: string; output?: string }): Promise<void> {
+  const items = await ascFetchAll<{
+    id: string
+    attributes: {
+      name?: string
+      productId?: string
+      subscriptionPeriod?: string
+      state?: string
+      familySharable?: boolean
+    }
+  }>(`/v1/subscriptionGroups/${opts.groupId}/subscriptions`, {
+    params: { "fields[subscriptions]": "name,productId,subscriptionPeriod,state,familySharable" },
+  })
+  const fmt = detectFormat(opts.output)
+  if (fmt === "json") { printJSON(items); return }
+  printTable(
+    ["ID", "Name", "Product ID", "Period", "State"],
+    items.map(s => [
+      s.id,
+      truncate(s.attributes.name ?? "-", 30),
+      s.attributes.productId ?? "-",
+      s.attributes.subscriptionPeriod ?? "-",
+      s.attributes.state ?? "-",
+    ]),
+    `Subscriptions (${items.length})`,
+  )
+}
+
+export async function subscriptionGet(subId: string, opts: { output?: string } = {}): Promise<void> {
+  const result = await ascFetch<{
+    data: {
+      id: string
+      attributes: {
+        name?: string
+        productId?: string
+        subscriptionPeriod?: string
+        state?: string
+        familySharable?: boolean
+        reviewNote?: string
+        availableInAllTerritories?: boolean
+        groupLevel?: number
+      }
+    }
+  }>(`/v1/subscriptions/${subId}`)
+  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(`Name:          ${a.name ?? "-"}`)
+  console.log(`Product ID:    ${a.productId ?? "-"}`)
+  console.log(`Period:        ${a.subscriptionPeriod ?? "-"}`)
+  console.log(`State:         ${a.state ?? "-"}`)
+  console.log(`Group Level:   ${a.groupLevel ?? "-"}`)
+  console.log(`Family Share:  ${a.familySharable ?? false}`)
+  console.log(`All Territ.:   ${a.availableInAllTerritories ?? false}`)
+}
+
+export async function subscriptionCreate(opts: {
+  groupId: string
+  name: string
+  productId: string
+  period: string
+}): Promise<void> {
+  const result = await ascFetch<{ data: { id: string } }>("/v1/subscriptions", {
+    method: "POST",
+    body: {
+      data: {
+        type: "subscriptions",
+        attributes: {
+          name: opts.name,
+          productId: opts.productId,
+          subscriptionPeriod: opts.period,
+        },
+        relationships: {
+          group: { data: { type: "subscriptionGroups", id: opts.groupId } },
+        },
+      },
+    },
+  })
+  printSuccess(`Created subscription: ${result.data.data.id} (${opts.productId})`)
+}
+
+export async function subscriptionPricesList(opts: {
+  subId: string
+  territory?: string
+  output?: string
+}): Promise<void> {
+  const params: Record<string, string> = {
+    "fields[subscriptionPrices]": "startDate,territory",
+    include: "subscriptionPricePoint",
+  }
+  if (opts.territory) params["filter[territory]"] = opts.territory
+  const items = await ascFetchAll<{
+    id: string
+    attributes: { startDate?: string; territory?: unknown }
+  }>(`/v1/subscriptions/${opts.subId}/prices`, { params })
+  const fmt = detectFormat(opts.output)
+  if (fmt === "json") { printJSON(items); return }
+  printTable(
+    ["Price ID", "Territory", "Start Date"],
+    items.map(p => [p.id, String(p.attributes.territory ?? "-"), p.attributes.startDate ?? "ongoing"]),
+    `Subscription Prices (${items.length})`,
+  )
+}

package/src/commands/testflight.ts

@@ -0,0 +1,110 @@
+import * as p from "@clack/prompts"
+import { ascFetch, ascFetchAll } from "../api/client.ts"
+import type { BetaGroup, BetaTester } from "../api/types.ts"
+import { detectFormat, formatDate, printJSON, printSuccess, printTable, truncate } from "../utils/output.ts"
+
+export async function testflightGroupsList(opts: {
+  appId?: string
+  output?: string
+} = {}): Promise<void> {
+  let groups: BetaGroup[]
+  if (opts.appId) {
+    groups = await ascFetchAll<BetaGroup>(`/v1/apps/${opts.appId}/betaGroups`)
+  } else {
+    groups = await ascFetchAll<BetaGroup>("/v1/betaGroups")
+  }
+
+  const fmt = detectFormat(opts.output)
+  if (fmt === "json") {
+    printJSON(groups.map((g) => ({ id: g.id, ...g.attributes })))
+    return
+  }
+
+  printTable(
+    ["ID", "Name", "Internal", "Public Link"],
+    groups.map((g) => [
+      g.id,
+      g.attributes.name,
+      g.attributes.isInternalGroup ? "yes" : "no",
+      g.attributes.publicLink ?? "-",
+    ]),
+    `Beta Groups (${groups.length})`,
+  )
+}
+
+export async function testflightTestersList(opts: {
+  groupId: string
+  output?: string
+}): Promise<void> {
+  const testers = await ascFetchAll<BetaTester>(
+    `/v1/betaGroups/${opts.groupId}/betaTesters`,
+    {
+      params: { "fields[betaTesters]": "firstName,lastName,email,inviteType,state" },
+    },
+  )
+
+  const fmt = detectFormat(opts.output)
+  if (fmt === "json") {
+    printJSON(testers.map((t) => ({ id: t.id, ...t.attributes })))
+    return
+  }
+
+  printTable(
+    ["ID", "Name", "Email", "State"],
+    testers.map((t) => [
+      t.id,
+      [t.attributes.firstName, t.attributes.lastName].filter(Boolean).join(" ") || "-",
+      t.attributes.email,
+      t.attributes.state ?? "-",
+    ]),
+    `Testers (${testers.length})`,
+  )
+}
+
+export async function testflightTestersAdd(opts: {
+  groupId: string
+  email?: string
+  firstName?: string
+  lastName?: string
+}): Promise<void> {
+  let email = opts.email
+  if (!email) {
+    const val = await p.text({ message: "Tester email:" })
+    if (p.isCancel(val)) { p.cancel("Cancelled"); process.exit(0) }
+    email = val as string
+  }
+
+  // Create tester + add to group
+  const res = await ascFetch<BetaTester>("/v1/betaTesters", {
+    method: "POST",
+    body: {
+      data: {
+        type: "betaTesters",
+        attributes: {
+          email,
+          firstName: opts.firstName,
+          lastName: opts.lastName,
+        },
+        relationships: {
+          betaGroups: {
+            data: [{ type: "betaGroups", id: opts.groupId }],
+          },
+        },
+      },
+    },
+  })
+  printSuccess(`Tester ${email} added (ID: ${res.data.id})`)
+}
+
+export async function testflightTestersRemove(opts: {
+  groupId: string
+  testerId: string
+}): Promise<void> {
+  await ascFetch(`/v1/betaGroups/${opts.groupId}/relationships/betaTesters`, {
+    method: "DELETE",
+    body: {
+      data: [{ type: "betaTesters", id: opts.testerId }],
+    },
+  })
+  printSuccess(`Tester ${opts.testerId} removed from group`)
+}

package/src/commands/versions.ts

@@ -0,0 +1,76 @@
+import { ascFetch, ascFetchAll } from "../api/client.ts"
+import type { AppStoreVersion, Platform } from "../api/types.ts"
+import { detectFormat, formatDate, printJSON, printSuccess, printTable } from "../utils/output.ts"
+
+export async function versionsList(opts: {
+  appId: string
+  platform?: string
+  output?: string
+}): Promise<void> {
+  const params: Record<string, string> = {
+    "fields[appStoreVersions]": "platform,versionString,appStoreState,createdDate",
+  }
+  if (opts.platform) params["filter[platform]"] = opts.platform.toUpperCase()
+
+  const versions = await ascFetchAll<AppStoreVersion>(
+    `/v1/apps/${opts.appId}/appStoreVersions`,
+    { params },
+  )
+
+  const fmt = detectFormat(opts.output)
+  if (fmt === "json") {
+    printJSON(versions.map((v) => ({ id: v.id, ...v.attributes })))
+    return
+  }
+
+  printTable(
+    ["ID", "Version", "Platform", "State", "Created"],
+    versions.map((v) => [
+      v.id,
+      v.attributes.versionString,
+      v.attributes.platform,
+      v.attributes.appStoreState,
+      formatDate(v.attributes.createdDate),
+    ]),
+    `Versions (${versions.length})`,
+  )
+}
+
+export async function versionsCreate(opts: {
+  appId: string
+  version: string
+  platform: string
+}): Promise<void> {
+  const platform = opts.platform.toUpperCase() as Platform
+  const res = await ascFetch<AppStoreVersion>("/v1/appStoreVersions", {
+    method: "POST",
+    body: {
+      data: {
+        type: "appStoreVersions",
+        attributes: {
+          platform,
+          versionString: opts.version,
+        },
+        relationships: {
+          app: { data: { type: "apps", id: opts.appId } },
+        },
+      },
+    },
+  })
+  printSuccess(`Created version ${opts.version} (${platform}) — ID: ${res.data.id}`)
+}
+
+export async function versionsSubmit(versionId: string): Promise<void> {
+  await ascFetch("/v1/appStoreVersionSubmissions", {
+    method: "POST",
+    body: {
+      data: {
+        type: "appStoreVersionSubmissions",
+        relationships: {
+          appStoreVersion: { data: { type: "appStoreVersions", id: versionId } },
+        },
+      },
+    },
+  })
+  printSuccess(`Version ${versionId} submitted for review`)
+}