@stacksjs/browser-extension 0.70.140 → 0.70.142

package/README.md

@@ -4,8 +4,9 @@ Build MV3 browser extensions (Chrome + Firefox + Safari) the Stacks way — the
 manifest, content/background scripts, stx pages, `declarativeNetRequest`
 rulesets, and store-ready packaging are all derived from a single
 `config/extension.ts`. No hand-written `manifest.json`, no per-project build
-script. Safari additionally gets the macOS container app: a checked-in Xcode
-scaffold, appex resource sync, and an xcodebuild pipeline.
+script. Safari additionally gets macOS, iPhone, and iPad container apps from
+one web bundle, with checked-in macOS development and universal App Store
+packaging owned by the framework.
 
 ## Quick start
 
@@ -46,7 +47,7 @@ repository instead of duplicating store orchestration:
 ```yaml
 jobs:
   publish:
-    uses: stacksjs/stacks/.github/workflows/browser-extension-release.yml@v0.70.122
+    uses: stacksjs/stacks/.github/workflows/browser-extension-release.yml@v0.70.142
     with:
       chrome-publisher-id: ${{ vars.CHROME_WEB_STORE_PUBLISHER_ID }}
       safari-enabled: ${{ vars.ENABLE_SAFARI_PUBLISH == 'true' }}
@@ -65,9 +66,9 @@ GitHub Release only after the enabled stores succeed.
 
 ## Safari
 
-Safari Web Extensions ship inside a macOS app, so the safari target has two
-halves: the web bundle (`extension:build --target safari`) and the container
-app. The build rewrites promise-style `chrome.*` to `browser.*` (Safari's
+Safari Web Extensions ship inside Apple container apps, so the safari target
+has two halves: the web bundle (`extension:build --target safari`) and the
+macOS/iOS apps. The build rewrites promise-style `chrome.*` to `browser.*` (Safari's
 `chrome.*` is callback-flavoured) and pins
 `browser_specific_settings.safari.strict_min_version` (default 18.4, the first
 Safari with MAIN-world content scripts + `match_about_blank`).
@@ -75,12 +76,17 @@ 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
+buddy extension:safari:app    # build configured macOS/iOS apps
+buddy extension:safari:app --platform ios # build for iPhone/iPad Simulator
+buddy extension:safari:publish # archive + upload every configured Apple platform
 ```
 
 Set `safariBundleId` in the config (the appex gets `<safariBundleId>.Extension`)
-and `safariTeamId` to the Apple Developer team used for signing. Publishing
+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
 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.
@@ -90,6 +96,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.
 
+For device testing, install the generated iOS app from Xcode, then enable the
+extension in Settings > Apps > Safari > Extensions. The iOS target supports
+iPhone and iPad from iOS 15 onward; the extension's configured Safari minimum
+version can require a newer OS.
+
 ## Configure
 
 ```ts
@@ -103,6 +114,9 @@ export default defineExtension({
   chromeWebStore: { publisherId: 'publisher-id', itemId: 'extension-id' },
   firefoxAddons: { license: 'MIT', categories: ['privacy-security'] },
   safariBundleId: 'com.example.MyExtension', // Safari container app bundle id
+  safariTeamId: 'TEAM123456',
+  safariPlatforms: ['macos', 'ios'], // iOS includes iPhone and iPad
+  safariAppCategory: 'public.app-category.utilities',
   targets: ['chrome', 'firefox'],
 
   background: 'src/background/index.ts',
@@ -164,5 +178,7 @@ import {
   scaffoldSafariApp,
   syncSafariResources,
   buildSafariApp,
+  buildSafariUniversalApp,
+  createSafariUniversalProject,
 } from '@stacksjs/browser-extension'
 ```

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

@@ -1,5 +1,5 @@
 import type { AppStoreConnectAuth } from './safari';
