@stacksjs/browser-extension 0.70.143 → 0.70.145

package/README.md

@@ -85,8 +85,9 @@ Set `safariBundleId` in the config (the appex gets `<safariBundleId>.Extension`)
 and `safariTeamId` to the Apple Developer team used for signing. Set
 `safariPlatforms: ['macos', 'ios']` for a universal extension; iOS covers both
 iPhone and iPad. Stacks generates the current Apple-supported universal Xcode
-project from the same built extension, archives both platforms, and uploads
-both to the same App Store Connect app record. Publishing
+project from the same built extension, archives both platforms, uploads them
+to the same App Store Connect app record, waits for Apple processing, and
+selects each processed build on its matching App Store version. Publishing
 reads `APP_STORE_CONNECT_API_KEY_ID`, `APP_STORE_CONNECT_API_ISSUER_ID`, and
 `APP_STORE_CONNECT_API_KEY_PATH` from the environment. Run with
 `--validate-only` to exercise Apple's validation without uploading a build.

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

@@ -2,6 +2,8 @@ import type { AppStoreConnectAuth } from './safari';
 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;
+/** 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[]>;
 /**
  * Register the explicit container and extension Bundle IDs required by a
  * Safari Web Extension, then check for the manually-created App Store Connect
@@ -12,6 +14,7 @@ export declare interface AppStoreConnectResource<T extends Record<string, unknow
   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
@@ -30,6 +33,23 @@ export declare interface AppStoreVersionAttributes extends Record<string, unknow
   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
@@ -42,6 +62,16 @@ export declare interface SafariAppStoreVersionResult {
   updated: boolean
   id: string
 }
+export declare interface SafariBuildAttachmentResult {
+  platform: SafariPlatform
+  versionId: string
+  buildId: string
+  buildNumber: string
+}
+export declare interface AttachSafariBuildsOptions {
+  timeoutMs?: number
+  pollIntervalMs?: number
+}
 export declare interface SafariProvisionOptions extends AppStoreConnectClientOptions {
   checkOnly?: boolean
   platform?: BundleIdPlatform
@@ -66,4 +96,6 @@ export declare class AppStoreConnectClient {
   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>;
 }

package/dist/app-store-connect.js

@@ -47,6 +47,8 @@ export class AppStoreConnectClient {
       const details = (await response.json().catch(() => ({}))).errors?.map((error) => error.detail ?? error.title ?? error.code).filter(Boolean).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 findBundleId(identifier) {
@@ -106,6 +108,34 @@ export class AppStoreConnectClient {
       })
     })).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",
@@ -116,6 +146,37 @@ const editableVersionStates = new Set([
 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);
+  }
+}
 async function ensureConfiguredAppStoreVersions(client, appId, platforms, version) {
   const versions = await client.listAppStoreVersions(appId), results = [];
   for (const platform of [...new Set(platforms)]) {

package/dist/firefox-addons.d.ts

@@ -1,4 +1,5 @@
 import type { ExtensionConfig, FirefoxAddonsConfig } from './types';
+export declare function firefoxSignArgs(options: FirefoxSignArgsOptions): string[];
 /** Metadata accepted by AMO v5 when web-ext creates the first listed version. */
 export declare function firefoxListingMetadata(config: ExtensionConfig, store: FirefoxAddonsConfig): Record<string, unknown> | undefined;
 /** Resolve web-ext from PATH or from this package's declared dependency. */
@@ -22,3 +23,11 @@ export declare interface FirefoxPublishResult {
   artifacts: string[]
   channel: 'listed' | 'unlisted'
 }
+declare interface FirefoxSignArgsOptions {
+  executable: string
+  sourceDir: string
+  artifactsDir: string
+  channel: 'listed' | 'unlisted'
+  timeout: number
+  approvalTimeout: number
+}

package/dist/firefox-addons.js

