@stacksjs/browser-extension 0.70.147 → 0.70.149

package/README.md

@@ -11,7 +11,8 @@ packaging owned by the framework.
 ## Quick start
 
 ```sh
-buddy extension:init          # scaffold config/extension.ts + starter files
+buddy extension:init          # scaffold Chrome + Firefox + Safari, including the Xcode app
+buddy extension:init --target safari --name "My Extension" --bundle-id com.example.MyExtension
 buddy extension:build         # build all targets → dist/ (+ dist-firefox/)
 buddy extension:build --target chrome
 buddy extension:build --target safari   # → dist-safari/ (browser.* namespace, safari manifest)

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

@@ -61,6 +61,9 @@ export declare interface SafariAppStoreVersionResult {
   created: boolean
   updated: boolean
   id: string
+  status?: 'ready' | 'deferred' | 'published'
+  appStoreState?: string
+  reason?: string
 }
 export declare interface SafariBuildAttachmentResult {
   platform: SafariPlatform

package/dist/app-store-connect.js

@@ -153,7 +153,13 @@ const editableVersionStates = new Set([
   "PREPARE_FOR_SUBMISSION",
   "DEVELOPER_REJECTED",
   "REJECTED",
-  "METADATA_REJECTED"
+  "METADATA_REJECTED",
+  "INVALID_BINARY"
+]), releasedVersionStates = new Set([
+  "READY_FOR_DISTRIBUTION",
+  "READY_FOR_SALE",
+  "DEVELOPER_REMOVED_FROM_SALE",
+  "REMOVED_FROM_SALE"
 ]);
 function appStorePlatform(platform) {
   return platform === "ios" ? "IOS" : "MAC_OS";
@@ -194,19 +200,43 @@ async function ensureConfiguredAppStoreVersions(client, appId, platforms, versio
   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 });
+      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 });
+      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 });
+    results.push({ platform, version, created: !0, updated: !1, id: created.id, status: "ready", appStoreState: created.attributes.appStoreState });
   }
   return results;
 }

package/dist/build.js

@@ -69,12 +69,12 @@ export async function buildExtension(config, options) {
   const pages = pageEntries(config.pages);
   await Promise.all(pages.filter((p) => p.page.script).map((p) => buildScript(p.page.script, `${p.name}.js`, outdir, cwd, minify)));
   if (pages.length) {
-    const { default: stxPlugin } = await import("bun-plugin-stx"), result = await Bun.build({
+    const { default: stxPlugin } = await import("bun-plugin-stx"), resourcesPartials = resolve(cwd, "resources/partials"), legacyPartials = resolve(cwd, "partials"), partialsDir = existsSync(resourcesPartials) ? resourcesPartials : legacyPartials, result = await Bun.build({
       entrypoints: pages.map((p) => resolve(cwd, p.page.template)),
       outdir,
       minify,
       naming: { entry: "[name].html" },
-      plugins: [stxPlugin()]
+      plugins: [stxPlugin({ partialsDir })]
     });
     if (!result.success)
       throw Error(`[browser-extension] failed to build pages: ${result.logs.join(`

package/dist/chrome-web-store.d.ts

@@ -2,7 +2,7 @@ import type { ChromeWebStoreConfig, ExtensionConfig } from './types';
 /** Build the RS256 assertion Google exchanges for a short-lived OAuth token. */
 export declare function chromeWebStoreServiceAccountAssertion(serviceAccount: GoogleServiceAccount, now?: unknown): string;
 /** Build, package, upload, and optionally submit an existing Chrome Web Store item. */
-export declare function publishChromeExtension(config: ExtensionConfig, options: ChromeWebStorePublishOptions): Promise<{ packagePath: string, upload: ChromeUploadResult, publish?: ChromePublishResult }>;
+export declare function publishChromeExtension(config: ExtensionConfig, options: ChromeWebStorePublishOptions): Promise<ChromeWebStorePublishResult>;
 export declare interface GoogleServiceAccount {
   client_email: string
   private_key: string
@@ -39,6 +39,23 @@ export declare interface ChromePublishResult {
   state: string
   warningInfo?: { warnings?: Array<{ reason: string, description: string }> }
 }
+export declare interface ChromeDeferredPublishResult {
+  state: string
+  submittedVersion?: string
+  reason: string
+}
+export declare interface ChromePublishedVersionResult {
+  state: string
+  version: string
+  reason: string
+}
+export declare interface ChromeWebStorePublishResult {
+  packagePath: string
+  upload?: ChromeUploadResult
+  publish?: ChromePublishResult
+  deferred?: ChromeDeferredPublishResult
+  alreadyPublished?: ChromePublishedVersionResult
+}
 export declare interface ChromeWebStorePublishOptions extends ChromeWebStoreClientOptions {
   version: string
   cwd?: string

package/dist/chrome-web-store.js

@@ -121,10 +121,38 @@ export class ChromeWebStoreClient {
     throw Error("[browser-extension] Chrome Web Store package processing timed out");
   }
 }
+function pendingReview(status) {
+  if (status.submittedItemRevisionStatus?.state !== "PENDING_REVIEW")
+    return;
+  const submittedVersion = status.submittedItemRevisionStatus.distributionChannels?.[0]?.crxVersion;
+  return {
+    state: status.submittedItemRevisionStatus.state,
+    submittedVersion,
+    reason: submittedVersion ? `Chrome Web Store version ${submittedVersion} is already pending review` : "A Chrome Web Store revision is already pending review"
+  };
+}
+function publishedVersion(status, version) {
+  const published = status.publishedItemRevisionStatus;
+  if (!published || !["PUBLISHED", "PUBLISHED_TO_TESTERS"].includes(published.state))
+    return;
+  if (!published.distributionChannels?.some((channel) => channel.crxVersion === version))
+    return;
+  return {
+    state: published.state,
+    version,
+    reason: `Chrome Web Store version ${version} is already ${published.state.toLowerCase().replaceAll("_", " ")}`
+  };
+}
 export async function publishChromeExtension(config, options) {
   if (!config.chromeWebStore)
     throw Error("[browser-extension] Chrome publishing needs chromeWebStore.publisherId and chromeWebStore.itemId in config/extension.ts");
-  const cwd = options.cwd ?? process.cwd(), packagePath = options.packagePath ?? await packageExtension(config, { target: "chrome", version: options.version, cwd }), client = new ChromeWebStoreClient(options), upload = await client.upload(config.chromeWebStore, packagePath);
+  const cwd = options.cwd ?? process.cwd(), packagePath = options.packagePath ?? await packageExtension(config, { target: "chrome", version: options.version, cwd }), client = new ChromeWebStoreClient(options), status = await client.fetchStatus(config.chromeWebStore), alreadyPublished = publishedVersion(status, options.version);
+  if (alreadyPublished)
+    return { packagePath, alreadyPublished };
+  const deferred = pendingReview(status);
+  if (deferred)
+    return { packagePath, deferred };
+  const upload = await client.upload(config.chromeWebStore, packagePath);
   if (upload.uploadState === "IN_PROGRESS")
     await client.waitForUpload(config.chromeWebStore);
   else if (upload.uploadState !== "SUCCEEDED")

package/dist/index.d.ts

@@ -16,5 +16,6 @@ export * from './firefox-addons';
 export * from './manifest';
 export * from './package';
 export * from './safari';
+export * from './scaffold';
 export * from './sanitize';
 export * from './types';

package/dist/index.js

@@ -7,5 +7,6 @@ export * from "./firefox-addons";
 export * from "./manifest";
 export * from "./package";
 export * from "./safari";
+export * from "./scaffold";
 export * from "./sanitize";
 export * from "./types";

package/dist/safari.d.ts

@@ -120,6 +120,8 @@ export declare interface SafariPublishResult {
   exportPath: string
   buildNumber: string
   artifacts: SafariPublishedArtifact[]
+  deferred: Array<{ platform: SafariPlatform, version: string, state?: string, reason: string }>
+  alreadyPublished: Array<{ platform: SafariPlatform, version: string, state?: string }>
   attachments: Array<{ platform: SafariPlatform, versionId: string, buildId: string, buildNumber: string }>
   appStoreSubmission?: {
     versions: Array<{ platform: SafariPlatform, versionId: string, localizationId: string }>

package/dist/safari.js

@@ -329,20 +329,36 @@ export async function publishSafariApp(config, options) {
     throw Error("[browser-extension] Safari publishing needs at least one platform");
   const { AppStoreConnectClient, attachSafariBuilds, provisionSafariApp } = await import("./app-store-connect"), provisioned = await provisionSafariApp(config, {
     ...auth,
-    version: options.version,
+    version: options.validateOnly ? void 0 : options.version,
     platforms
   });
   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");
+  const publishablePlatforms = options.validateOnly ? platforms : platforms.filter((platform) => provisioned.appStoreVersions.some((version) => version.platform === platform && version.status !== "deferred" && version.status !== "published")), deferred = provisioned.appStoreVersions.filter((version) => version.status === "deferred").map((version) => ({
+    platform: version.platform,
+    version: version.version,
+    state: version.appStoreState,
+    reason: version.reason ?? `Safari ${version.platform} publication is deferred`
+  })), alreadyPublished = provisioned.appStoreVersions.filter((version) => version.status === "published").map((version) => ({ platform: version.platform, version: version.version, state: version.appStoreState }));
+  if (!publishablePlatforms.length)
+    return {
+      archivePath: "",
+      exportPath: "",
+      buildNumber,
+      artifacts: [],
+      attachments: [],
+      deferred,
+      alreadyPublished
+    };
   if (options.build !== !1)
     await buildExtension(config, { target: "safari", version: options.version, cwd });
-  const appName = safariAppName(config), dir = safariProjectDir(cwd, options.dir), buildDir = join(dir, "build"), universal = platforms.includes("ios");
+  const appName = safariAppName(config), dir = safariProjectDir(cwd, options.dir), buildDir = join(dir, "build"), universal = publishablePlatforms.includes("ios");
   let project, projectCwd;
   if (universal) {
     const generated = await createSafariUniversalProject(config, {
       ...options,
       build: !1,
-      platforms
+      platforms: publishablePlatforms
     });
     project = generated.project;
     projectCwd = generated.dir;
@@ -354,7 +370,7 @@ export async function publishSafariApp(config, options) {
   const authArgs = xcodeAuthArgs(auth);
   await mkdir(buildDir, { recursive: !0 });
   const method = options.validateOnly ? "validation" : "app-store-connect", artifacts = [];
-  for (const platform of platforms) {
+  for (const platform of publishablePlatforms) {
     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 });
@@ -391,7 +407,7 @@ 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, {
+  const attachments = options.validateOnly ? [] : await attachSafariBuilds(new AppStoreConnectClient(auth), provisioned.appRecord.id, provisioned.appStoreVersions.filter((version) => version.status !== "deferred" && version.status !== "published"), buildNumber, {
     timeoutMs: options.processingTimeoutMs,
     pollIntervalMs: options.processingPollIntervalMs
   }), appStoreSubmission = !options.validateOnly && config.safariAppStore ? await (await import("./app-store-submission")).prepareSafariAppStoreSubmission(new AppStoreConnectClient(auth), config, provisioned.appRecord.id, attachments.map((attachment) => ({
@@ -404,6 +420,8 @@ export async function publishSafariApp(config, options) {
     exportPath: firstArtifact.exportPath,
     buildNumber,
     artifacts,
+    deferred,
+    alreadyPublished,
     attachments,
     appStoreSubmission: appStoreSubmission ? { versions: appStoreSubmission.versions, reviewSubmissionIds: appStoreSubmission.reviewSubmissionIds } : void 0
   };

package/dist/scaffold.d.ts

@@ -0,0 +1,22 @@
+import { scaffoldSafariApp } from './safari';
+import type { ExtensionConfig, ExtensionTarget, SafariPlatform } from './types';
+export declare function resolveExtensionScaffoldTargets(target?: ExtensionScaffoldTarget): ExtensionTarget[];
+/** Scaffold a complete cross-browser extension, including Safari's container app. */
+export declare function scaffoldExtensionProject(options?: ExtensionProjectScaffoldOptions): Promise<ExtensionProjectScaffoldResult>;
+export declare interface ExtensionProjectScaffoldOptions {
+  cwd?: string
+  name?: string
+  target?: ExtensionScaffoldTarget
+  bundleId?: string
+  teamId?: string
+  platforms?: SafariPlatform[]
+  version?: string
+  force?: boolean
+}
+export declare interface ExtensionProjectScaffoldResult {
+  config: ExtensionConfig
+  written: string[]
+  skipped: string[]
+  safari?: Awaited<ReturnType<typeof scaffoldSafariApp>>
+}
+export type ExtensionScaffoldTarget = ExtensionTarget | 'all';

package/dist/scaffold.js

@@ -0,0 +1,92 @@
+import { existsSync } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import process from "node:process";
+import { scaffoldSafariApp } from "./safari";
+export function resolveExtensionScaffoldTargets(target = "all") {
+  return target === "all" ? ["chrome", "firefox", "safari"] : [target];
+}
+function safariAppName(name) {
+  return name.replace(/[^A-Za-z0-9]/g, "") || "MyExtension";
+}
+function quotedList(values) {
+  return `[${values.map((value) => `'${value}'`).join(", ")}]`;
+}
+function extensionConfigSource(config) {
+  const safari = config.targets?.includes("safari") ? `
+  safariBundleId: '${config.safariBundleId}',
+  safariPlatforms: ${quotedList(config.safariPlatforms ?? ["macos", "ios"])},
+  safariAppCategory: 'public.app-category.utilities',${config.safariTeamId ? `
+  safariTeamId: '${config.safariTeamId}',` : ""}` : "", firefox = config.targets?.includes("firefox") ? `
+  // Replace this before publishing to Mozilla Add-ons.
+  geckoId: 'extension@example.com',` : "";
+  return `import { defineExtension } from '@stacksjs/browser-extension'
+
+export default defineExtension({
+  name: ${JSON.stringify(config.name)},
+  description: 'A browser extension built with Stacks.',
+  targets: ${quotedList(config.targets ?? [])},${firefox}${safari}
+  background: 'src/background/index.ts',
+  content: [
+    { entry: 'src/content/index.ts', matches: ['<all_urls>'], runAt: 'document_start' },
+  ],
+  pages: {
+    popup: { template: 'resources/views/popup.stx', script: 'resources/scripts/popup.ts' },
+  },
+  public: 'public',
+  manifest: {
+    permissions: ['storage', 'tabs'],
+  },
+})
+`;
+}
+export async function scaffoldExtensionProject(options = {}) {
+  const cwd = options.cwd ?? process.cwd(), name = options.name ?? "My Extension", targets = resolveExtensionScaffoldTargets(options.target), appName = safariAppName(name), config = {
+    name,
+    description: "A browser extension built with Stacks.",
+    targets,
+    background: "src/background/index.ts",
+    content: [{ entry: "src/content/index.ts", matches: ["<all_urls>"], runAt: "document_start" }],
+    pages: { popup: { template: "resources/views/popup.stx", script: "resources/scripts/popup.ts" } },
+    public: "public",
+    manifest: { permissions: ["storage", "tabs"] },
+    ...targets.includes("firefox") && { geckoId: "extension@example.com" },
+    ...targets.includes("safari") && {
+      safariBundleId: options.bundleId ?? `com.example.${appName}`,
+      safariTeamId: options.teamId,
+      safariPlatforms: options.platforms ?? ["macos", "ios"],
+      safariAppCategory: "public.app-category.utilities"
+    }
+  }, written = [], skipped = [], write = async (relative, content) => {
+    const absolute = join(cwd, relative);
+    if (existsSync(absolute) && !options.force) {
+      skipped.push(relative);
+      return;
+    }
+    await mkdir(dirname(absolute), { recursive: !0 });
+    await Bun.write(absolute, content);
+    written.push(relative);
+  };
+  await write("config/extension.ts", extensionConfigSource(config));
+  await write("src/background/index.ts", `console.log(${JSON.stringify(`[${name}] background ready`)})
+`);
+  await write("src/content/index.ts", `console.log(${JSON.stringify(`[${name}] content script loaded`)})
+`);
+  await write("resources/scripts/popup.ts", `console.log(${JSON.stringify(`[${name}] popup ready`)})
+`);
+  await write("resources/views/popup.stx", `<main class="popup">
+  <h1>${name}</h1>
+  <p>Edit resources/views/popup.stx to build your popup.</p>
+  <script src="/popup.js"></script>
+</main>
+`);
+  await mkdir(join(cwd, "public"), { recursive: !0 });
+  const safari = targets.includes("safari") ? await scaffoldSafariApp(config, {
+    cwd,
+    bundleId: config.safariBundleId,
+    teamId: config.safariTeamId,
+    version: options.version,
+    force: options.force
+  }) : void 0;
+  return { config, written, skipped, safari };
+}

package/package.json

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