@stacksjs/browser-extension 0.70.211 → 0.70.213

package/README.md

@@ -132,6 +132,11 @@ what `xcrun safari-web-extension-converter` generates, so day-to-day work
 never needs the converter; `--signed` builds need an Apple Development
 identity selected in Xcode.
 
+The provider-neutral App Store Connect client, certificate/profile
+provisioning, version reconciliation, and build attachment live in
+`ts-pantry`. Stacks keeps only the Safari-specific Bundle ID mapping, Xcode
+build orchestration, and listing configuration.
+
 When `safariAppStore` is configured, publishing also synchronizes the app
 description, category, content-rights declaration, pricing, age rating,
 territory availability, review contact, export compliance, and required

package/dist/app-store-connect.d.ts

@@ -1,7 +1,26 @@
-import type { AppStoreConnectAuth } from './safari';
+import { AppStoreConnectClient, provisionMacApp } from 'ts-pantry';
+import type { AppStoreConnectClientOptions, AppStoreVersionPlatform, BundleIdPlatform } from 'ts-pantry';
 import type { ExtensionConfig, SafariPlatform } from './types';
-/** Generate the short-lived ES256 team token required by App Store Connect. */
-export declare function appStoreConnectToken(auth: Required<AppStoreConnectAuth>, now?: unknown): string;
+export type {
+  AppAttributes,
+  AppStoreBuildAttachmentResult,
+  AppStoreBuildResult,
+  AppStoreConnectAuth,
+  AppStoreConnectClientOptions,
+  AppStoreConnectResource,
+  AppStoreVersionAttributes,
+  AppStoreVersionPlatform,
+  BuildAttributes,
+  BundleIdAttributes,
+  BundleIdCapabilityAttributes,
+  BundleIdPlatform,
+  CertificateAttributes,
+  MacAppProvisionOptions,
+  MacAppProvisionResult,
+  MacDistributionCertificateType,
+  PreReleaseVersionAttributes,
+  ProfileAttributes,
+} from 'ts-pantry';
 /** Wait for the uploaded binaries to process, then select them for their App Store versions. */
 export declare function attachSafariBuilds(client: AppStoreConnectClient, appId: string, versions: SafariAppStoreVersionResult[], buildNumber: string, options?: AttachSafariBuildsOptions): Promise<SafariBuildAttachmentResult[]>;
 /**
@@ -10,51 +29,6 @@ export declare function attachSafariBuilds(client: AppStoreConnectClient, appId:
  * app record. Apple does not expose an official API for creating that record.
  */
 export declare function provisionSafariApp(config: ExtensionConfig, options?: SafariProvisionOptions): Promise<SafariProvisionResult>;
