@leonxin/meetgames 0.1.15 → 0.1.17

package/src/ios/pbxprojEditor.ts

@@ -12,6 +12,13 @@ const xcode = require("xcode") as {
   project: (pbxprojPath: string) => XcodeProject;
 };
 
+const EXPECTED_SIGNATURE_BY_XCFRAMEWORK: Record<string, string> = {
+  "FBAEMKit.xcframework": '"AppleDeveloperProgram:V9WTTPBFK9:Meta Platforms, Inc."',
+  "FBSDKCoreKit.xcframework": '"AppleDeveloperProgram:V9WTTPBFK9:Meta Platforms, Inc."',
+  "FBSDKCoreKit_Basics.xcframework": '"AppleDeveloperProgram:V9WTTPBFK9:Meta Platforms, Inc."',
+  "FBSDKLoginKit.xcframework": '"AppleDeveloperProgram:V9WTTPBFK9:Meta Platforms, Inc."',
+};
+
 export interface PbxContext {
   rel: string;
   proj: XcodeProject;
@@ -216,6 +223,36 @@ function frameworkFileType(file: string): string {
   return file.endsWith(".xcframework") ? "wrapper.xcframework" : "wrapper.framework";
 }
 
+function expectedSignature(file: string): string | undefined {
+  return EXPECTED_SIGNATURE_BY_XCFRAMEWORK[path.basename(file)];
+}
+
+function formatLastKnownFileType(lastKnownFileType: string): string {
+  return lastKnownFileType === "wrapper.plug-in" ? '"wrapper.plug-in"' : quotePbxStringIfNeeded(lastKnownFileType);
+}
+
+function topSdkFileReference(file: string, lastKnownFileType: string): Record<string, unknown> {
+  const basename = path.basename(file);
+  const ref: Record<string, unknown> = {
+    isa: "PBXFileReference",
+  };
+  const signature = expectedSignature(file);
+  if (signature) ref.expectedSignature = signature;
+  ref.lastKnownFileType = formatLastKnownFileType(lastKnownFileType);
+  ref.name = basename;
+  ref.path = file;
+  ref.sourceTree = "SOURCE_ROOT";
+  return ref;
+}
+
+function normalizeTopSdkFileReference(ref: Record<string, unknown>, file: string, lastKnownFileType: string): void {
+  const normalized = topSdkFileReference(file, lastKnownFileType);
+  for (const [key, value] of Object.entries(normalized)) {
+    ref[key] = value;
+  }
+  delete ref.includeInIndex;
+}
+
 function ensureFileRef(ctx: PbxContext, file: string, lastKnownFileType: string): string {
   const basename = path.basename(file);
   const existing = findFileRefUuid(ctx, file);
@@ -223,20 +260,13 @@ function ensureFileRef(ctx: PbxContext, file: string, lastKnownFileType: string)
   if (existing) {
     const ref = fileRefSection[existing];
     if (ref && typeof ref === "object") {
-      (ref as Record<string, unknown>).lastKnownFileType = lastKnownFileType;
+      normalizeTopSdkFileReference(ref as Record<string, unknown>, file, lastKnownFileType);
     }
     return existing;
   }
 
   const uuid = ctx.proj.generateUuid();
-  fileRefSection[uuid] = {
-    isa: "PBXFileReference",
-    name: `"${basename}"`,
-    path: `"${file}"`,
-    sourceTree: '"<group>"',
-    lastKnownFileType,
-    includeInIndex: 0,
-  };
+  fileRefSection[uuid] = topSdkFileReference(file, lastKnownFileType);
   fileRefSection[`${uuid}_comment`] = basename;
   return uuid;
 }
@@ -322,15 +352,14 @@ function addCopyFileManually(ctx: PbxContext, target: string, file: string): voi
   if (!fileRefUuid) {
     fileRefUuid = ctx.proj.generateUuid();
     const fileRefSection = objectSection(ctx.proj, "PBXFileReference");
-    fileRefSection[fileRefUuid] = {
-      isa: "PBXFileReference",
-      name: `"${basename}"`,
-      path: `"${file}"`,
-      sourceTree: '"<group>"',
-      lastKnownFileType: "wrapper.framework",
-      includeInIndex: 0,
-    };
+    fileRefSection[fileRefUuid] = topSdkFileReference(file, "wrapper.framework");
     fileRefSection[`${fileRefUuid}_comment`] = basename;
+  } else {
+    const fileRefSection = objectSection(ctx.proj, "PBXFileReference");
+    const ref = fileRefSection[fileRefUuid];
+    if (ref && typeof ref === "object") {
+      normalizeTopSdkFileReference(ref as Record<string, unknown>, file, "wrapper.framework");
+    }
   }
 
   const buildUuid = ctx.proj.generateUuid();
@@ -421,13 +450,7 @@ function addSourceFileManually(ctx: PbxContext, file: string, lastKnownFileType?
   const fileRefSection = objectSection(ctx.proj, "PBXFileReference");
   const buildFileSection = objectSection(ctx.proj, "PBXBuildFile");
 
-  fileRefSection[fileRefUuid] = {
-    isa: "PBXFileReference",
-    name: `"${basename}"`,
-    path: `"${file}"`,
-    sourceTree: '"<group>"',
-    lastKnownFileType: lastKnownFileType ?? sourceFileType(file),
-  };
+  fileRefSection[fileRefUuid] = topSdkFileReference(file, lastKnownFileType ?? sourceFileType(file));
   fileRefSection[`${fileRefUuid}_comment`] = basename;
   buildFileSection[buildUuid] = {
     isa: "PBXBuildFile",
@@ -458,14 +481,7 @@ function addResourceFileManually(ctx: PbxContext, file: string, lastKnownFileTyp
   const fileRefSection = objectSection(ctx.proj, "PBXFileReference");
   const buildFileSection = objectSection(ctx.proj, "PBXBuildFile");
 
-  fileRefSection[fileRefUuid] = {
-    isa: "PBXFileReference",
-    name: `"${basename}"`,
-    path: `"${file}"`,
-    sourceTree: '"<group>"',
-    lastKnownFileType: resourceFileType(file, lastKnownFileType),
-    includeInIndex: 0,
-  };
+  fileRefSection[fileRefUuid] = topSdkFileReference(file, resourceFileType(file, lastKnownFileType));
   fileRefSection[`${fileRefUuid}_comment`] = basename;
   buildFileSection[buildUuid] = {
     isa: "PBXBuildFile",

package/src/remote/sdkHomeDownload.ts

@@ -33,9 +33,9 @@ export interface SdkHomeDownloadUrlRequest {
 
 export interface DownloadIosSdkOptions {
   baseUrl?: string;
-  version?: string;
   plugins?: readonly string[] | string;
   packageType?: string;
+  cacheRoot?: string;
   signal?: AbortSignal;
 }
 
@@ -43,13 +43,14 @@ export interface DownloadIosSdkResult {
   version: string;
   versionDate: string;
   versionUrl: string;
-  downloadApiUrl: string;
-  sdkZipUrl: string;
+  downloadApiUrl?: string;
+  sdkZipUrl?: string;
   zipPath: string;
   extractDir: string;
   resolvedSdkRoot: string;
   iosConfigPath: string;
   cacheMetadataPath: string;
+  downloaded: boolean;
 }
 
 function isRecord(value: unknown): value is JsonRecord {
@@ -188,6 +189,68 @@ export function resolveIosSdkRootFromDirectory(bundledDir: string): string {
   throw new Error(`iOS SDK layout invalid under ${bundledDir}: need sdk/ + plugins/ at top level or under one version directory.`);
 }
 
+function tryResolveIosSdkRootFromDirectory(bundledDir: string): string | null {
+  try {
+    return resolveIosSdkRootFromDirectory(bundledDir);
+  } catch {
+    return null;
+  }
+}
+
+function compareSdkVersions(a: string, b: string): number {
+  const left = a.split(/[.-]/);
+  const right = b.split(/[.-]/);
+  const len = Math.max(left.length, right.length);
+  for (let i = 0; i < len; i += 1) {
+    const l = left[i] ?? "0";
+    const r = right[i] ?? "0";
+    const ln = /^\d+$/.test(l) ? Number(l) : null;
+    const rn = /^\d+$/.test(r) ? Number(r) : null;
+    if (ln !== null && rn !== null) {
+      if (ln !== rn) return ln - rn;
+      continue;
+    }
+    const cmp = l.localeCompare(r);
+    if (cmp !== 0) return cmp;
+  }
+  return 0;
+}
+
+function findReusableCachedIosSdk(params: {
+  cacheRoot?: string;
+  packageType: string;
+  plugins: readonly string[];
+  serverVersion: string;
+}): { version: string; layout: ReturnType<typeof resolveIosSdkCacheLayout>; resolvedSdkRoot: string } | null {
+  const probe = resolveIosSdkCacheLayout({
+    version: "__probe__",
+    packageType: params.packageType,
+    plugins: params.plugins,
+    cacheRoot: params.cacheRoot,
+  });
+  const packageDir = path.dirname(path.dirname(probe.baseDir));
+  if (!fs.existsSync(packageDir)) return null;
+
+  let best: { version: string; layout: ReturnType<typeof resolveIosSdkCacheLayout>; resolvedSdkRoot: string } | null = null;
+  for (const ent of fs.readdirSync(packageDir, { withFileTypes: true })) {
+    if (!ent.isDirectory() || ent.name.startsWith(".")) continue;
+    const comparedToServer = compareSdkVersions(ent.name, params.serverVersion);
+    if (comparedToServer < 0) continue;
+    const layout = resolveIosSdkCacheLayout({
+      version: ent.name,
+      packageType: params.packageType,
+      plugins: params.plugins,
+      cacheRoot: params.cacheRoot,
+    });
+    const resolvedSdkRoot = tryResolveIosSdkRootFromDirectory(layout.extractDir);
+    if (!resolvedSdkRoot) continue;
+    if (!best || compareSdkVersions(ent.name, best.version) > 0) {
+      best = { version: ent.name, layout, resolvedSdkRoot };
+    }
+  }
+  return best;
+}
+
 export async function downloadBinaryFile(url: string, absPath: string, signal?: AbortSignal): Promise<void> {
   let res: Response;
   try {
@@ -236,25 +299,39 @@ export async function downloadIosSdkToBundled(
   const baseUrl = options.baseUrl || defaultSdkHomeApiBaseUrl;
   const packageType = options.packageType || DEFAULT_IOS_SDK_PACKAGE_TYPE;
   const plugins = pluginsToList(options.plugins);
-  const versionResult = options.version
-    ? { url: buildSdkHomeVersionUrl(baseUrl), ios: { ver: options.version, date: "" } }
-    : await fetchSdkHomeIosVersion({ baseUrl, signal: options.signal });
-  const version = versionResult.ios.ver;
-  const downloadResult = await fetchSdkHomeIosDownloadUrl({
-    baseUrl,
-    version,
-    plugins,
+  const versionResult = await fetchSdkHomeIosVersion({ baseUrl, signal: options.signal });
+  const serverVersion = versionResult.ios.ver;
+  const reusableCache = findReusableCachedIosSdk({
+    cacheRoot: options.cacheRoot,
     packageType,
-    signal: options.signal,
+    plugins,
+    serverVersion,
   });
-  const cacheLayout = resolveIosSdkCacheLayout({ version, packageType, plugins });
+  const version = reusableCache?.version ?? serverVersion;
+  const cacheLayout =
+    reusableCache?.layout ?? resolveIosSdkCacheLayout({ version, packageType, plugins, cacheRoot: options.cacheRoot });
   const extractDir = cacheLayout.extractDir;
   const zipPath = cacheLayout.zipPath;
+  let downloadApiUrl: string | undefined;
+  let sdkZipUrl: string | undefined;
+  let downloaded = false;
 
   const downloadAndExtract = async (): Promise<void> => {
-    await downloadBinaryFile(downloadResult.sdkZipUrl, zipPath, options.signal);
+    const cachedRoot = tryResolveIosSdkRootFromDirectory(extractDir);
+    if (cachedRoot) return;
+    const fetchedDownload = await fetchSdkHomeIosDownloadUrl({
+      baseUrl,
+      version,
+      plugins,
+      packageType,
+      signal: options.signal,
+    });
+    downloadApiUrl = fetchedDownload.url;
+    sdkZipUrl = fetchedDownload.sdkZipUrl;
+    await downloadBinaryFile(fetchedDownload.sdkZipUrl, zipPath, options.signal);
     fs.rmSync(extractDir, { recursive: true, force: true });
     await extractZip(zipPath, extractDir);
+    downloaded = true;
   };
   await withCacheLock(cacheLayout.lockDir, downloadAndExtract);
   const iosConfigPath = syncMeetSdkIosVersionToConfig({
@@ -266,30 +343,33 @@ export async function downloadIosSdkToBundled(
   });
   const resolvedSdkRoot = resolveIosSdkRootFromDirectory(extractDir);
   const cacheMetadataPath = cacheLayout.metadataPath;
-  writeIosSdkCacheMetadata({
-    metadataPath: cacheMetadataPath,
-    version,
-    date: versionResult.ios.date,
-    packageType,
-    plugins,
-    versionUrl: versionResult.url,
-    downloadApiUrl: downloadResult.url,
-    sdkZipUrl: downloadResult.sdkZipUrl,
-    zipPath,
-    extractDir,
-    resolvedSdkRoot,
-  });
+  if (downloaded && downloadApiUrl && sdkZipUrl) {
+    writeIosSdkCacheMetadata({
+      metadataPath: cacheMetadataPath,
+      version,
+      date: versionResult.ios.date,
+      packageType,
+      plugins,
+      versionUrl: versionResult.url,
+      downloadApiUrl,
+      sdkZipUrl,
+      zipPath,
+      extractDir,
+      resolvedSdkRoot,
+    });
+  }
 
   return {
     version,
     versionDate: versionResult.ios.date,
     versionUrl: versionResult.url,
-    downloadApiUrl: downloadResult.url,
-    sdkZipUrl: downloadResult.sdkZipUrl,
+    downloadApiUrl,
+    sdkZipUrl,
     zipPath,
     extractDir,
     resolvedSdkRoot,
     iosConfigPath,
     cacheMetadataPath,
+    downloaded,
   };
 }

package/tests/pipeline.ios.test.ts

@@ -159,6 +159,18 @@ describe.skipIf(!hasIosProjectFixture)("pipeline ios fixture", () => {
       expect(fs.existsSync(path.join(tmp, "topSDK", "TOPIAPPayPlugin.framework"))).toBe(true);
       expect(fs.readFileSync(path.join(tmp, "topSDK", "TopSDKInstall.swift"), "utf8")).toBe("");
       expect(fs.existsSync(path.join(tmp, "topSDK", "TopSDKSource.bundle"))).toBe(true);
+      expect(
+        fs.readlinkSync(
+          path.join(
+            tmp,
+            "topSDK",
+            "FBSDKLoginKit.xcframework",
+            "ios-arm64_x86_64-maccatalyst",
+            "FBSDKLoginKit.framework",
+            "FBSDKLoginKit"
+          )
+        )
+      ).toBe("Versions/Current/FBSDKLoginKit");
 
       const pbx = fs.readFileSync(path.join(tmp, "native-sample.xcodeproj", "project.pbxproj"), "utf8");
       expect(pbx).toContain("TOPCore.framework");
@@ -167,6 +179,13 @@ describe.skipIf(!hasIosProjectFixture)("pipeline ios fixture", () => {
       expect(pbx).toContain("TOPCoreModel.xcdatamodeld in Sources");
       expect(pbx).not.toContain("TOPCoreModel.xcdatamodeld in Resources");
       expect(pbx).not.toContain("FBSDKLoginKit.xcframework in Resources");
+      expect(pbx).toContain(
+        'FBSDKLoginKit.xcframework */ = {isa = PBXFileReference; expectedSignature = "AppleDeveloperProgram:V9WTTPBFK9:Meta Platforms, Inc."; lastKnownFileType = wrapper.xcframework; name = FBSDKLoginKit.xcframework; path = topSDK/FBSDKLoginKit.xcframework; sourceTree = SOURCE_ROOT; };'
+      );
+      expect(pbx).toContain("FBSDKCoreKit.xcframework");
+      expect(pbx).toContain("FBSDKCoreKit_Basics.xcframework");
+      expect(pbx).toContain("FBAEMKit.xcframework");
+      expect(pbx).not.toContain('path = "topSDK/FBSDKLoginKit.xcframework"; sourceTree = "<group>";');
       expect(pbx).toContain("LIBRARY_SEARCH_PATHS = \"$(SRCROOT)/topSDK\"");
       expect(pbx).toContain("SWIFT_VERSION = 5.0");
       expect(pbx).toContain('"-ObjC"');

package/tests/sdkHomeDownload.test.ts

@@ -2,16 +2,19 @@ import { afterEach, describe, expect, it, vi } from "vitest";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import {
   DEFAULT_IOS_SDK_PLUGINS,
   buildSdkHomeDownloadUrl,
   buildSdkHomeVersionUrl,
+  downloadIosSdkToBundled,
   fetchSdkHomeIosDownloadUrl,
   fetchSdkHomeIosVersion,
   fetchSdkHomeVersions,
   resolveIosSdkRootFromDirectory,
   resolveIosSdkZipFileName,
 } from "../src/remote/sdkHomeDownload.js";
+import { resolveIosSdkCacheLayout } from "../src/cache.js";
 
 describe("sdk-home iOS SDK download client", () => {
   afterEach(() => {
@@ -121,4 +124,101 @@ describe("sdk-home iOS SDK download client", () => {
       fs.rmSync(root, { recursive: true, force: true });
     }
   });
+
+  it("reuses an existing iOS SDK cache for the latest server version", async () => {
+    const version = "99.88.77-cache-test";
+    const cacheRoot = fs.mkdtempSync(path.join(os.tmpdir(), "meet-sdk-tool-cache-"));
+    const cacheLayout = resolveIosSdkCacheLayout({
+      version,
+      packageType: "native",
+      plugins: [...DEFAULT_IOS_SDK_PLUGINS],
+      cacheRoot,
+    });
+    fs.mkdirSync(path.join(cacheLayout.extractDir, "sdk"), { recursive: true });
+    fs.mkdirSync(path.join(cacheLayout.extractDir, "plugins"), { recursive: true });
+    const fetchMock = vi.fn(async (input: string | URL) => {
+      const url = String(input);
+      if (url.includes("/sdk/home/sdk-download/getDownLoadUrl")) {
+        throw new Error("download URL should not be requested when cache is current");
+      }
+      return {
+        ok: true,
+        status: 200,
+        text: async () =>
+          JSON.stringify({
+            code: 200,
+            data: {
+              result: {
+                android: { ver: "1.0.0", date: "2026-01-01" },
+                ios: { ver: version, date: "2026-06-26" },
+              },
+            },
+          }),
+      };
+    });
+    vi.stubGlobal("fetch", fetchMock as unknown as typeof fetch);
+
+    try {
+      const result = await downloadIosSdkToBundled(path.resolve(path.dirname(fileURLToPath(import.meta.url)), ".."), {
+        baseUrl: "https://example.com",
+        cacheRoot,
+      });
+
+      expect(result.version).toBe(version);
+      expect(result.downloaded).toBe(false);
+      expect(result.resolvedSdkRoot).toBe(cacheLayout.extractDir);
+      expect(fetchMock).toHaveBeenCalledTimes(1);
+    } finally {
+      fs.rmSync(cacheRoot, { recursive: true, force: true });
+    }
+  });
+
+  it("reuses a higher local iOS SDK cache instead of downloading an older server version", async () => {
+    const serverVersion = "99.88.77-cache-test";
+    const cachedVersion = "99.88.78-cache-test";
+    const cacheRoot = fs.mkdtempSync(path.join(os.tmpdir(), "meet-sdk-tool-cache-"));
+    const cacheLayout = resolveIosSdkCacheLayout({
+      version: cachedVersion,
+      packageType: "native",
+      plugins: [...DEFAULT_IOS_SDK_PLUGINS],
+      cacheRoot,
+    });
+    fs.mkdirSync(path.join(cacheLayout.extractDir, "sdk"), { recursive: true });
+    fs.mkdirSync(path.join(cacheLayout.extractDir, "plugins"), { recursive: true });
+    const fetchMock = vi.fn(async (input: string | URL) => {
+      const url = String(input);
+      if (url.includes("/sdk/home/sdk-download/getDownLoadUrl")) {
+        throw new Error("download URL should not be requested when a higher cache is available");
+      }
+      return {
+        ok: true,
+        status: 200,
+        text: async () =>
+          JSON.stringify({
+            code: 200,
+            data: {
+              result: {
+                android: { ver: "1.0.0", date: "2026-01-01" },
+                ios: { ver: serverVersion, date: "2026-06-26" },
+              },
+            },
+          }),
+      };
+    });
+    vi.stubGlobal("fetch", fetchMock as unknown as typeof fetch);
+
+    try {
+      const result = await downloadIosSdkToBundled(path.resolve(path.dirname(fileURLToPath(import.meta.url)), ".."), {
+        baseUrl: "https://example.com",
+        cacheRoot,
+      });
+
+      expect(result.version).toBe(cachedVersion);
+      expect(result.downloaded).toBe(false);
+      expect(result.resolvedSdkRoot).toBe(cacheLayout.extractDir);
+      expect(fetchMock).toHaveBeenCalledTimes(1);
+    } finally {
+      fs.rmSync(cacheRoot, { recursive: true, force: true });
+    }
+  });
 });