@onmyway133/asc-cli 1.0.1

package/src/commands/auth.ts

@@ -0,0 +1,327 @@
+import * as p from "@clack/prompts"
+import chalk from "chalk"
+import { existsSync, readFileSync } from "fs"
+import {
+  addOrUpdateProfile,
+  credentialsPath,
+  getActiveProfile,
+  loadCredentials,
+  removeProfile,
+  saveCredentials,
+  setActiveProfile,
+  updateProfile,
+  type Profile,
+} from "../auth/credentials.ts"
+import { deleteFromKeychain, generateJWT, saveToKeychain } from "../auth/jwt.ts"
+import { printError, printSuccess, printTable } from "../utils/output.ts"
+
+export async function authLogin(args: {
+  name?: string
+  keyId?: string
+  issuerId?: string
+  privateKey?: string
+  bypassKeychain?: boolean
+}): Promise<void> {
+  p.intro(chalk.bold("App Store Connect — Login"))
+
+  let name = args.name
+  let keyId = args.keyId
+  let issuerId = args.issuerId
+  let privateKey = args.privateKey
+
+  // Interactive prompts for missing values
+  if (!keyId) {
+    const val = await p.text({ message: "Key ID (from App Store Connect API Keys):" })
+    if (p.isCancel(val)) { p.cancel("Cancelled"); process.exit(0) }
+    keyId = val as string
+  }
+
+  if (!issuerId) {
+    const val = await p.text({ message: "Issuer ID:" })
+    if (p.isCancel(val)) { p.cancel("Cancelled"); process.exit(0) }
+    issuerId = val as string
+  }
+
+  if (!privateKey) {
+    const val = await p.text({
+      message: "Path to private key (.p8 file):",
+      placeholder: "~/.asc/AuthKey_XXXXXX.p8",
+    })
+    if (p.isCancel(val)) { p.cancel("Cancelled"); process.exit(0) }
+    privateKey = val as string
+  }
+
+  if (!name) {
+    const existing = loadCredentials()
+    const defaultName = existing.profiles.length === 0 ? "default" : undefined
+    const val = await p.text({
+      message: "Profile name:",
+      placeholder: defaultName ?? "work",
+      defaultValue: defaultName,
+    })
+    if (p.isCancel(val)) { p.cancel("Cancelled"); process.exit(0) }
+    name = (val as string) || "default"
+  }
+
+  // Expand ~ in path
+  const expandedPath = privateKey.trim().replace(/^~/, process.env["HOME"] ?? "")
+  if (!existsSync(expandedPath)) {
+    printError(new Error(`Private key file not found: ${expandedPath}`))
+    process.exit(1)
+  }
+
+  const spinner = p.spinner()
+  spinner.start("Validating credentials…")
+
+  const profile: Profile = {
+    name,
+    keyId,
+    issuerId,
+    privateKeyPath: privateKey,
+    isDefault: loadCredentials().profiles.length === 0,
+  }
+
+  // Try storing in keychain
+  let storedInKeychain = false
+  if (!args.bypassKeychain) {
+    const pem = readFileSync(expandedPath, "utf8")
+    storedInKeychain = saveToKeychain(name, pem)
+    if (storedInKeychain) {
+      // Don't need path if stored in keychain
+      profile.storedInKeychain = true
+    }
+  }
+
+  // Validate by generating JWT
+  try {
+    await generateJWT(profile)
+    spinner.stop("Credentials validated")
+  } catch (err) {
+    spinner.stop("Validation failed")
+    printError(err)
+    process.exit(1)
+  }
+
+  addOrUpdateProfile(profile)
+
+  const keychainNote = storedInKeychain ? chalk.dim(" (private key stored in Keychain)") : ""
+  printSuccess(`Profile "${chalk.cyan(name)}" saved${keychainNote}`)
+  console.log(chalk.dim(`  Credentials: ${credentialsPath()}`))
+  p.outro("You're all set! Run " + chalk.cyan("asc apps list") + " to get started.")
+}
+
+export function authList(): void {
+  const creds = loadCredentials()
+  if (creds.profiles.length === 0) {
+    console.log(chalk.dim("No profiles configured. Run: asc auth login"))
+    return
+  }
+  printTable(
+    ["Profile", "Key ID", "Issuer ID", "Active"],
+    creds.profiles.map((p) => [
+      p.name,
+      p.keyId,
+      p.issuerId,
+      creds.activeProfile === p.name ? chalk.green("✓") : "",
+    ]),
+    "Profiles",
+  )
+}
+
+export async function authUse(name?: string): Promise<void> {
+  const creds = loadCredentials()
+  if (creds.profiles.length === 0) {
+    console.log(chalk.dim("No profiles. Run: asc auth login"))
+    return
+  }
+
+  let profileName = name
+  if (!profileName) {
+    const choice = await p.select({
+      message: "Select profile to activate:",
+      options: creds.profiles.map((pr) => ({
+        value: pr.name,
+        label: pr.name,
+        hint: pr.name === creds.activeProfile ? "active" : undefined,
+      })),
+    })
+    if (p.isCancel(choice)) { p.cancel("Cancelled"); process.exit(0) }
+    profileName = choice as string
+  }
+
+  if (!setActiveProfile(profileName)) {
+    printError(new Error(`Profile "${profileName}" not found`))
+    process.exit(1)
+  }
+  printSuccess(`Active profile set to "${chalk.cyan(profileName)}"`)
+}
+
+export async function authStatus(opts: { validate?: boolean } = {}): Promise<void> {
+  const profile = getActiveProfile()
+  if (!profile) {
+    console.log(chalk.dim("No active profile. Run: asc auth login"))
+    return
+  }
+
+  console.log(chalk.bold("Active profile:"), chalk.cyan(profile.name))
+  console.log("  Key ID:    ", profile.keyId)
+  console.log("  Issuer ID: ", profile.issuerId)
+  if (profile.privateKeyPath) {
+    console.log("  Key path:  ", profile.privateKeyPath)
+  }
+  if (profile.storedInKeychain) {
+    console.log("  Keychain:  ", chalk.green("yes"))
+  }
+
+  if (opts.validate) {
+    const spinner = p.spinner()
+    spinner.start("Validating token…")
+    try {
+      await generateJWT(profile)
+      spinner.stop(chalk.green("Token generated successfully"))
+    } catch (err) {
+      spinner.stop(chalk.red("Token generation failed"))
+      printError(err)
+    }
+  }
+}
+
+export async function authLogout(name?: string): Promise<void> {
+  const creds = loadCredentials()
+  let profileName = name
+
+  if (!profileName) {
+    if (creds.profiles.length === 0) {
+      console.log(chalk.dim("No profiles configured."))
+      return
+    }
+    const choice = await p.select({
+      message: "Select profile to remove:",
+      options: creds.profiles.map((pr) => ({
+        value: pr.name,
+        label: pr.name,
+        hint: pr.name === creds.activeProfile ? "active" : undefined,
+      })),
+    })
+    if (p.isCancel(choice)) { p.cancel("Cancelled"); process.exit(0) }
+    profileName = choice as string
+  }
+
+  const confirm = await p.confirm({
+    message: `Remove profile "${profileName}"?`,
+  })
+  if (p.isCancel(confirm) || !confirm) {
+    p.cancel("Cancelled")
+    return
+  }
+
+  deleteFromKeychain(profileName)
+  if (removeProfile(profileName)) {
+    printSuccess(`Profile "${chalk.cyan(profileName)}" removed`)
+  } else {
+    printError(new Error(`Profile "${profileName}" not found`))
+  }
+}
+
+// ---- Profile management (dedicated subcommand) ----
+
+export function profileView(name?: string): void {
+  const creds = loadCredentials()
+  const profileName = name ?? creds.activeProfile
+  const profile = creds.profiles.find((p) => p.name === profileName)
+  if (!profile) {
+    printError(new Error(`Profile "${profileName}" not found. Run: asc auth list`))
+    process.exit(1)
+  }
+  const isActive = creds.activeProfile === profile.name
+  console.log(chalk.bold(`Profile: ${chalk.cyan(profile.name)}`) + (isActive ? chalk.green("  ← active") : ""))
+  console.log(`  Key ID:         ${profile.keyId}`)
+  console.log(`  Issuer ID:      ${profile.issuerId}`)
+  if (profile.privateKeyPath) {
+    console.log(`  Key path:       ${profile.privateKeyPath}`)
+  }
+  console.log(`  In Keychain:    ${profile.storedInKeychain ? chalk.green("yes") : "no"}`)
+  if (profile.vendorNumber) {
+    console.log(`  Vendor Number:  ${profile.vendorNumber}`)
+  }
+  console.log(chalk.dim(`\n  Credentials file: ${credentialsPath()}`))
+}
+
+export async function profileUpdate(
+  name: string | undefined,
+  updates: {
+    keyId?: string
+    issuerId?: string
+    privateKey?: string
+    vendorNumber?: string
+    bypassKeychain?: boolean
+    renameTo?: string
+  },
+): Promise<void> {
+  const creds = loadCredentials()
+  const resolvedName = name ?? creds.activeProfile
+  const existing = creds.profiles.find((p) => p.name === resolvedName)
+  if (!existing) {
+    printError(new Error(`Profile "${resolvedName}" not found. Run: asc auth list`))
+    process.exit(1)
+  }
+
+  const changes: Partial<Omit<Profile, "name">> = {}
+  if (updates.keyId) changes.keyId = updates.keyId
+  if (updates.issuerId) changes.issuerId = updates.issuerId
+  if (updates.vendorNumber) changes.vendorNumber = updates.vendorNumber
+
+  if (updates.privateKey) {
+    const expandedPath = updates.privateKey.trim().replace(/^~/, process.env["HOME"] ?? "")
+    if (!existsSync(expandedPath)) {
+      printError(new Error(`Private key file not found: ${expandedPath}`))
+      process.exit(1)
+    }
+    changes.privateKeyPath = updates.privateKey
+
+    if (!updates.bypassKeychain) {
+      const pem = readFileSync(expandedPath, "utf8")
+      const stored = saveToKeychain(resolvedName, pem)
+      if (stored) {
+        changes.storedInKeychain = true
+      }
+    }
+  }
+
+  if (updates.renameTo) {
+    if (creds.profiles.find((p) => p.name === updates.renameTo)) {
+      printError(new Error(`Profile "${updates.renameTo}" already exists`))
+      process.exit(1)
+    }
+    // Move keychain entry to new name
+    if (existing.storedInKeychain) {
+      const { loadFromKeychain, saveToKeychain: save, deleteFromKeychain } = await import("../auth/jwt.ts")
+      const pem = loadFromKeychain(resolvedName)
+      if (pem) {
+        save(updates.renameTo, pem)
+        deleteFromKeychain(resolvedName)
+      }
+    }
+    // Rename in credentials file
+    const idx = creds.profiles.findIndex((p) => p.name === resolvedName)
+    creds.profiles[idx] = { ...creds.profiles[idx]!, ...changes, name: updates.renameTo }
+    if (creds.activeProfile === resolvedName) creds.activeProfile = updates.renameTo
+    saveCredentials(creds)
+    printSuccess(`Profile "${chalk.cyan(resolvedName)}" renamed to "${chalk.cyan(updates.renameTo)}"`)
+    profileView(updates.renameTo)
+    return
+  }
+
+  if (Object.keys(changes).length === 0) {
+    console.log(chalk.dim("Nothing to update. Provide at least one flag."))
+    return
+  }
+
+  updateProfile(resolvedName, changes)
+  printSuccess(`Profile "${chalk.cyan(resolvedName)}" updated`)
+  profileView(resolvedName)
+}
+
+export async function profileDelete(name?: string): Promise<void> {
+  return authLogout(name)
+}