-import type { ExtensionConfig } from './types';
+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;
 /**
@@ -25,21 +25,37 @@ export declare interface AppAttributes extends Record<string, unknown> {
   primaryLocale: string
   sku: string
 }
+export declare interface AppStoreVersionAttributes extends Record<string, unknown> {
+  platform: AppStoreVersionPlatform
+  versionString: string
+  appStoreState: string
+}
 export declare interface AppStoreConnectClientOptions extends AppStoreConnectAuth {
   baseUrl?: string
   fetch?: typeof globalThis.fetch
   now?: () => number
 }
+export declare interface SafariAppStoreVersionResult {
+  platform: SafariPlatform
+  version: string
+  created: boolean
+  updated: boolean
+  id: string
+}
 export declare interface SafariProvisionOptions extends AppStoreConnectClientOptions {
   checkOnly?: boolean
   platform?: BundleIdPlatform
+  version?: string
+  platforms?: SafariPlatform[]
 }
 export declare interface SafariProvisionResult {
   container: { identifier: string, exists: boolean, created: boolean }
   extension: { identifier: string, exists: boolean, created: boolean }
   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);
@@ -47,4 +63,7 @@ export declare class AppStoreConnectClient {
   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>>;
 }

package/dist/app-store-connect.js

@@ -79,14 +79,72 @@ export class AppStoreConnectClient {
     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;
+  }
+}
+const editableVersionStates = new Set([
+  "PREPARE_FOR_SUBMISSION",
+  "DEVELOPER_REJECTED",
+  "REJECTED",
+  "METADATA_REJECTED"
+]);
+function appStorePlatform(platform) {
+  return platform === "ios" ? "IOS" : "MAC_OS";
+}
+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) {
+      results.push({ platform, version, created: !1, updated: !1, id: exact.id });
+      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 });
+      continue;
+    }
+    const created = await client.createAppStoreVersion(appId, applePlatform, version);
+    versions.push(created);
+    results.push({ platform, version, created: !0, updated: !1, id: created.id });
+  }
+  return results;
 }
 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);
+  const client = new AppStoreConnectClient(options), identifier = config.safariBundleId, extensionIdentifier = `${identifier}.Extension`, platforms = options.platforms ?? config.safariPlatforms ?? ["macos"], bundleIdPlatform = options.platform ?? (platforms.includes("ios") ? "UNIVERSAL" : "MAC_OS"), bundleOptions = { checkOnly: options.checkOnly, platform: bundleIdPlatform }, container = await client.ensureBundleId(identifier, config.name, bundleOptions), extension = await client.ensureBundleId(extensionIdentifier, `${config.name} Safari Extension`, bundleOptions), app = await client.findApp(identifier), appStoreVersions = app && options.version && !options.checkOnly ? await ensureConfiguredAppStoreVersions(client, app.id, platforms, options.version) : [];
   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 }
+    appRecord: { exists: Boolean(app), id: app?.id },
+    appStoreVersions
   };
 }

package/dist/safari.d.ts

@@ -1,4 +1,4 @@
-import type { ExtensionConfig } from './types';
+import type { ExtensionConfig, SafariPlatform } from './types';
 /**
  * Safari container-app tooling: scaffold the Xcode project, sync the built
  * safari bundle into the appex Resources, and xcodebuild the app.
@@ -18,6 +18,9 @@ import type { ExtensionConfig } from './types';
 export declare function safariAppName(config: ExtensionConfig): string;
 /** Directory the container app is scaffolded into. */
 export declare function safariProjectDir(cwd?: unknown, dir?: string): string;
+/** Safari platforms selected in config, de-duplicated in stable order. */
+export declare function resolveSafariPlatforms(config: ExtensionConfig, platforms?: SafariPlatform[]): SafariPlatform[];
+export declare function safariPackagerArgs(input: string, projectLocation: string, appName: string, bundleId: string, platforms: SafariPlatform[]): string[];
 /** Upgrade a Stacks-generated project that copied Resources as a nested folder. */
 export declare function migrateSafariResourceBuildPhase(project: string, appName: string): string;
 /**
@@ -34,6 +37,10 @@ export declare function scaffoldSafariApp(config: ExtensionConfig, options?: Saf
  * marketing-site pages built into dist) are kept out.
  */
 export declare function syncSafariResources(config: ExtensionConfig, options?: SafariSyncOptions): Promise<{ resources: string, files: number }>;