-export declare interface AppStoreConnectResource<T extends Record<string, unknown>> {
-  type: string
-  id: string
-  attributes: T
-  relationships?: Record<string, { data?: { type: string, id: string } | null }>
-}
-export declare interface BundleIdAttributes extends Record<string, unknown> {
-  identifier: string
-  name: string
-  platform: BundleIdPlatform
-  seedId?: string
-}
-export declare interface AppAttributes extends Record<string, unknown> {
-  bundleId: string
-  name: string
-  primaryLocale: string
-  sku: string
-}
-export declare interface AppStoreVersionAttributes extends Record<string, unknown> {
-  platform: AppStoreVersionPlatform
-  versionString: string
-  appStoreState: string
-}
-export declare interface BuildAttributes extends Record<string, unknown> {
-  version: string
-  uploadedDate: string
-  expired: boolean
-  processingState: string
-}
-export declare interface PreReleaseVersionAttributes extends Record<string, unknown> {
-  version: string
-  platform: AppStoreVersionPlatform
-}
-export declare interface AppStoreBuildResult {
-  id: string
-  buildNumber: string
-  version: string
-  platform: AppStoreVersionPlatform
-  processingState: string
-}
-export declare interface AppStoreConnectClientOptions extends AppStoreConnectAuth {
-  baseUrl?: string
-  fetch?: typeof globalThis.fetch
-  now?: () => number
-}
 export declare interface SafariAppStoreVersionResult {
   platform: SafariPlatform
   version: string
@@ -87,20 +61,8 @@ export declare interface SafariProvisionResult {
   appRecord: { exists: boolean, id?: string }
   appStoreVersions: SafariAppStoreVersionResult[]
 }
-export type BundleIdPlatform = 'IOS' | 'MAC_OS' | 'UNIVERSAL';
-export type AppStoreVersionPlatform = 'IOS' | 'MAC_OS';
-/** Minimal official App Store Connect client for Safari provisioning checks. */
-export declare class AppStoreConnectClient {
-  constructor(options?: AppStoreConnectClientOptions);
-  request<T>(path: string, init?: RequestInit): Promise<T>;
-  upload(url: string, init: RequestInit): Promise<void>;
-  findBundleId(identifier: string): Promise<AppStoreConnectResource<BundleIdAttributes> | undefined>;
-  registerBundleId(identifier: string, name: string, platform?: BundleIdPlatform): Promise<AppStoreConnectResource<BundleIdAttributes>>;
-  ensureBundleId(identifier: string, name: string, options?: { checkOnly?: boolean, platform?: BundleIdPlatform }): Promise<{ bundleId?: AppStoreConnectResource<BundleIdAttributes>, created: boolean }>;
-  findApp(bundleId: string): Promise<AppStoreConnectResource<AppAttributes> | undefined>;
-  listAppStoreVersions(appId: string): Promise<Array<AppStoreConnectResource<AppStoreVersionAttributes>>>;
-  createAppStoreVersion(appId: string, platform: AppStoreVersionPlatform, versionString: string): Promise<AppStoreConnectResource<AppStoreVersionAttributes>>;
-  updateAppStoreVersion(versionId: string, versionString: string): Promise<AppStoreConnectResource<AppStoreVersionAttributes>>;
-  listBuilds(appId: string, buildNumber: string): Promise<AppStoreBuildResult[]>;
-  attachBuild(versionId: string, buildId: string): Promise<void>;
-}
+export {
+  AppStoreConnectClient,
+  provisionMacApp,
+};
+export { appStoreConnectToken } from 'ts-pantry';

package/dist/app-store-connect.js

@@ -1,244 +1,40 @@
-import { createPrivateKey, sign } from "node:crypto";
-import { readFileSync } from "node:fs";
-import { resolveAppStoreConnectAuth } from "./safari";
-const appStoreConnectBaseUrl = "https://api.appstoreconnect.apple.com/v1";
-function apiErrorMessages(error) {
-  const messages = [error.detail ?? error.title ?? error.code].filter((message) => Boolean(message));
-  for (const associated of Object.values(error.meta?.associatedErrors ?? {}))
-    for (const nested of associated)
-      messages.push(...apiErrorMessages(nested));
-  return messages;
-}
-function base64urlJson(value) {
-  return Buffer.from(JSON.stringify(value)).toString("base64url");
-}
-export function appStoreConnectToken(auth, now = Math.floor(Date.now() / 1000)) {
-  const header = { alg: "ES256", kid: auth.keyId, typ: "JWT" }, payload = {
-    iss: auth.issuerId,
-    iat: now,
-    exp: now + 120,
-    aud: "appstoreconnect-v1"
-  }, input = `${base64urlJson(header)}.${base64urlJson(payload)}`;
-  let key;
-  try {
-    key = createPrivateKey(readFileSync(auth.keyPath, "utf8"));
-  } catch (error) {
-    throw Error(`[browser-extension] App Store Connect API key could not be parsed: ${error instanceof Error ? error.message : String(error)}`);
-  }
-  const signature = sign("sha256", Buffer.from(input), { key, dsaEncoding: "ieee-p1363" });
-  return `${input}.${signature.toString("base64url")}`;
-}
+import {
+  AppStoreConnectClient,
+  ensureAppStoreVersions,
+  provisionMacApp,
+  waitForAppStoreBuilds
+} from "ts-pantry";
 
-export class AppStoreConnectClient {
-  auth;
-  baseUrl;
-  fetcher;
-  now;
-  constructor(options = {}) {
-    this.auth = resolveAppStoreConnectAuth(options);
-    this.baseUrl = (options.baseUrl ?? appStoreConnectBaseUrl).replace(/\/$/, "");
-    this.fetcher = options.fetch ?? globalThis.fetch;
-    this.now = options.now ?? (() => Math.floor(Date.now() / 1000));
-  }
-  async request(path, init = {}) {
-    const url = /^https?:\/\//.test(path) ? path : /^\/v\d+\//.test(path) ? `${new URL(this.baseUrl).origin}${path}` : `${this.baseUrl}${path}`, response = await this.fetcher(url, {
-      ...init,
-      headers: {
-        Accept: "application/json",
-        Authorization: `Bearer ${appStoreConnectToken(this.auth, this.now())}`,
-        ...init.body ? { "Content-Type": "application/json" } : {},
-        ...init.headers
-      }
-    });
-    if (!response.ok) {
-      const body = await response.json().catch(() => ({})), details = [...new Set(body.errors?.flatMap(apiErrorMessages) ?? [])].join("; ");
-      throw Error(`[browser-extension] App Store Connect ${init.method ?? "GET"} ${path} failed (${response.status})${details ? `: ${details}` : ""}`);
-    }
-    if (response.status === 204)
-      return;
-    return await response.json();
-  }
-  async upload(url, init) {
-    const response = await this.fetcher(url, init);
-    if (!response.ok)
-      throw Error(`[browser-extension] App Store Connect asset upload failed (${response.status})`);
-  }
-  async findBundleId(identifier) {
-    const query = new URLSearchParams({ "filter[identifier]": identifier });
-    return (await this.request(`/bundleIds?${query}`)).data.find((bundleId) => bundleId.attributes.identifier === identifier);
-  }
-  async registerBundleId(identifier, name, platform = "MAC_OS") {
-    return (await this.request("/bundleIds", {
-      method: "POST",
-      body: JSON.stringify({
-        data: {
-          type: "bundleIds",
-          attributes: { identifier, name, platform }
-        }
-      })
-    })).data;
-  }
-  async ensureBundleId(identifier, name, options = {}) {
-    const existing = await this.findBundleId(identifier);
-    if (existing)
-      return { bundleId: existing, created: !1 };
-    if (options.checkOnly)
-      return { created: !1 };
-    return {
-      bundleId: await this.registerBundleId(identifier, name, options.platform),
-      created: !0
-    };
-  }
-  async findApp(bundleId) {
-    const query = new URLSearchParams({ "filter[bundleId]": bundleId });
-    return (await this.request(`/apps?${query}`)).data.find((app) => app.attributes.bundleId === bundleId);
-  }
-  async listAppStoreVersions(appId) {
-    return (await this.request(`/apps/${appId}/appStoreVersions?limit=200`)).data;
-  }
-  async createAppStoreVersion(appId, platform, versionString) {
-    return (await this.request("/appStoreVersions", {
-      method: "POST",
-      body: JSON.stringify({
-        data: {
-          type: "appStoreVersions",
-          attributes: { platform, versionString },
-          relationships: { app: { data: { type: "apps", id: appId } } }
-        }
-      })
-    })).data;
-  }
-  async updateAppStoreVersion(versionId, versionString) {
-    return (await this.request(`/appStoreVersions/${versionId}`, {
-      method: "PATCH",
-      body: JSON.stringify({
-        data: {
-          type: "appStoreVersions",
-          id: versionId,
-          attributes: { versionString }
-        }
-      })
-    })).data;
-  }
-  async listBuilds(appId, buildNumber) {
-    const query = new URLSearchParams({
-      "filter[app]": appId,
-      "filter[version]": buildNumber,
-      include: "preReleaseVersion",
-      limit: "20",
-      "fields[builds]": "version,uploadedDate,expired,processingState,preReleaseVersion",
-      "fields[preReleaseVersions]": "version,platform"
-    }), response = await this.request(`/builds?${query}`), preReleaseVersions = new Map((response.included ?? []).filter((item) => item.type === "preReleaseVersions").map((item) => [item.id, item.attributes]));
-    return response.data.flatMap((build) => {
-      const preReleaseVersionId = build.relationships?.preReleaseVersion?.data?.id, preReleaseVersion = preReleaseVersionId ? preReleaseVersions.get(preReleaseVersionId) : void 0;
-      if (!preReleaseVersion)
-        return [];
-      return [{
-        id: build.id,
-        buildNumber: build.attributes.version,
-        version: preReleaseVersion.version,
-        platform: preReleaseVersion.platform,
-        processingState: build.attributes.processingState
-      }];
-    });
-  }
-  async attachBuild(versionId, buildId) {
-    await this.request(`/appStoreVersions/${versionId}/relationships/build`, {
-      method: "PATCH",
-      body: JSON.stringify({ data: { type: "builds", id: buildId } })
-    });
-  }
-}
-const editableVersionStates = new Set([
-  "PREPARE_FOR_SUBMISSION",
-  "DEVELOPER_REJECTED",
-  "REJECTED",
-  "METADATA_REJECTED",
-  "INVALID_BINARY"
-]), releasedVersionStates = new Set([
-  "READY_FOR_DISTRIBUTION",
-  "READY_FOR_SALE",
-  "DEVELOPER_REMOVED_FROM_SALE",
-  "REMOVED_FROM_SALE"
-]);
+export {
+  AppStoreConnectClient,
+  provisionMacApp
+};
+export { appStoreConnectToken } from "ts-pantry";
 function appStorePlatform(platform) {
   return platform === "ios" ? "IOS" : "MAC_OS";
 }
 export async function attachSafariBuilds(client, appId, versions, buildNumber, options = {}) {
-  const timeoutMs = options.timeoutMs ?? 1200000, pollIntervalMs = options.pollIntervalMs ?? 15000, deadline = Date.now() + timeoutMs, pending = new Map(versions.map((version) => [appStorePlatform(version.platform), version]));
-  while (!0) {
-    const builds = await client.listBuilds(appId, buildNumber), attachments = [];
-    for (const [platform, version] of pending) {
-      const build = builds.find((item) => item.platform === platform && item.version === version.version);
-      if (!build)
-        continue;
-      if (build.processingState === "FAILED" || build.processingState === "INVALID")
-        throw Error(`[browser-extension] Safari ${version.platform} build ${buildNumber} failed App Store Connect processing (${build.processingState})`);
-      if (build.processingState !== "VALID")
-        continue;
-      attachments.push({
-        platform: version.platform,
-        versionId: version.id,
-        buildId: build.id,
-        buildNumber
-      });
-    }
-    if (attachments.length === pending.size) {
-      for (const attachment of attachments)
-        await client.attachBuild(attachment.versionId, attachment.buildId);
-      return attachments;
-    }
-    if (Date.now() >= deadline) {
-      const waiting = [...pending.values()].map((item) => item.platform).join(", ");
-      throw Error(`[browser-extension] timed out waiting for Safari ${waiting} build ${buildNumber} to finish App Store Connect processing`);
-    }
-    await Bun.sleep(pollIntervalMs);
-  }
+  const pantryVersions = versions.map((version) => ({
+    platform: appStorePlatform(version.platform),
+    version: version.version,
+    id: version.id
+  }));
+  return (await waitForAppStoreBuilds(client, appId, pantryVersions, buildNumber, options)).map((attachment) => ({
+    platform: attachment.platform === "IOS" ? "ios" : "macos",
+    versionId: attachment.versionId,
+    buildId: attachment.buildId,
+    buildNumber: attachment.buildNumber
+  }));
 }
 async function ensureConfiguredAppStoreVersions(client, appId, platforms, version) {
-  const versions = await client.listAppStoreVersions(appId), results = [];
-  for (const platform of [...new Set(platforms)]) {
-    const applePlatform = appStorePlatform(platform), exact = versions.find((item) => item.attributes.platform === applePlatform && item.attributes.versionString === version);
-    if (exact) {
-      const appStoreState = exact.attributes.appStoreState, status = editableVersionStates.has(appStoreState) ? "ready" : releasedVersionStates.has(appStoreState) ? "published" : "deferred";
-      results.push({
-        platform,
-        version,
-        created: !1,
-        updated: !1,
-        id: exact.id,
-        status,
-        appStoreState,
-        ...status === "deferred" ? { reason: `Safari ${platform} version ${version} is already ${appStoreState}` } : {}
-      });
-      continue;
-    }
-    const editable = versions.find((item) => item.attributes.platform === applePlatform && editableVersionStates.has(item.attributes.appStoreState));
-    if (editable) {
-      const updated = await client.updateAppStoreVersion(editable.id, version);
-      editable.attributes.versionString = version;
-      results.push({ platform, version, created: !1, updated: !0, id: updated.id, status: "ready", appStoreState: updated.attributes.appStoreState });
-      continue;
-    }
-    const blocking = versions.find((item) => item.attributes.platform === applePlatform && !releasedVersionStates.has(item.attributes.appStoreState));
-    if (blocking) {
-      results.push({
-        platform,
-        version,
-        created: !1,
-        updated: !1,
-        id: blocking.id,
-        status: "deferred",
-        appStoreState: blocking.attributes.appStoreState,
-        reason: `Safari ${platform} version ${version} is queued behind ${blocking.attributes.versionString} (${blocking.attributes.appStoreState})`
-      });
-      continue;
-    }
-    const created = await client.createAppStoreVersion(appId, applePlatform, version);
-    versions.push(created);
-    results.push({ platform, version, created: !0, updated: !1, id: created.id, status: "ready", appStoreState: created.attributes.appStoreState });
-  }
-  return results;
+  return (await ensureAppStoreVersions(client, appId, platforms.map((platform) => ({ platform: appStorePlatform(platform), version })))).map((result) => {
+    const platform = result.platform === "IOS" ? "ios" : "macos";
+    return {
+      ...result,
+      platform,
+      ...result.reason ? { reason: result.reason.replace(`${result.platform} version`, `Safari ${platform} version`) } : {}
+    };
+  });
 }
 export async function provisionSafariApp(config, options = {}) {
   if (!config.safariBundleId)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/browser-extension",
   "type": "module",
-  "version": "0.70.211",
+  "version": "0.70.213",
   "description": "Build MV3 browser extensions (Chrome, Firefox, Safari) the Stacks way — manifest, content/background scripts, DNR rules, packaging, Safari container app, all config-driven.",
   "author": "Chris Breuer",
   "contributors": [
@@ -52,6 +52,9 @@
     "dist",
     "safari-template"
   ],
+  "dependencies": {
+    "ts-pantry": "^0.11.0"
+  },
   "scripts": {
     "build": "bun build.ts",
     "typecheck": "bun tsc --noEmit",