@leonxin/meetgames 0.1.7 → 0.1.11

package/src/ios/entitlements.ts

@@ -0,0 +1,61 @@
+import path from "node:path";
+import type { TextFileStore } from "../ops/fileStore.js";
+import { buildPlistXml, parsePlistXml } from "./infoPlist.js";
+import { getTargetBuildSettings, setBuildSetting, type PbxContext } from "./pbxprojEditor.js";
+
+const APPLE_SIGN_IN_KEY = "com.apple.developer.applesignin";
+
+function unquote(value: string): string {
+  return value.replace(/^"|"$/g, "").trim();
+}
+
+function entitlementsRelPath(pbx: PbxContext, raw: unknown): string | null {
+  if (typeof raw !== "string" || !raw.trim()) return null;
+  let rel = unquote(raw);
+  if (rel.includes("$(SRCROOT)")) {
+    rel = rel.replace(/\$\(SRCROOT\)/g, pbx.srcRoot);
+  }
+  if (path.isAbsolute(rel)) {
+    return path.relative(pbx.srcRoot, rel).split(path.sep).join("/");
+  }
+  return rel.split(path.sep).join("/");
+}
+
+function readPlistOrEmpty(store: TextFileStore, relFromProjectRoot: string): Record<string, unknown> {
+  const xml = store.read(relFromProjectRoot);
+  if (!xml.trim()) return {};
+  return parsePlistXml(xml);
+}
+
+export function ensureAppleSignInEntitlement(
+  store: TextFileStore,
+  projectRoot: string,
+  pbx: PbxContext
+): string[] {
+  const settings = getTargetBuildSettings(pbx);
+  const entRelPaths = new Set<string>();
+  for (const s of settings) {
+    const rel = entitlementsRelPath(pbx, s.CODE_SIGN_ENTITLEMENTS);
+    if (rel) entRelPaths.add(rel);
+  }
+
+  if (!entRelPaths.size) {
+    const rel = path.join(pbx.targetName, `${pbx.targetName}.entitlements`).split(path.sep).join("/");
+    setBuildSetting(pbx, "CODE_SIGN_ENTITLEMENTS", rel);
+    entRelPaths.add(rel);
+  }
+
+  const changedRelPaths: string[] = [];
+  for (const entRel of entRelPaths) {
+    const abs = path.isAbsolute(entRel) ? entRel : path.join(pbx.srcRoot, entRel);
+    const storeRel = path.relative(projectRoot, abs).split(path.sep).join("/");
+    const data = readPlistOrEmpty(store, storeRel);
+    const before = JSON.stringify(data);
+    data[APPLE_SIGN_IN_KEY] = ["Default"];
+    if (JSON.stringify(data) !== before || !store.read(storeRel).trim()) {
+      store.write(storeRel, buildPlistXml(data));
+      changedRelPaths.push(storeRel);
+    }
+  }
+  return changedRelPaths;
+}

package/src/ios/fileManager.ts

@@ -0,0 +1,48 @@
+import fs from "node:fs";
+import path from "node:path";
+
+/** Copies SDK assets into `{srcRoot}/topSDK/` (topsdk-tool-ios FileManager). */
+export class TopSdkFileManager {
+  readonly topSdkRel = "topSDK";
+  readonly topSdkAbs: string;
+
+  constructor(readonly srcRoot: string) {
+    this.topSdkAbs = path.join(srcRoot, this.topSdkRel);
+    fs.mkdirSync(this.topSdkAbs, { recursive: true });
+  }
+
+  relFromSrc(absPath: string): string {
+    return path.relative(this.srcRoot, absPath).split(path.sep).join("/");
+  }
+
+  copyFramework(srcPath: string): string {
+    const base = path.basename(srcPath);
+    if (!base.includes(".framework") && !base.includes(".xcframework") && !base.includes(".bundle")) {
+      throw new Error(`not a framework/xcframework/bundle: ${srcPath}`);
+    }
+    if (!fs.existsSync(srcPath)) throw new Error(`framework not found: ${srcPath}`);
+    const dest = path.join(this.topSdkAbs, base);
+    fs.rmSync(dest, { recursive: true, force: true });
+    fs.cpSync(srcPath, dest, { recursive: true });
+    return dest;
+  }
+
+  copyDir(srcPath: string): string {
+    if (!fs.existsSync(srcPath)) throw new Error(`directory not found: ${srcPath}`);
+    const base = path.basename(srcPath);
+    const dest = path.join(this.topSdkAbs, base);
+    fs.rmSync(dest, { recursive: true, force: true });
+    fs.cpSync(srcPath, dest, { recursive: true });
+    return dest;
+  }
+
+  copyFile(srcPath: string): string {
+    if (!fs.existsSync(srcPath) || !fs.statSync(srcPath).isFile()) {
+      throw new Error(`file not found: ${srcPath}`);
+    }
+    const dest = path.join(this.topSdkAbs, path.basename(srcPath));
+    fs.rmSync(dest, { force: true });
+    fs.copyFileSync(srcPath, dest);
+    return dest;
+  }
+}