+/** Generate a clean Apple-supported Safari project for macOS, iOS, or both. */
+export declare function createSafariUniversalProject(config: ExtensionConfig, options?: SafariUniversalProjectOptions): Promise<SafariUniversalProject>;
+/** Build Apple-supported macOS and iOS Safari containers from one web bundle. */
+export declare function buildSafariUniversalApp(config: ExtensionConfig, options?: SafariUniversalBuildOptions): Promise<SafariUniversalBuildResult>;
 /**
  * Full pipeline: build the safari bundle, sync it into the appex Resources,
  * then xcodebuild the container app when full Xcode is available. Returns the
@@ -47,7 +54,7 @@ export declare function resolveAppStoreConnectAuth(options: AppStoreConnectAuth)
  * Store Connect. Xcode owns certificate/profile creation and the upload so the
  * same command works locally and in macOS CI with an API key.
  */
-export declare function publishSafariApp(config: ExtensionConfig, options: SafariPublishOptions): Promise<{ archivePath: string, exportPath: string, buildNumber: string }>;
+export declare function publishSafariApp(config: ExtensionConfig, options: SafariPublishOptions): Promise<SafariPublishResult>;
 export declare interface SafariScaffoldOptions {
   bundleId?: string
   dir?: string
@@ -62,6 +69,25 @@ export declare interface SafariSyncOptions {
   dir?: string
   cwd?: string
 }
+export declare interface SafariUniversalProjectOptions extends SafariSyncOptions {
+  platforms?: SafariPlatform[]
+  build?: boolean
+  version?: string
+}
+export declare interface SafariUniversalProject {
+  dir: string
+  project: string
+  resources: string
+  platforms: SafariPlatform[]
+}
+export declare interface SafariUniversalBuildOptions extends SafariUniversalProjectOptions {
+  release?: boolean
+  signed?: boolean
+  skipXcodebuild?: boolean
+}
+export declare interface SafariUniversalBuildResult extends SafariUniversalProject {
+  appPaths: Partial<Record<SafariPlatform, string>>
+}
 export declare interface SafariAppBuildOptions extends SafariSyncOptions {
   release?: boolean
   signed?: boolean
@@ -80,4 +106,16 @@ export declare interface SafariPublishOptions extends SafariSyncOptions, AppStor
   teamId?: string
   validateOnly?: boolean
   build?: boolean
+  platforms?: SafariPlatform[]
+}
+export declare interface SafariPublishedArtifact {
+  platform: SafariPlatform
+  archivePath: string
+  exportPath: string
+}
+export declare interface SafariPublishResult {
+  archivePath: string
+  exportPath: string
+  buildNumber: string
+  artifacts: SafariPublishedArtifact[]
 }

package/dist/safari.js

@@ -11,6 +11,34 @@ export function safariAppName(config) {
 export function safariProjectDir(cwd = process.cwd(), dir = "safari") {
   return resolve(cwd, dir);
 }
+export function resolveSafariPlatforms(config, platforms) {
+  const selected = platforms ?? config.safariPlatforms ?? ["macos"];
+  return [...new Set(selected)];
+}
+function safariPlatformFlag(platforms) {
+  if (platforms.length !== 1)
+    return;
+  return platforms[0] === "ios" ? "--ios-only" : "--macos-only";
+}
+export function safariPackagerArgs(input, projectLocation, appName, bundleId, platforms) {
+  const platformFlag = safariPlatformFlag(platforms);
+  return [
+    "safari-web-extension-packager",
+    "--project-location",
+    projectLocation,
+    "--app-name",
+    appName,
+    "--bundle-identifier",
+    bundleId,
+    "--swift",
+    "--copy-resources",
+    "--no-open",
+    "--no-prompt",
+    "--force",
+    ...platformFlag ? [platformFlag] : [],
+    input
+  ];
+}
 function templateRoot() {
   return resolve(import.meta.dir, "..", "safari-template");
 }
@@ -41,6 +69,8 @@ function safariResourceCopyBuildPhase(appName) {
 `;
 }
 export function migrateSafariResourceBuildPhase(project, appName) {
+  if (project.includes("resources_prefix='$(SRCROOT)"))
+    return project.replace(/\/\* Begin PBXShellScriptBuildPhase section \*\/[\s\S]*?\/\* End PBXShellScriptBuildPhase section \*\/\n/, safariResourceCopyBuildPhase(appName));
   if (project.includes("SCRIPT_INPUT_FILE_LIST_0"))
     return project;
   if (project.includes("0D0000000000000000000023 /* Copy Web Extension Resources */"))
@@ -123,24 +153,12 @@ async function generateAppIcons(config, dir, vars, iconsDir, cwd) {
       return;
     }
 }
-export async function syncSafariResources(config, options = {}) {
-  const cwd = options.cwd ?? process.cwd(), outdir = resolve(cwd, options.outdir ?? resolveOutdir(config, "safari"));
-  if (!existsSync(join(outdir, "manifest.json")))
-    throw Error(`[browser-extension] ${outdir}/manifest.json is missing. Run extension:build --target safari first.`);
-  const appName = safariAppName(config), projectDir = safariProjectDir(cwd, options.dir), projectPath = join(projectDir, `${appName}.xcodeproj`, "project.pbxproj");
-  if (existsSync(projectPath)) {
-    const project = await Bun.file(projectPath).text(), migrated = migrateSafariResourceBuildPhase(project, appName);
-    if (migrated !== project)
-      await Bun.write(projectPath, migrated);
-  }
-  const resources = join(projectDir, `${appName} Extension`, "Resources"), exclude = new Set(config.safariExclude ?? []);
-  if (existsSync(resources)) {
-    for (const entry of readdirSync(resources))
-      if (entry !== ".gitkeep")
-        await rm(join(resources, entry), { recursive: !0, force: !0 });
-  }
+async function mirrorSafariResources(config, outdir, resources, keepPlaceholder = !1) {
+  const exclude = new Set(config.safariExclude ?? []);
+  await rm(resources, { recursive: !0, force: !0 });
   await mkdir(resources, { recursive: !0 });
-  let files = 0;
+  if (keepPlaceholder)
+    await Bun.write(join(resources, ".gitkeep"), "");
   const synced = [];
   for (const rel of walk(outdir)) {
     if (exclude.has(rel) || rel.split("/").includes(".DS_Store"))
@@ -149,16 +167,84 @@ export async function syncSafariResources(config, options = {}) {
     await mkdir(dirname(dest), { recursive: !0 });
     cpSync(join(outdir, rel), dest);
     synced.push(rel);
-    files += 1;
   }
-  const inputs = synced.map((rel) => join(resources, rel)).join(`
+  return synced;
+}
+export async function syncSafariResources(config, options = {}) {
+  const cwd = options.cwd ?? process.cwd(), outdir = resolve(cwd, options.outdir ?? resolveOutdir(config, "safari"));
+  if (!existsSync(join(outdir, "manifest.json")))
+    throw Error(`[browser-extension] ${outdir}/manifest.json is missing. Run extension:build --target safari first.`);
+  const appName = safariAppName(config), projectDir = safariProjectDir(cwd, options.dir), projectPath = join(projectDir, `${appName}.xcodeproj`, "project.pbxproj");
+  if (existsSync(projectPath)) {
+    const project = await Bun.file(projectPath).text(), migrated = migrateSafariResourceBuildPhase(project, appName);
+    if (migrated !== project)
+      await Bun.write(projectPath, migrated);
+  }
+  const resources = join(projectDir, `${appName} Extension`, "Resources"), synced = await mirrorSafariResources(config, outdir, resources, !0), inputs = synced.map((rel) => `$(SRCROOT)/${appName} Extension/Resources/${rel}`).join(`
 `), outputs = synced.map((rel) => `$(TARGET_BUILD_DIR)/$(UNLOCALIZED_RESOURCES_FOLDER_PATH)/${rel}`).join(`
 `);
   await Bun.write(join(projectDir, `${appName} Extension`, "Resources.inputs.xcfilelist"), `${inputs}
 `);
   await Bun.write(join(projectDir, `${appName} Extension`, "Resources.outputs.xcfilelist"), `${outputs}
 `);
-  return { resources, files };
+  return { resources, files: synced.length };
+}
+export async function createSafariUniversalProject(config, options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  if (options.build !== !1) {
+    if (!options.version)
+      throw Error("[browser-extension] createSafariUniversalProject needs a version to build the extension");
+    await buildExtension(config, { target: "safari", version: options.version, cwd });
+  }
+  const outdir = resolve(cwd, options.outdir ?? resolveOutdir(config, "safari"));
+  if (!existsSync(join(outdir, "manifest.json")))
+    throw Error(`[browser-extension] ${outdir}/manifest.json is missing. Run extension:build --target safari first.`);
+  const appName = safariAppName(config), bundleId = config.safariBundleId;
+  if (!bundleId)
+    throw Error("[browser-extension] universal Safari packaging needs safariBundleId in config/extension.ts");
+  const platforms = resolveSafariPlatforms(config, options.platforms);
+  if (!platforms.length)
+    throw Error("[browser-extension] universal Safari packaging needs at least one platform");
+  const buildDir = join(safariProjectDir(cwd, options.dir), "build"), resources = join(buildDir, "universal-resources"), projectLocation = join(buildDir, "universal-project");
+  await mirrorSafariResources(config, outdir, resources);
+  await rm(projectLocation, { recursive: !0, force: !0 });
+  await mkdir(projectLocation, { recursive: !0 });
+  const args = safariPackagerArgs(resources, projectLocation, appName, bundleId, platforms), exitCode = await Bun.spawn(["xcrun", ...args], { cwd, stdout: "inherit", stderr: "inherit" }).exited;
+  if (exitCode !== 0)
+    throw Error(`[browser-extension] Safari web extension packager failed (${exitCode})`);
+  const dir = join(projectLocation, appName), project = join(dir, `${appName}.xcodeproj`);
+  if (!existsSync(project))
+    throw Error(`[browser-extension] Safari packager did not create ${project}`);
+  return { dir, project, resources, platforms };
+}
+export async function buildSafariUniversalApp(config, options = {}) {
+  const generated = await createSafariUniversalProject(config, options), appPaths = {};
+  if (options.skipXcodebuild)
+    return { ...generated, appPaths };
+  const appName = safariAppName(config), configuration = options.release ? "Release" : "Debug", derivedData = join(safariProjectDir(options.cwd ?? process.cwd(), options.dir), "build", "universal-derived");
+  await rm(derivedData, { recursive: !0, force: !0 });
+  for (const platform of generated.platforms) {
+    const ios = platform === "ios", args = [
+      "xcodebuild",
+      "-project",
+      generated.project,
+      "-scheme",
+      `${appName} (${ios ? "iOS" : "macOS"})`,
+      "-configuration",
+      configuration,
+      "-destination",
+      ios ? "generic/platform=iOS Simulator" : "generic/platform=macOS",
+      "-derivedDataPath",
+      derivedData,
+      ...ios ? ["-sdk", "iphonesimulator", "CODE_SIGNING_ALLOWED=NO"] : options.signed ? ["-allowProvisioningUpdates"] : ["CODE_SIGNING_ALLOWED=NO"],
+      "build"
+    ], exitCode = await Bun.spawn(args, { cwd: generated.dir, stdout: "inherit", stderr: "inherit" }).exited;
+    if (exitCode !== 0)
+      throw Error(`[browser-extension] Safari ${platform} app build failed (${exitCode})`);
+    const products = ios ? `${configuration}-iphonesimulator` : configuration;
+    appPaths[platform] = join(derivedData, "Build", "Products", products, `${appName}.app`);
+  }
+  return { ...generated, appPaths };
 }
 export async function buildSafariApp(config, options = {}) {
   const cwd = options.cwd ?? process.cwd();
@@ -205,6 +291,11 @@ function xcodeAuthArgs(auth) {
     auth.issuerId
   ];
 }
+async function runXcodebuild(args, cwd, operation) {
+  const exitCode = await Bun.spawn(["xcodebuild", ...args], { cwd, stdout: "inherit", stderr: "inherit" }).exited;
+  if (exitCode !== 0)
+    throw Error(`[browser-extension] ${operation} failed (${exitCode})`);
+}
 function exportOptionsPlist(method, teamId) {
   return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@@ -233,17 +324,76 @@ export async function publishSafariApp(config, options) {
   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`);
+  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, {
+    ...auth,
+    version: options.version,
+    platforms
+  })).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 });
-  await syncSafariResources(config, options);
-  const appName = safariAppName(config), dir = safariProjectDir(cwd, options.dir), buildDir = join(dir, "build"), archivePath = join(buildDir, `${appName}.xcarchive`), exportPath = join(buildDir, options.validateOnly ? "validation" : "upload"), plistPath = join(buildDir, options.validateOnly ? "ExportOptions.validation.plist" : "ExportOptions.app-store.plist"), authArgs = xcodeAuthArgs(auth);
+  const appName = safariAppName(config), dir = safariProjectDir(cwd, options.dir), buildDir = join(dir, "build"), universal = platforms.includes("ios");
+  let project, projectCwd;
+  if (universal) {
+    const generated = await createSafariUniversalProject(config, {
+      ...options,
+      build: !1,
+      platforms
+    });
+    project = generated.project;
+    projectCwd = generated.dir;
+  } else {
+    await syncSafariResources(config, options);
+    project = join(dir, `${appName}.xcodeproj`);
+    projectCwd = dir;
+  }
+  const authArgs = xcodeAuthArgs(auth);
   await mkdir(buildDir, { recursive: !0 });
-  await rm(archivePath, { recursive: !0, force: !0 });
-  await rm(exportPath, { recursive: !0, force: !0 });
-  const project = join(dir, `${appName}.xcodeproj`);
-  await Bun.$`xcodebuild -project ${project} -scheme ${appName} -configuration Release -destination generic/platform=macOS -archivePath ${archivePath} MARKETING_VERSION=${options.version} CURRENT_PROJECT_VERSION=${buildNumber} DEVELOPMENT_TEAM=${teamId} ${authArgs} archive`;
-  const method = options.validateOnly ? "validation" : "app-store-connect";
-  await Bun.write(plistPath, exportOptionsPlist(method, teamId));
-  await Bun.$`xcodebuild -exportArchive -archivePath ${archivePath} -exportPath ${exportPath} -exportOptionsPlist ${plistPath} ${authArgs}`;
-  return { archivePath, exportPath, buildNumber };
+  const method = options.validateOnly ? "validation" : "app-store-connect", artifacts = [];
+  for (const platform of platforms) {
+    const suffix = universal ? `-${platform}` : "", archivePath = join(buildDir, `${appName}${suffix}.xcarchive`), exportPath = join(buildDir, `${options.validateOnly ? "validation" : "upload"}${suffix}`), plistPath = join(buildDir, `ExportOptions.${method}${suffix}.plist`), scheme = universal ? `${appName} (${platform === "ios" ? "iOS" : "macOS"})` : appName, destination = platform === "ios" ? "generic/platform=iOS" : "generic/platform=macOS";
+    await rm(archivePath, { recursive: !0, force: !0 });
+    await rm(exportPath, { recursive: !0, force: !0 });
+    await runXcodebuild([
+      "-project",
+      project,
+      "-scheme",
+      scheme,
+      "-configuration",
+      "Release",
+      "-destination",
+      destination,
+      "-archivePath",
+      archivePath,
+      `MARKETING_VERSION=${options.version}`,
+      `CURRENT_PROJECT_VERSION=${buildNumber}`,
+      `DEVELOPMENT_TEAM=${teamId}`,
+      ...platform === "ios" ? ["CODE_SIGNING_ALLOWED=NO"] : [],
+      ...platform === "macos" && config.safariAppCategory ? [`INFOPLIST_KEY_LSApplicationCategoryType=${config.safariAppCategory}`] : [],
+      ...authArgs,
+      "archive"
+    ], projectCwd, `Safari ${platform} archive`);
+    await Bun.write(plistPath, exportOptionsPlist(method, teamId));
+    await runXcodebuild([
+      "-exportArchive",
+      "-archivePath",
+      archivePath,
+      "-exportPath",
+      exportPath,
+      "-exportOptionsPlist",
+      plistPath,
+      ...authArgs
+    ], projectCwd, `Safari ${platform} export`);
+    artifacts.push({ platform, archivePath, exportPath });
+  }
+  return {
+    archivePath: artifacts[0].archivePath,
+    exportPath: artifacts[0].exportPath,
+    buildNumber,
+    artifacts
+  };
 }

package/dist/types.d.ts

@@ -76,6 +76,8 @@ export declare interface ExtensionConfig {
   firefoxAddons?: FirefoxAddonsConfig
   safariBundleId?: string
   safariTeamId?: string
+  safariPlatforms?: SafariPlatform[]
+  safariAppCategory?: string
   safariExclude?: string[]
   targets?: ExtensionTarget[]
   background?: string
@@ -107,3 +109,4 @@ export declare interface BuildOptions {
  * or per-project build script.
  */
 export type ExtensionTarget = 'chrome' | 'firefox' | 'safari';
+export type SafariPlatform = 'macos' | 'ios';

package/package.json

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