package/src/commands/availability.ts

@@ -0,0 +1,52 @@
+import { ascFetch, ascFetchAll } from "../api/client.ts"
+import { detectFormat, printJSON, printTable } from "../utils/output.ts"
+
+export async function availabilityGet(appId: string, opts: { output?: string } = {}): Promise<void> {
+  const result = await ascFetch<{
+    data: { id: string; attributes: { availableInNewTerritories?: boolean } }
+    included?: Array<{ type: string; id: string; attributes?: { currency?: string; name?: string } }>
+  }>(`/v1/apps/${appId}/appAvailabilityV2`, {
+    params: {
+      include: "availableTerritories",
+      "fields[territories]": "currency,name",
+    },
+  })
+  const body = result.data
+  const fmt = detectFormat(opts.output)
+  if (fmt === "json") { printJSON(body); return }
+  console.log(`App ID:                       ${appId}`)
+  console.log(`Available in new territories: ${body.data.attributes?.availableInNewTerritories ?? "-"}`)
+  const territories = (body.included ?? []).filter(r => r.type === "territories")
+  if (territories.length) {
+    console.log(`\nEnabled Territories (${territories.length}):`)
+    printTable(
+      ["Territory Code", "Name", "Currency"],
+      territories.map(t => [t.id, t.attributes?.name ?? "-", t.attributes?.currency ?? "-"]),
+    )
+  }
+}
+
+export async function availabilityTerritoriesSet(opts: {
+  appId: string
+  territories: string[]
+  availableInNewTerritories?: boolean
+}): Promise<void> {
+  await ascFetch(`/v1/appAvailabilities`, {
+    method: "POST",
+    body: {
+      data: {
+        type: "appAvailabilities",
+        attributes: {
+          availableInNewTerritories: opts.availableInNewTerritories ?? true,
+        },
+        relationships: {
+          app: { data: { type: "apps", id: opts.appId } },
+          availableTerritories: {
+            data: opts.territories.map(t => ({ type: "territories", id: t })),
+          },
+        },
+      },
+    },
+  })
+  console.log(`Availability updated for app ${opts.appId}`)
+}