package/src/ios/infoPlist.ts

@@ -0,0 +1,55 @@
+import { build as buildPlist, parse as parsePlist } from "plist";
+
+export interface PlistDocument {
+  relPath: string;
+  data: Record<string, unknown>;
+}
+
+export function parsePlistXml(xml: string): Record<string, unknown> {
+  const parsed = parsePlist(xml);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return {};
+  }
+  return parsed as Record<string, unknown>;
+}
+
+export function buildPlistXml(data: Record<string, unknown>): string {
+  return buildPlist(data as Parameters<typeof buildPlist>[0]);
+}
+
+export function addPlistParam(data: Record<string, unknown>, key: string, value: unknown): void {
+  data[key] = value;
+}
+
+export function setAppTransportSecurity(data: Record<string, unknown>, open: boolean): void {
+  const security =
+    (data.NSAppTransportSecurity as Record<string, unknown> | undefined) ?? {};
+  security.NSAllowsArbitraryLoads = open;
+  data.NSAppTransportSecurity = security;
+}
+
+export function addQueriesScheme(data: Record<string, unknown>, scheme: string): void {
+  if (!scheme) return;
+  const schemes = Array.isArray(data.LSApplicationQueriesSchemes)
+    ? [...(data.LSApplicationQueriesSchemes as string[])]
+    : [];
+  if (schemes.includes(scheme)) return;
+  schemes.push(scheme);
+  data.LSApplicationQueriesSchemes = schemes;
+}
+
+export function addUrlScheme(data: Record<string, unknown>, urlScheme: string): void {
+  if (!urlScheme) return;
+  const types = Array.isArray(data.CFBundleURLTypes)
+    ? [...(data.CFBundleURLTypes as Array<Record<string, unknown>>)]
+    : [];
+  for (const entry of types) {
+    const urls = entry.CFBundleURLSchemes as string[] | undefined;
+    if (urls?.includes(urlScheme)) return;
+  }
+  types.push({
+    CFBundleTypeRole: "Editor",
+    CFBundleURLSchemes: [urlScheme],
+  });
+  data.CFBundleURLTypes = types;
+}

package/src/ios/integrate.ts

