@stacksjs/browser-extension 0.70.119 → 0.70.120

package/README.md

@@ -28,6 +28,7 @@ Safari with MAIN-world content scripts + `match_about_blank`).
 
 ```sh
 buddy extension:safari:init   # scaffold the Xcode container app into safari/
+buddy extension:safari:provision # register both Bundle IDs + check the app record
 buddy extension:safari:app    # build + sync into the appex + xcodebuild
 buddy extension:safari:publish # signed archive + App Store Connect upload
 ```

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

@@ -0,0 +1,50 @@
+import type { AppStoreConnectAuth } from './safari';
+import type { ExtensionConfig } from './types';
+/** Generate the short-lived ES256 team token required by App Store Connect. */
+export declare function appStoreConnectToken(auth: Required<AppStoreConnectAuth>, now?: unknown): string;
+/**
+ * Register the explicit container and extension Bundle IDs required by a
+ * Safari Web Extension, then check for the manually-created App Store Connect
+ * 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
+}
+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 AppStoreConnectClientOptions extends AppStoreConnectAuth {
+  baseUrl?: string
+  fetch?: typeof globalThis.fetch
+  now?: () => number
+}
+export declare interface SafariProvisionOptions extends AppStoreConnectClientOptions {
+  checkOnly?: boolean
+  platform?: BundleIdPlatform
+}
+export declare interface SafariProvisionResult {
+  container: { identifier: string, exists: boolean, created: boolean }
+  extension: { identifier: string, exists: boolean, created: boolean }
+  appRecord: { exists: boolean, id?: string }
+}
+export type BundleIdPlatform = 'IOS' | 'MAC_OS' | 'UNIVERSAL';
+/** Minimal official App Store Connect client for Safari provisioning checks. */
+export declare class AppStoreConnectClient {
+  constructor(options?: AppStoreConnectClientOptions);
+  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>;
+}

package/dist/app-store-connect.js

@@ -0,0 +1,92 @@
+import { createPrivateKey, sign } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { resolveAppStoreConnectAuth } from "./safari";
+const appStoreConnectBaseUrl = "https://api.appstoreconnect.apple.com/v1";
+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")}`;
+}
+
+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 response = await this.fetcher(`${this.baseUrl}${path}`, {
+      ...init,
+      headers: {
+        Accept: "application/json",
+        Authorization: `Bearer ${appStoreConnectToken(this.auth, this.now())}`,
+        ...init.body ? { "Content-Type": "application/json" } : {},
+        ...init.headers
+      }
+    });
+    if (!response.ok) {
+      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}` : ""}`);
+    }
+    return await response.json();
+  }
+  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);
+  }
+}
+export async function provisionSafariApp(config, options = {}) {
+  if (!config.safariBundleId)
+    throw Error("[browser-extension] Safari provisioning needs safariBundleId in config/extension.ts");
+  const client = new AppStoreConnectClient(options), identifier = config.safariBundleId, extensionIdentifier = `${identifier}.Extension`, container = await client.ensureBundleId(identifier, config.name, options), extension = await client.ensureBundleId(extensionIdentifier, `${config.name} Safari Extension`, options), app = await client.findApp(identifier);
+  return {
+    container: { identifier, exists: Boolean(container.bundleId), created: container.created },
+    extension: { identifier: extensionIdentifier, exists: Boolean(extension.bundleId), created: extension.created },
+    appRecord: { exists: Boolean(app), id: app?.id }
+  };
+}

package/dist/index.d.ts

@@ -8,6 +8,7 @@
  * app scaffold, appex resource sync, and xcodebuild pipeline.
  */
 export * from './build';
+export * from './app-store-connect';
 export * from './config';
 export * from './manifest';
 export * from './package';

package/dist/index.js

@@ -1,4 +1,5 @@
 export * from "./build";
+export * from "./app-store-connect";
 export * from "./config";
 export * from "./manifest";
 export * from "./package";

package/dist/safari.d.ts

@@ -38,6 +38,8 @@ export declare function syncSafariResources(config: ExtensionConfig, options?: S
  * built `.app` path (undefined when xcodebuild was skipped/unavailable).
  */
 export declare function buildSafariApp(config: ExtensionConfig, options?: SafariAppBuildOptions): Promise<{ appPath?: string, resources: string }>;
+/** Resolve and validate App Store Connect credentials from options or environment variables. */
+export declare function resolveAppStoreConnectAuth(options: AppStoreConnectAuth): Required<AppStoreConnectAuth>;
 /**
  * Create a signed Release archive and either validate it or upload it to App
  * Store Connect. Xcode owns certificate/profile creation and the upload so the

package/dist/safari.js

@@ -132,7 +132,7 @@ export async function buildSafariApp(config, options = {}) {
   await Bun.$`xcodebuild -project ${join(dir, `${appName}.xcodeproj`)} -scheme ${appName} -configuration ${configuration} -derivedDataPath ${derivedData} ${signing} build`;
   return { appPath: join(derivedData, "Build", "Products", configuration, `${appName}.app`), resources };
 }
-function appStoreConnectAuth(options) {
+export function resolveAppStoreConnectAuth(options) {
   const keyId = options.keyId ?? process.env.APP_STORE_CONNECT_API_KEY_ID, issuerId = options.issuerId ?? process.env.APP_STORE_CONNECT_API_ISSUER_ID, keyPath = options.keyPath ?? process.env.APP_STORE_CONNECT_API_KEY_PATH, missing = [
     !keyId && "APP_STORE_CONNECT_API_KEY_ID",
     !issuerId && "APP_STORE_CONNECT_API_ISSUER_ID",
@@ -180,7 +180,7 @@ export async function publishSafariApp(config, options) {
   const cwd = options.cwd ?? process.cwd(), teamId = options.teamId ?? config.safariTeamId;
   if (!teamId)
     throw Error("[browser-extension] Safari publishing needs safariTeamId in config/extension.ts or --team-id");
-  const auth = appStoreConnectAuth(options), buildNumber = options.buildNumber ?? process.env.GITHUB_RUN_NUMBER ?? String(Math.floor(Date.now() / 1000));
+  const auth = resolveAppStoreConnectAuth(options), buildNumber = options.buildNumber ?? process.env.GITHUB_RUN_NUMBER ?? String(Math.floor(Date.now() / 1000));
   if (!/^\d+(?:\.\d+){0,2}$/.test(buildNumber))
     throw Error(`[browser-extension] invalid Safari build number ${buildNumber}; use one to three dot-separated integers`);
   if (options.build !== !1)

package/package.json

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