package/src/commands/beta-review.ts

@@ -0,0 +1,145 @@
+import { ascFetch, ascFetchAll } from "../api/client.ts"
+import { detectFormat, formatDate, printJSON, printSuccess, printTable, truncate } from "../utils/output.ts"
+
+// ---- Beta App Review Submissions ----
+
+export async function betaReviewSubmissionCreate(buildId: string): Promise<void> {
+  const result = await ascFetch<{ data: { id: string; attributes: { betaReviewState?: string } } }>(
+    "/v1/betaAppReviewSubmissions",
+    {
+      method: "POST",
+      body: {
+        data: {
+          type: "betaAppReviewSubmissions",
+          relationships: {
+            build: { data: { type: "builds", id: buildId } },
+          },
+        },
+      },
+    },
+  )
+  const state = result.data.data.attributes.betaReviewState
+  printSuccess(`Beta review submitted for build ${buildId} (state: ${state ?? "WAITING_FOR_REVIEW"})`)
+}
+
+export async function betaReviewSubmissionGet(buildId: string, opts: { output?: string } = {}): Promise<void> {
+  const items = await ascFetchAll<{
+    id: string
+    attributes: { betaReviewState?: string }
+    relationships?: { build?: { data?: { id: string } } }
+  }>("/v1/betaAppReviewSubmissions", {
+    params: { "filter[build]": buildId },
+  })
+  const fmt = detectFormat(opts.output)
+  if (fmt === "json") { printJSON(items); return }
+  if (items.length === 0) {
+    console.log(`No beta review submission found for build ${buildId}`)
+    return
+  }
+  for (const s of items) {
+    console.log(`Submission ID: ${s.id}`)
+    console.log(`State:         ${s.attributes.betaReviewState ?? "-"}`)
+  }
+}
+
+// ---- Beta App Review Details ----
+
+export async function betaReviewDetailGet(appId: string, opts: { output?: string } = {}): Promise<void> {
+  const result = await ascFetch<{
+    data: {
+      id: string
+      attributes: {
+        contactFirstName?: string
+        contactLastName?: string
+        contactPhone?: string
+        contactEmail?: string
+        demoAccountName?: string
+        demoAccountPassword?: string
+        demoAccountRequired?: boolean
+        notes?: string
+      }
+    }
+  }>(`/v1/apps/${appId}/betaAppReviewDetail`)
+  const fmt = detectFormat(opts.output)
+  if (fmt === "json") { printJSON(result.data.data); return }
+  const a = result.data.data.attributes
+  console.log(`Review Detail ID:   ${result.data.data.id}`)
+  console.log(`Contact:            ${a.contactFirstName ?? ""} ${a.contactLastName ?? ""}`)
+  console.log(`Contact Email:      ${a.contactEmail ?? "-"}`)
+  console.log(`Contact Phone:      ${a.contactPhone ?? "-"}`)
+  console.log(`Demo Account:       ${a.demoAccountRequired ? "Required" : "Not required"}`)
+  if (a.demoAccountRequired) {
+    console.log(`Demo Username:      ${a.demoAccountName ?? "-"}`)
+  }
+  if (a.notes) console.log(`Notes:              ${a.notes}`)
+}
+
+export async function betaReviewDetailUpdate(opts: {
+  appId: string
+  contactFirstName?: string
+  contactLastName?: string
+  contactEmail?: string
+  contactPhone?: string
+  demoAccountName?: string
+  demoAccountPassword?: string
+  demoAccountRequired?: boolean
+  notes?: string
+}): Promise<void> {
+  // First get the detail ID
+  const current = await ascFetch<{ data: { id: string } }>(`/v1/apps/${opts.appId}/betaAppReviewDetail`)
+  const detailId = current.data.data.id
+  const { appId, ...attributes } = opts
+  await ascFetch(`/v1/betaAppReviewDetails/${detailId}`, {
+    method: "PATCH",
+    body: {
+      data: {
+        type: "betaAppReviewDetails",
+        id: detailId,
+        attributes,
+      },
+    },
+  })
+  printSuccess(`Beta review details updated for app ${appId}`)
+}
+
+// ---- Build Beta Details ----
+
+export async function buildBetaDetailUpdate(opts: {
+  buildId: string
+  autoNotifyEnabled?: boolean
+}): Promise<void> {
+  const current = await ascFetch<{
+    data: { id: string }
+  }>(`/v1/builds/${opts.buildId}/buildBetaDetail`)
+  const detailId = current.data.data.id
+  await ascFetch(`/v1/buildBetaDetails/${detailId}`, {
+    method: "PATCH",
+    body: {
+      data: {
+        type: "buildBetaDetails",
+        id: detailId,
+        attributes: { autoNotifyEnabled: opts.autoNotifyEnabled },
+      },
+    },
+  })
+  printSuccess(`Build beta detail updated for build ${opts.buildId}`)
+}
+
+// ---- Beta Build Localizations ----
+
+export async function betaBuildLocalizationsList(opts: {
+  buildId: string
+  output?: string
+}): Promise<void> {
+  const items = await ascFetchAll<{
+    id: string
+    attributes: { locale?: string; whatsNew?: string }
+  }>(`/v1/builds/${opts.buildId}/betaBuildLocalizations`)
+  const fmt = detectFormat(opts.output)
+  if (fmt === "json") { printJSON(items); return }
+  printTable(
+    ["ID", "Locale", "What's New"],
+    items.map(l => [l.id, l.attributes.locale ?? "-", truncate(l.attributes.whatsNew ?? "-", 60)]),
+    `Beta Build Localizations (${items.length})`,
+  )
+}