@@ -4,6 +4,23 @@ import { createRequire } from "node:module";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import { buildExtension, resolveOutdir } from "./build";
+export function firefoxSignArgs(options) {
+  return [
+    options.executable,
+    "sign",
+    "--source-dir",
+    options.sourceDir,
+    "--artifacts-dir",
+    options.artifactsDir,
+    "--channel",
+    options.channel,
+    "--timeout",
+    String(options.timeout),
+    "--approval-timeout",
+    String(options.approvalTimeout),
+    "--no-input"
+  ];
+}
 function resolveFirefoxAuth(options) {
   const issuer = options.issuer ?? process.env.AMO_JWT_ISSUER ?? process.env.WEB_EXT_API_KEY, secret = options.secret ?? process.env.AMO_JWT_SECRET ?? process.env.WEB_EXT_API_SECRET, missing = [!issuer && "AMO_JWT_ISSUER", !secret && "AMO_JWT_SECRET"].filter(Boolean);
   if (missing.length)
@@ -50,22 +67,14 @@ export async function publishFirefoxExtension(config, options) {
   await mkdir(artifactsDir, { recursive: !0 });
   const before = new Set(existsSync(artifactsDir) ? readdirSync(artifactsDir) : []), tempDir = await mkdtemp(join(tmpdir(), "stacks-firefox-publish-"));
   try {
-    const args = [
+    const args = firefoxSignArgs({
       executable,
-      "sign",
-      "--source-dir",
       sourceDir,
-      "--artifacts-dir",
       artifactsDir,
-      "--channel",
-      store.channel ?? "listed",
-      "--timeout",
-      String(options.timeout ?? 300000),
-      "--approval-timeout",
-      String(options.approvalTimeout ?? 0),
-      "--no-input",
-      "--boring"
-    ], metadata = firefoxListingMetadata(config, store);
+      channel: store.channel ?? "listed",
+      timeout: options.timeout ?? 300000,
+      approvalTimeout: options.approvalTimeout ?? 0
+    }), metadata = firefoxListingMetadata(config, store);
     if (metadata) {
       const metadataPath = join(tempDir, "amo-metadata.json");
       await Bun.write(metadataPath, `${JSON.stringify(metadata, null, 2)}

package/dist/safari.d.ts

@@ -107,6 +107,8 @@ export declare interface SafariPublishOptions extends SafariSyncOptions, AppStor
   validateOnly?: boolean
   build?: boolean
   platforms?: SafariPlatform[]
+  processingTimeoutMs?: number
+  processingPollIntervalMs?: number
 }
 export declare interface SafariPublishedArtifact {
   platform: SafariPlatform
@@ -118,4 +120,5 @@ export declare interface SafariPublishResult {
   exportPath: string
   buildNumber: string
   artifacts: SafariPublishedArtifact[]
+  attachments: Array<{ platform: SafariPlatform, versionId: string, buildId: string, buildNumber: string }>
 }

package/dist/safari.js

@@ -327,12 +327,12 @@ export async function publishSafariApp(config, options) {
   const platforms = resolveSafariPlatforms(config, options.platforms);
   if (!platforms.length)
     throw Error("[browser-extension] Safari publishing needs at least one platform");
-  const { provisionSafariApp } = await import("./app-store-connect");
-  if (!(await provisionSafariApp(config, {
+  const { AppStoreConnectClient, attachSafariBuilds, provisionSafariApp } = await import("./app-store-connect"), provisioned = await provisionSafariApp(config, {
     ...auth,
     version: options.version,
     platforms
-  })).appRecord.exists)
+  });
+  if (!provisioned.appRecord.exists)
     throw Error("[browser-extension] the App Store Connect app record is missing; create it once in App Store Connect before publishing");
   if (options.build !== !1)
     await buildExtension(config, { target: "safari", version: options.version, cwd });
@@ -390,10 +390,15 @@ export async function publishSafariApp(config, options) {
     ], projectCwd, `Safari ${platform} export`);
     artifacts.push({ platform, archivePath, exportPath });
   }
+  const attachments = options.validateOnly ? [] : await attachSafariBuilds(new AppStoreConnectClient(auth), provisioned.appRecord.id, provisioned.appStoreVersions, buildNumber, {
+    timeoutMs: options.processingTimeoutMs,
+    pollIntervalMs: options.processingPollIntervalMs
+  }), firstArtifact = artifacts[0];
   return {
-    archivePath: artifacts[0].archivePath,
-    exportPath: artifacts[0].exportPath,
+    archivePath: firstArtifact.archivePath,
+    exportPath: firstArtifact.exportPath,
     buildNumber,
-    artifacts
+    artifacts,
+    attachments
   };
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/browser-extension",
   "type": "module",
-  "version": "0.70.143",
+  "version": "0.70.145",
   "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": [