@@ -0,0 +1,516 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import type { StepResult, WorkspaceContext } from "../contracts/types.js";
+import {
+  MEETSDK_REMOTE_CONFIG_FILENAME,
+  tryParseAsMeetSdkRemoteConfig,
+  validateMeetSdkRemoteConfig,
+} from "../config/meetSdkRemoteConfig.js";
+import type { TextFileStore } from "../ops/fileStore.js";
+import type { BinaryCopy } from "../ops/handlers.js";
+import { buildChannelConfigMap, enabledIosPluginFolders, unsupportedIosModuleKeys } from "./channelConfig.js";
+import { CodeUtils, findDelegateFiles, findSceneDelegateFiles } from "./codeUtils.js";
+import type { CodeConfig, LoadedPluginConfig } from "./types.js";
+import { DEFAULT_PERFORM_SETTINGS, type PerformSetting } from "./types.js";
+import { TopSdkFileManager } from "./fileManager.js";
+import {
+  addPlistParam,
+  addQueriesScheme,
+  addUrlScheme,
+  buildPlistXml,
+  parsePlistXml,
+  setAppTransportSecurity,
+  type PlistDocument,
+} from "./infoPlist.js";
+import {
+  addCopyFile,
+  addOtherLinkerFlag,
+  addSourceOrResourceFile,
+  addSystemFramework,
+  addSystemLib,
+  addThirdPartyFramework,
+  findInfoPlistPathsFromPbx,
+  loadPbxFromStore,
+  savePbxToStore,
+  setBuildSetting,
+  type PbxContext,
+} from "./pbxprojEditor.js";
+import { findPluginByFolder, listSdkCoreConfigs, validateLoadedPluginResources } from "./pluginConfig.js";
+import { resolveIosSdkRoot } from "./sdkBundle.js";
+import { applyChannelTemplate, applyChannelTemplateValue } from "./template.js";
+import { ensureAppleSignInEntitlement } from "./entitlements.js";
+
+export interface IosIntegrateOptions {
+  dryRun?: boolean;
+  targetName?: string;
+  executeAppDelegate?: boolean;
+  performSettings?: readonly PerformSetting[];
+}
+
+const IOS_FIREBASE_CONFIG_FILE = "GoogleService-Info.plist";
+
+function ok(changed: string[], warnings: string[] = []): StepResult {
+  return { ok: true, changedFiles: changed, warnings, errors: [] };
+}
+
+function fail(errors: string[], warnings: string[] = []): StepResult {
+  return { ok: false, changedFiles: [], warnings, errors };
+}
+
+function applyPlugin(
+  loaded: LoadedPluginConfig,
+  pbx: PbxContext,
+  fm: TopSdkFileManager,
+  channelConfig: Record<string, unknown>,
+  perform: readonly PerformSetting[],
+  binaryCopies: BinaryCopy[],
+  dryRun: boolean,
+  remoteSources: Map<string, string> = new Map()
+): void {
+  const { config, sourceDir } = loaded;
+  const srcRoot = pbx.srcRoot;
+
+  if (perform.includes("frameworks") && config.frameworks?.length) {
+    for (const fw of config.frameworks) {
+      if (fw.system) {
+        addSystemFramework(pbx, fw.name);
+        continue;
+      }
+      const src = path.join(sourceDir, fw.name);
+      if (!fs.existsSync(src)) throw new Error(`missing framework resource for ${config.name}: ${fw.name}`);
+      const relTo = path.join(fm.topSdkRel, path.basename(src)).split(path.sep).join("/");
+      if (dryRun) {
+        binaryCopies.push({ fromAbs: src, relTo });
+      } else {
+        fm.copyFramework(src);
+      }
+      addThirdPartyFramework(pbx, relTo, Boolean(fw.embed));
+      if (fw.copyFile) addCopyFile(pbx, relTo);
+    }
+  }
+
+  if (perform.includes("libs") && config.libs?.length) {
+    for (const lib of config.libs) {
+      if (lib.system) {
+        addSystemLib(pbx, lib.name);
+        continue;
+      }
+      const src = path.join(sourceDir, lib.name);
+      if (!fs.existsSync(src)) throw new Error(`missing lib resource for ${config.name}: ${lib.name}`);
+      const relTo = path.join(fm.topSdkRel, path.basename(src)).split(path.sep).join("/");
+      if (dryRun) binaryCopies.push({ fromAbs: src, relTo });
+      else fm.copyFile(src);
+      addSourceOrResourceFile(pbx, relTo);
+    }
+  }
+
+  if (perform.includes("sources") && config.sources?.length) {
+    for (const source of config.sources) {
+      const remoteRel = remoteSources.get(`${config.name}:${source}`);
+      if (remoteRel) {
+        addSourceOrResourceFile(pbx, remoteRel);
+        continue;
+      }
+      const src = path.join(sourceDir, source);
+      if (!fs.existsSync(src)) throw new Error(`missing source resource for ${config.name}: ${source}`);
+      if (
+        fs.statSync(src).isDirectory() &&
+        !src.endsWith(".bundle") &&
+        !src.endsWith(".framework") &&
+        !src.endsWith(".xcdatamodeld")
+      ) {
+        if (!dryRun) {
+          const copied = fm.copyDir(src);
+          const walk = (dir: string): void => {
+            for (const name of fs.readdirSync(dir)) {
+              const full = path.join(dir, name);
+              if (fs.statSync(full).isDirectory()) {
+                if (name.endsWith(".bundle")) {
+                  addSourceOrResourceFile(pbx, fm.relFromSrc(full));
+                } else {
+                  walk(full);
+                }
+                continue;
+              }
+              if (/\.(h|m|mm|plist|a)$/.test(name)) {
+                addSourceOrResourceFile(pbx, fm.relFromSrc(full));
+              }
+            }
+          };
+          walk(copied);
+        }
+      } else {
+        const relTo = path.join(fm.topSdkRel, path.basename(src)).split(path.sep).join("/");
+        if (dryRun) binaryCopies.push({ fromAbs: src, relTo });
+        else if (fs.statSync(src).isDirectory()) fm.copyDir(src);
+        else fm.copyFile(src);
+        addSourceOrResourceFile(pbx, relTo);
+      }
+    }
+  }
+
+  if (perform.includes("buildSettings") && config.buildSettings) {
+    for (const [k, v] of Object.entries(config.buildSettings)) {
+      setBuildSetting(pbx, k, v);
+    }
+  }
+
+  if (perform.includes("OtherLinkerFlags") && config.OtherLinkerFlags?.length) {
+    for (const flag of config.OtherLinkerFlags) {
+      addOtherLinkerFlag(pbx, flag);
+    }
+  }
+
+}
+
+function validateLoadedPluginResourcesForIos(loaded: LoadedPluginConfig): string[] {
+  const errors = validateLoadedPluginResources(loaded);
+  if (loaded.config.name !== "FirebaseManager") return errors;
+  return errors.filter((error) => !error.includes(`missing source resource for FirebaseManager: ${IOS_FIREBASE_CONFIG_FILE}`));
+}
+
+async function downloadIosFirebaseConfig(
+  remote: ReturnType<typeof tryParseAsMeetSdkRemoteConfig>,
+  pbx: PbxContext,
+  dryRun: boolean,
+  relTo: string
+): Promise<{ remoteSources: Map<string, string>; warnings: string[]; errors: string[] }> {
+  const remoteSources = new Map<string, string>();
+  const warnings: string[] = [];
+  const errors: string[] = [];
+  const firebase = remote?.sdkModules.analytics.firebase;
+  if (typeof firebase !== "object" || firebase === null) {
+    return { remoteSources, warnings, errors };
+  }
+
+  const url = firebase.firebase_file_url?.trim();
+  if (!url) {
+    errors.push("iOS Firebase config requires sdkModules.analytics.firebase.firebaseUrl");
+    return { remoteSources, warnings, errors };
+  }
+
+  remoteSources.set(`FirebaseManager:${IOS_FIREBASE_CONFIG_FILE}`, relTo);
+
+  if (dryRun) {
+    warnings.push(`would download ${IOS_FIREBASE_CONFIG_FILE} to ${relTo}`);
+    return { remoteSources, warnings, errors };
+  }
+
+  let res: Response;
+  try {
+    res = await fetch(url);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    errors.push(`iOS Firebase config download failed: ${msg}`);
+    return { remoteSources, warnings, errors };
+  }
+  if (!res.ok) {
+    errors.push(`iOS Firebase config download failed: HTTP ${res.status} ${res.statusText}`);
+    return { remoteSources, warnings, errors };
+  }
+
+  const abs = path.join(pbx.srcRoot, relTo);
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  fs.writeFileSync(abs, Buffer.from(await res.arrayBuffer()));
+  warnings.push(`downloaded ${IOS_FIREBASE_CONFIG_FILE} to ${relTo}`);
+  return { remoteSources, warnings, errors };
+}
+
+function iosFirebaseConfigRelPath(plistDocs: PlistDocument[]): string {
+  const relPlist = plistDocs[0]?.relPath;
+  if (!relPlist) return IOS_FIREBASE_CONFIG_FILE;
+  const dir = path.posix.dirname(relPlist.replace(/\\/g, "/"));
+  return dir === "." ? IOS_FIREBASE_CONFIG_FILE : path.posix.join(dir, IOS_FIREBASE_CONFIG_FILE);
+}
+
+function appDelegateCodeShouldMoveToSceneDelegate(code: CodeConfig): boolean {
+  if (code.type === "header") return false;
+  const method = code.method ?? "";
+  return (
+    method.includes("openURL") ||
+    method.includes("continueUserActivity") ||
+    method.includes("applicationDidEnterBackground") ||
+    method.includes("applicationWillEnterForeground")
+  );
+}
+
+function appDelegateCodesForLifecycle(loaded: LoadedPluginConfig, hasUniqueSceneDelegate: boolean): CodeConfig[] {
+  const codes = loaded.config.appDelegateCodes ?? [];
+  if (!hasUniqueSceneDelegate) return codes;
+  return codes.filter((code) => !appDelegateCodeShouldMoveToSceneDelegate(code));
+}
+
+function readDottedPath(obj: Record<string, unknown>, dottedPath: string): unknown {
+  let cur: unknown = obj;
+  for (const part of dottedPath.split(".")) {
+    if (!part) continue;
+    if (cur && typeof cur === "object" && part in (cur as Record<string, unknown>)) {
+      cur = (cur as Record<string, unknown>)[part];
+    } else {
+      return undefined;
+    }
+  }
+  return cur;
+}
+
+function validateRequiredChannelConfigs(
+  loadedConfigs: LoadedPluginConfig[],
+  channelConfig: Record<string, unknown>
+): string[] {
+  const missing: string[] = [];
+  for (const loaded of loadedConfigs) {
+    for (const required of loaded.config.requireConfigs ?? []) {
+      const value = readDottedPath(channelConfig, required);
+      if (value === undefined || value === null || String(value).length === 0) {
+        missing.push(`${loaded.config.name}: ${required}`);
+      }
+    }
+  }
+  return missing;
+}
+
+function mergePlistParams(
+  docs: PlistDocument[],
+  loaded: LoadedPluginConfig,
+  channelConfig: Record<string, unknown>,
+  perform: readonly PerformSetting[]
+): void {
+  if (!perform.includes("infoParams") && !perform.includes("urlScheme") && !perform.includes("queriesSchemes")) {
+    return;
+  }
+  for (const doc of docs) {
+    if (perform.includes("infoParams") && loaded.config.infoParams) {
+      for (const [key, raw] of Object.entries(loaded.config.infoParams)) {
+        addPlistParam(doc.data, key, applyChannelTemplateValue(raw, channelConfig));
+      }
+    }
+    if (perform.includes("queriesSchemes") && loaded.config.queriesSchemes?.length) {
+      for (const scheme of loaded.config.queriesSchemes) {
+        addQueriesScheme(doc.data, scheme);
+      }
+    }
+    if (perform.includes("urlScheme") && loaded.config.urlScheme) {
+      let scheme = applyChannelTemplate(loaded.config.urlScheme, channelConfig);
+      if (scheme.endsWith("://")) scheme = scheme.replace("://", "");
+      addUrlScheme(doc.data, scheme);
+    }
+  }
+}
+
+function buildTopSdkPluginInfo(
+  plugins: LoadedPluginConfig[],
+  channelConfig: Record<string, unknown>
+): { pluginsInfo: Array<Record<string, unknown>>; dataPluginsInfo: Array<Record<string, unknown>> } {
+  const pluginsInfo: Array<Record<string, unknown>> = [];
+  const dataPluginsInfo: Array<Record<string, unknown>> = [];
+  for (const loaded of plugins) {
+    const info: Record<string, unknown> = { name: loaded.config.name };
+    const key = loaded.config.key;
+    if (key && Object.prototype.hasOwnProperty.call(channelConfig, key)) {
+      const params: Record<string, string> = {};
+      for (const [paramKey, rawValue] of Object.entries(loaded.config.pluginParams ?? {})) {
+        params[paramKey] = applyChannelTemplate(String(rawValue), channelConfig);
+      }
+      info.params = params;
+    }
+    if (loaded.config.type === 4) {
+      dataPluginsInfo.push(info);
+    } else {
+      pluginsInfo.push(info);
+    }
+  }
+  return { pluginsInfo, dataPluginsInfo };
+}
+
+export async function runIosIntegrateTopSdk(
+  ctx: WorkspaceContext,
+  store: TextFileStore,
+  binaryCopies: BinaryCopy[],
+  options: IosIntegrateOptions = {}
+): Promise<StepResult> {
+  if (!ctx.ios?.ok) return fail(["iOS project not detected"]);
+  const warnings: string[] = [];
+  const changed = new Set<string>();
+
+  const configPath = path.join(ctx.projectRoot, MEETSDK_REMOTE_CONFIG_FILENAME);
+  if (!fs.existsSync(configPath)) {
+    return fail([`${MEETSDK_REMOTE_CONFIG_FILENAME} not found; run fetch-config or setup first`]);
+  }
+  let remote: ReturnType<typeof tryParseAsMeetSdkRemoteConfig>;
+  try {
+    remote = tryParseAsMeetSdkRemoteConfig(JSON.parse(fs.readFileSync(configPath, "utf8")) as unknown);
+  } catch (e) {
+    return fail([e instanceof Error ? e.message : String(e)]);
+  }
+  if (!remote) {
+    return fail([`invalid ${MEETSDK_REMOTE_CONFIG_FILENAME}`]);
+  }
+  const validation = validateMeetSdkRemoteConfig(remote);
+  if (!validation.ok) {
+    warnings.push(`remote config missing fields: ${validation.missing.join(", ")}`);
+  }
+
+  let sdkRoot: string;
+  try {
+    sdkRoot = resolveIosSdkRoot(ctx.packageRoot);
+  } catch (e) {
+    return fail([e instanceof Error ? e.message : String(e)]);
+  }
+
+  const targetName = options.targetName ?? ctx.ios.targetName ?? path.basename(ctx.ios.xcodeprojPath!, ".xcodeproj");
+  const perform = options.performSettings ?? DEFAULT_PERFORM_SETTINGS;
+  const executeAppDelegate = options.executeAppDelegate !== false;
+  const dryRun = Boolean(options.dryRun);
+
+  const channelConfig = buildChannelConfigMap(remote);
+  const coreConfigs = listSdkCoreConfigs(sdkRoot);
+  const pluginFolders = enabledIosPluginFolders(remote);
+  for (const key of unsupportedIosModuleKeys(remote)) {
+    warnings.push(`iOS plugin mapping not found for sdkModules.${key}; skipped`);
+  }
+  const pluginConfigs: LoadedPluginConfig[] = [];
+  for (const folder of pluginFolders) {
+    const p = findPluginByFolder(sdkRoot, folder);
+    if (p) pluginConfigs.push(p);
+    else warnings.push(`iOS plugin folder not in SDK package: plugins/${folder}`);
+  }
+  const xcodeprojPath = ctx.ios.xcodeprojPath!;
+  const pbx = await loadPbxFromStore(store, ctx.projectRoot, xcodeprojPath, targetName);
+  const fm = new TopSdkFileManager(pbx.srcRoot);
+
+  let plistDocs: PlistDocument[];
+  try {
+    plistDocs = await ensureInfoPlists(store, ctx, pbx, targetName);
+  } catch (e) {
+    return fail([e instanceof Error ? e.message : String(e)], warnings);
+  }
+
+  const firebaseDownload = await downloadIosFirebaseConfig(remote, pbx, dryRun, iosFirebaseConfigRelPath(plistDocs));
+  warnings.push(...firebaseDownload.warnings);
+  if (firebaseDownload.errors.length) return fail(firebaseDownload.errors, warnings);
+
+  const resourceErrors = [...coreConfigs, ...pluginConfigs].flatMap(validateLoadedPluginResourcesForIos);
+  if (resourceErrors.length) return fail(resourceErrors, warnings);
+
+  const missingRequiredConfigs = validateRequiredChannelConfigs(pluginConfigs, channelConfig);
+  if (missingRequiredConfigs.length) {
+    return fail([`iOS remote config missing required channel params: ${missingRequiredConfigs.join(", ")}`], warnings);
+  }
+
+  for (const loaded of coreConfigs) {
+    applyPlugin(loaded, pbx, fm, channelConfig, perform, binaryCopies, dryRun, firebaseDownload.remoteSources);
+  }
+  for (const loaded of pluginConfigs) {
+    applyPlugin(loaded, pbx, fm, channelConfig, perform, binaryCopies, dryRun, firebaseDownload.remoteSources);
+  }
+
+  for (const loaded of [...coreConfigs, ...pluginConfigs]) {
+    mergePlistParams(plistDocs, loaded, channelConfig, perform);
+    if (perform.includes("infoParams")) {
+      setAppTransportSecurity(plistDocs[0]?.data ?? {}, true);
+    }
+  }
+  for (const doc of plistDocs) {
+    if (perform.includes("infoParams")) {
+      const { pluginsInfo, dataPluginsInfo } = buildTopSdkPluginInfo(pluginConfigs, channelConfig);
+      addPlistParam(doc.data, "TOPSDK", {
+        APP_ID: remote.topsdk.appId,
+        Plugins: pluginsInfo,
+        dataPlugins: dataPluginsInfo,
+      });
+    }
+    const rel = path.relative(ctx.projectRoot, path.join(pbx.srcRoot, doc.relPath)).split(path.sep).join("/");
+    store.write(rel, buildPlistXml(doc.data));
+    changed.add(rel);
+  }
+
+  if (perform.includes("infoParams") && pluginConfigs.some((p) => p.config.name === "AppleSignin")) {
+    for (const rel of ensureAppleSignInEntitlement(store, ctx.projectRoot, pbx)) {
+      changed.add(rel);
+    }
+  }
+
+  savePbxToStore(store, pbx);
+  changed.add(pbx.rel);
+
+  if (executeAppDelegate) {
+    const sceneDelegateRelPaths: string[] = [];
+    for (const abs of findSceneDelegateFiles(pbx.srcRoot)) {
+      sceneDelegateRelPaths.push(path.relative(ctx.projectRoot, abs).split(path.sep).join("/"));
+    }
+    const hasUniqueSceneDelegate = sceneDelegateRelPaths.length === 1;
+
+    const delegateRelPaths: string[] = [];
+    for (const abs of findDelegateFiles(pbx.srcRoot)) {
+      delegateRelPaths.push(path.relative(ctx.projectRoot, abs).split(path.sep).join("/"));
+    }
+    if (!delegateRelPaths.length) {
+      warnings.push("no UIApplicationDelegate .m/.mm found; skipped AppDelegate injection (SwiftUI @main is not supported yet)");
+    }
+    if (delegateRelPaths.length > 1) {
+      warnings.push(`multiple UIApplicationDelegate files found; skipped AppDelegate injection: ${delegateRelPaths.join(", ")}`);
+    }
+    for (const rel of delegateRelPaths.length === 1 ? delegateRelPaths : []) {
+      const cu = CodeUtils.fromFile(path.join(ctx.projectRoot, rel));
+      let okInject = true;
+      for (const loaded of [...coreConfigs, ...pluginConfigs]) {
+        for (const code of appDelegateCodesForLifecycle(loaded, hasUniqueSceneDelegate)) {
+          if (code.type === "header") {
+            if (!cu.addHeader(code.content)) okInject = false;
+          } else if ((code.type === "method" || code.type === "code") && code.method) {
+            if (!cu.addCodeToMethod(code.method, code.content, Boolean(code.addToReturn))) okInject = false;
+          }
+        }
+      }
+      if (!okInject) warnings.push(`AppDelegate injection incomplete for ${rel}`);
+      const before = store.read(rel);
+      cu.applyToStore((c) => store.write(rel, c));
+      if (store.read(rel) !== before) changed.add(rel);
+    }
+
+    if (sceneDelegateRelPaths.length > 1) {
+      warnings.push(`multiple UIWindowSceneDelegate files found; skipped SceneDelegate injection: ${sceneDelegateRelPaths.join(", ")}`);
+    }
+    for (const rel of sceneDelegateRelPaths.length === 1 ? sceneDelegateRelPaths : []) {
+      const cu = CodeUtils.fromFile(path.join(ctx.projectRoot, rel));
+      let okInject = true;
+      for (const loaded of [...coreConfigs, ...pluginConfigs]) {
+        for (const code of loaded.config.sceneDelegateCodes ?? []) {
+          if (code.type === "header") {
+            if (!cu.addHeader(code.content)) okInject = false;
+          } else if ((code.type === "method" || code.type === "code") && code.method) {
+            if (!cu.addCodeToMethod(code.method, code.content, Boolean(code.addToReturn))) okInject = false;
+          }
+        }
+      }
+      if (!okInject) warnings.push(`SceneDelegate injection incomplete for ${rel}`);
+      const before = store.read(rel);
+      cu.applyToStore((c) => store.write(rel, c));
+      if (store.read(rel) !== before) changed.add(rel);
+    }
+  }
+
+  return ok([...changed], warnings);
+}
+
+async function ensureInfoPlists(
+  store: TextFileStore,
+  ctx: WorkspaceContext,
+  pbx: PbxContext,
+  targetName: string
+): Promise<PlistDocument[]> {
+  const absPaths = findInfoPlistPathsFromPbx(pbx);
+  if (absPaths.length) {
+    return absPaths.map((abs) => {
+      const rel = path.relative(ctx.projectRoot, abs).split(path.sep).join("/");
+      if (!fs.existsSync(abs)) {
+        throw new Error(`Info.plist not found for iOS target ${targetName}: ${rel}`);
+      }
+      const xml = store.read(rel) || fs.readFileSync(abs, "utf8");
+      return { relPath: path.relative(pbx.srcRoot, abs).split(path.sep).join("/"), data: parsePlistXml(xml) };
+    });
+  }
+
+  throw new Error(`Info.plist not found for iOS target ${targetName}; configure INFOPLIST_FILE before running setup`);
+}