package/src/commands/builds.ts

@@ -0,0 +1,97 @@
+import { ascFetch, ascFetchAll } from "../api/client.ts"
+import type { Build } from "../api/types.ts"
+import { detectFormat, formatDate, printJSON, printSuccess, printTable, truncate } from "../utils/output.ts"
+
+export async function buildsList(opts: {
+  appId?: string
+  version?: string
+  platform?: string
+  output?: string
+} = {}): Promise<void> {
+  const params: Record<string, string> = {
+    "fields[builds]": "version,uploadedDate,processingState,expired",
+    "limit": "200",
+  }
+  if (opts.appId) params["filter[app]"] = opts.appId
+  if (opts.version) params["filter[version]"] = opts.version
+  if (opts.platform) params["filter[platform]"] = opts.platform.toUpperCase()
+
+  const builds = await ascFetchAll<Build>("/v1/builds", { params })
+
+  const fmt = detectFormat(opts.output)
+  if (fmt === "json") {
+    printJSON(builds.map((b) => ({ id: b.id, ...b.attributes })))
+    return
+  }
+
+  printTable(
+    ["ID", "Version", "Uploaded", "State", "Expired"],
+    builds.map((b) => [
+      b.id,
+      b.attributes.version,
+      formatDate(b.attributes.uploadedDate),
+      b.attributes.processingState ?? "-",
+      b.attributes.expired ? "yes" : "no",
+    ]),
+    `Builds (${builds.length})`,
+  )
+}
+
+export async function buildsGet(buildId: string, opts: { output?: string } = {}): Promise<void> {
+  const res = await ascFetch<Build>(`/v1/builds/${buildId}`)
+  const b = res.data
+
+  const fmt = detectFormat(opts.output)
+  if (fmt === "json") {
+    printJSON({ id: b.id, ...b.attributes })
+    return
+  }
+
+  console.log(`ID:               ${b.id}`)
+  console.log(`Version:          ${b.attributes.version}`)
+  console.log(`Uploaded:         ${formatDate(b.attributes.uploadedDate)}`)
+  console.log(`Processing State: ${b.attributes.processingState ?? "-"}`)
+  console.log(`Expired:          ${b.attributes.expired ? "yes" : "no"}`)
+  console.log(`Min OS:           ${b.attributes.minOsVersion ?? "-"}`)
+}
+
+export async function buildsUpdateBetaNotes(opts: {
+  buildId: string
+  locale: string
+  notes: string
+}): Promise<void> {
+  // First get existing localizations
+  const res = await ascFetchAll<{ type: string; id: string; attributes: { locale: string; whatsNew?: string } }>(
+    `/v1/builds/${opts.buildId}/betaBuildLocalizations`,
+  )
+
+  const existing = res.find((l) => l.attributes.locale === opts.locale)
+
+  if (existing) {
+    await ascFetch(`/v1/betaBuildLocalizations/${existing.id}`, {
+      method: "PATCH",
+      body: {
+        data: {
+          type: "betaBuildLocalizations",
+          id: existing.id,
+          attributes: { whatsNew: opts.notes },
+        },
+      },
+    })
+    printSuccess(`Beta notes updated for locale "${opts.locale}"`)
+  } else {
+    await ascFetch("/v1/betaBuildLocalizations", {
+      method: "POST",
+      body: {
+        data: {
+          type: "betaBuildLocalizations",
+          attributes: { locale: opts.locale, whatsNew: opts.notes },
+          relationships: {
+            build: { data: { type: "builds", id: opts.buildId } },
+          },
+        },
+      },
+    })
+    printSuccess(`Beta notes created for locale "${opts.locale}"`)
+  }
+}