@leonxin/meetgames 0.1.8 → 0.1.11

package/tests/pipeline.ios.test.ts

@@ -0,0 +1,385 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+import { loadManifestFile } from "../src/config/loadManifest.js";
+import { buildWorkspaceContext } from "../src/core/workspace.js";
+import { runPipeline } from "../src/core/pipeline.js";
+import { detectIOS } from "../src/ios/detect.js";
+import { resolveIosSdkRoot } from "../src/ios/sdkBundle.js";
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const pkgRoot = path.resolve(here, "..");
+const iosRoot = path.join(pkgRoot, "fixtures", "ios-test-project", "tooltest");
+const iosRemoteConfigFixture = path.join(pkgRoot, "fixtures", "meetsdk-remote-config.ios-tooltest.json");
+const hasIosProjectFixture = fs.existsSync(iosRoot);
+const manifest = () => loadManifestFile(path.join(pkgRoot, "recipes", "ios-default.yaml"));
+
+function writeOfflineRemoteConfig(projectRoot: string): void {
+  fs.copyFileSync(iosRemoteConfigFixture, path.join(projectRoot, "meetsdk-remote-config.json"));
+}
+
+function copyProjectToTemp(): string {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "meet-ios-integrate-"));
+  fs.cpSync(iosRoot, tmp, { recursive: true });
+  writeOfflineRemoteConfig(tmp);
+  return tmp;
+}
+
+function pbxBuildFileRefErrors(pbx: string): string[] {
+  const fileRefs = new Set<string>();
+  for (const match of pbx.matchAll(/^\s*([A-F0-9]{24}) \/\* .* \*\/ = \{isa = PBXFileReference;/gm)) {
+    fileRefs.add(match[1]);
+  }
+
+  const errors: string[] = [];
+  for (const match of pbx.matchAll(
+    /^\s*([A-F0-9]{24}) \/\* (.*?) \*\/ = \{isa = PBXBuildFile; fileRef = ([A-F0-9]{24}) /gm
+  )) {
+    const [, buildFileId, label, fileRefId] = match;
+    if (!fileRefs.has(fileRefId)) errors.push(`${label}: ${buildFileId} -> ${fileRefId}`);
+  }
+  return errors;
+}
+
+function plannedIosAsset(patch: string, binaryCopies: Array<{ relTo: string }>, name: string): boolean {
+  return patch.includes(name) || binaryCopies.some((c) => c.relTo.includes(name));
+}
+
+describe("pipeline ios bundled SDK", () => {
+  it("resolves bundled TopSDK iOS V1.6 package", () => {
+    const sdkRoot = resolveIosSdkRoot(pkgRoot);
+    expect(fs.existsSync(path.join(sdkRoot, "sdk", "topsdkConfig.t.json"))).toBe(true);
+    expect(fs.existsSync(path.join(sdkRoot, "plugins", "GuestSignin", "config.t.json"))).toBe(true);
+  });
+});
+
+describe.skipIf(!hasIosProjectFixture)("pipeline ios fixture", () => {
+  it("detects tooltest xcodeproj with AppDelegate target", () => {
+    const d = detectIOS(iosRoot);
+    expect(d.ok).toBe(true);
+    if (d.ok) {
+      expect(d.targetName).toBe("tooltest");
+      expect(fs.existsSync(path.join(iosRoot, "tooltest", "AppDelegate.m"))).toBe(true);
+    }
+  });
+
+  it("detects when project root is the xcodeproj directory itself", () => {
+    const xcodeprojRoot = path.join(iosRoot, "tooltest.xcodeproj");
+    const d = detectIOS(xcodeprojRoot);
+    expect(d.ok).toBe(true);
+    if (d.ok) {
+      expect(d.xcodeprojPath).toBe(xcodeprojRoot);
+      expect(d.targetName).toBe("tooltest");
+    }
+  });
+
+  it("builds workspace context when project root is the xcodeproj directory", () => {
+    const ctx = buildWorkspaceContext(path.join(iosRoot, "tooltest.xcodeproj"), pkgRoot);
+    expect(ctx.ios?.ok).toBe(true);
+    expect(ctx.ios?.ok && ctx.ios.xcodeprojPath).toBe(path.join(iosRoot, "tooltest.xcodeproj"));
+  });
+
+  it("dry-run: plans TOPCore + GuestSignin frameworks and pbxproj edits", async () => {
+    const tmp = copyProjectToTemp();
+    try {
+      const ctx = buildWorkspaceContext(tmp, pkgRoot);
+      expect(ctx.ios?.ok).toBe(true);
+      const { report, patch, binaryCopies } = await runPipeline(ctx, manifest(), { dryRun: true });
+      expect(report.errors).toEqual([]);
+      expect(plannedIosAsset(patch, binaryCopies, "TOPCore.framework")).toBe(true);
+      expect(plannedIosAsset(patch, binaryCopies, "TOPGuestSigninPlugin.framework")).toBe(true);
+      expect(binaryCopies.some((c) => c.relTo.includes("topSDK/TOPCore.framework"))).toBe(true);
+      expect(binaryCopies.some((c) => c.relTo.includes("topSDK/TOPGuestSigninPlugin.framework"))).toBe(true);
+
+    } finally {
+      fs.rmSync(tmp, { recursive: true, force: true });
+    }
+  });
+
+  it("apply: copies SDK, updates pbxproj, injects AppDelegate", async () => {
+    const tmp = copyProjectToTemp();
+    try {
+      const ctx = buildWorkspaceContext(tmp, pkgRoot);
+      const { report } = await runPipeline(ctx, manifest(), { dryRun: false });
+      expect(report.errors).toEqual([]);
+
+      expect(fs.existsSync(path.join(tmp, "topSDK", "TOPCore.framework"))).toBe(true);
+      expect(fs.existsSync(path.join(tmp, "topSDK", "TOPSDK.framework"))).toBe(true);
+      expect(fs.existsSync(path.join(tmp, "topSDK", "TOPGuestSigninPlugin.framework"))).toBe(true);
+      expect(fs.existsSync(path.join(tmp, "topSDK", "TopSDKSource.bundle"))).toBe(true);
+
+      const pbx = fs.readFileSync(path.join(tmp, "tooltest.xcodeproj", "project.pbxproj"), "utf8");
+      expect(pbx).toContain("TOPCore.framework");
+      expect(pbx).toContain("TOPGuestSigninPlugin.framework");
+      expect(pbx).toContain("-ObjC");
+      expect(pbxBuildFileRefErrors(pbx)).toEqual([]);
+
+      const delegate = fs.readFileSync(path.join(tmp, "tooltest", "AppDelegate.m"), "utf8");
+      expect(delegate).toContain("#import <TOPSDK/TopSDK.h>");
+      expect(delegate).toContain("TopSDK.sharedInstance");
+      expect(delegate).toContain("TOPDataSDK");
+
+      const plist = fs.readFileSync(path.join(tmp, "tooltest", "Info.plist"), "utf8");
+      expect(plist).toContain("<key>TOPSDK</key>");
+      expect(plist).toContain("<key>APP_ID</key>");
+      expect(plist).toContain("mock-ios-tooltest-app-id");
+      expect(plist).toContain("GuestSignin");
+    } finally {
+      fs.rmSync(tmp, { recursive: true, force: true });
+    }
+  });
+
+  it("apply: enables Apple Sign In entitlement when AppleSignin plugin is enabled", async () => {
+    const tmp = copyProjectToTemp();
+    try {
+      const configPath = path.join(tmp, "meetsdk-remote-config.json");
+      const remote = JSON.parse(fs.readFileSync(configPath, "utf8")) as Record<string, unknown>;
+      remote.sdkModules = {
+        login: { apple: {} },
+        payment: {},
+        analytics: {},
+      };
+      fs.writeFileSync(configPath, JSON.stringify(remote, null, 2), "utf8");
+
+      const ctx = buildWorkspaceContext(tmp, pkgRoot);
+      const { report } = await runPipeline(ctx, manifest(), { dryRun: false });
+      expect(report.errors).toEqual([]);
+
+      const entitlementsPath = path.join(tmp, "tooltest", "tooltest.entitlements");
+      expect(fs.existsSync(entitlementsPath)).toBe(true);
+      const entitlements = fs.readFileSync(entitlementsPath, "utf8");
+      expect(entitlements).toContain("com.apple.developer.applesignin");
+      expect(entitlements).toContain("Default");
+
+      const pbx = fs.readFileSync(path.join(tmp, "tooltest.xcodeproj", "project.pbxproj"), "utf8");
+      expect(pbx).toContain("CODE_SIGN_ENTITLEMENTS");
+      expect(pbx).toContain("tooltest/tooltest.entitlements");
+      expect(pbx).toContain("TOPAppleSigninPlugin.framework");
+    } finally {
+      fs.rmSync(tmp, { recursive: true, force: true });
+    }
+  });
+
+  it("dry-run: maps supported iOS plugin params from meetsdk remote config", async () => {
+    const tmp = copyProjectToTemp();
+    try {
+      const configPath = path.join(tmp, "meetsdk-remote-config.json");
+      const remote = JSON.parse(fs.readFileSync(configPath, "utf8")) as Record<string, unknown>;
+      remote.sdkModules = {
+        login: {
+          guest: {},
+          email: {},
+          apple: {},
+          facebook: {
+            clientId: "fb-app",
+            scheme: "fb-scheme",
+            secret: "fb-token",
+            name: "Facebook Display",
+          },
+          google: {
+            clientId: "google-client",
+            scheme: "google-reversed",
+          },
+          snapchat: {
+            clientId: "snap-client",
+            redirect: "snap-redirect",
+            scheme: "snap-scheme",
+          },
+          line: {
+            clientId: "line-client",
+            scheme: "line-scheme",
+          },
+          naver: {
+            clientId: "naver-client",
+            secret: "naver-secret",
+            name: "Naver Name",
+            scheme: "naver-scheme",
+          },
+          kakao: {
+            clientId: "kakao-client",
+            scheme: "kakao-scheme",
+          },
+          tiktok: {
+            clientId: "tiktok-client",
+            secret: "tiktok-secret",
+            redirect: "tiktok-scheme://callback",
+          },
+          discord: {
+            clientId: "discord-client",
+            secret: "discord-secret",
+            redirect: "https://example.invalid/oauth-redirect.html",
+          },
+        },
+        payment: {
+          googleIap: {},
+        },
+        analytics: {
+          appsflyer: {
+            devKey: "af-dev-key",
+            appleAppId: "123456789",
+            enableDebugLog: true,
+          },
+          adjust: {
+            appCode: "adjust-token",
+            enableSandbox: true,
+          },
+          facebookdata: {
+            clientId: "fb-app",
+            scheme: "fb-scheme",
+            secret: "fb-token",
+            name: "Facebook Display",
+          },
+        },
+      };
+      fs.writeFileSync(configPath, JSON.stringify(remote, null, 2), "utf8");
+
+      const ctx = buildWorkspaceContext(tmp, pkgRoot);
+      const { report, patch, binaryCopies } = await runPipeline(ctx, manifest(), { dryRun: true });
+      expect(report.errors).toEqual([]);
+      expect(report.warnings.join("\n")).not.toContain("Discord");
+      expect(plannedIosAsset(patch, binaryCopies, "TOPGoogleSigninPlugin.framework")).toBe(true);
+      expect(plannedIosAsset(patch, binaryCopies, "TOPFacebookSigninPlugin.framework")).toBe(true);
+      expect(plannedIosAsset(patch, binaryCopies, "TOPSnapchatSigninPlugin.framework")).toBe(true);
+      expect(plannedIosAsset(patch, binaryCopies, "TOPLineSigninPlugin.framework")).toBe(true);
+      expect(plannedIosAsset(patch, binaryCopies, "TOPNaverSigninPlugin.framework")).toBe(true);
+      expect(plannedIosAsset(patch, binaryCopies, "TOPKakaoSigninPlugin.framework")).toBe(true);
+      expect(plannedIosAsset(patch, binaryCopies, "TOPTiktokSigninPlugin.framework")).toBe(true);
+      expect(plannedIosAsset(patch, binaryCopies, "TOPDiscordSigninPlugin.framework")).toBe(true);
+      expect(plannedIosAsset(patch, binaryCopies, "TOPIAPPayPlugin.framework")).toBe(true);
+      expect(plannedIosAsset(patch, binaryCopies, "TOPDataAppsFlyerPlugin.framework")).toBe(true);
+      expect(plannedIosAsset(patch, binaryCopies, "TOPDataAdjustPlugin.framework")).toBe(true);
+      expect(plannedIosAsset(patch, binaryCopies, "TOPDataFacebookPlugin.framework")).toBe(true);
+      expect(patch).toContain("FacebookDisplayName");
+      expect(patch).toContain("Facebook Display");
+      expect(patch).toContain("REVERSED_CLIENT_ID");
+      expect(patch).toContain("google-reversed");
+      expect(patch).toContain("APPLE_APP_ID");
+      expect(patch).toContain("123456789");
+      expect(patch).toContain("APP_TOKEN");
+      expect(patch).toContain("adjust-token");
+      expect(patch).toContain("SCSDKRedirectUrl");
+      expect(patch).toContain("snap-redirect");
+      expect(binaryCopies.some((c) => c.relTo.includes("topSDK/TOPDataFacebookPlugin.framework"))).toBe(true);
+    } finally {
+      fs.rmSync(tmp, { recursive: true, force: true });
+    }
+  });
+
+  it("dry-run: uses remote GoogleService-Info.plist for iOS Firebase instead of bundled source", async () => {
+    const tmp = copyProjectToTemp();
+    try {
+      const configPath = path.join(tmp, "meetsdk-remote-config.json");
+      const remote = JSON.parse(fs.readFileSync(configPath, "utf8")) as Record<string, unknown>;
+      remote.sdkModules = {
+        login: {},
+        payment: {},
+        analytics: {
+          firebase: {
+            firebaseUrl: "https://cdn.example.invalid/GoogleService-Info.plist",
+            firebaseName: "GoogleService-Info.plist",
+          },
+        },
+      };
+      fs.writeFileSync(configPath, JSON.stringify(remote, null, 2), "utf8");
+
+      const ctx = buildWorkspaceContext(tmp, pkgRoot);
+      const { report, patch } = await runPipeline(ctx, manifest(), { dryRun: true });
+
+      expect(report.errors).toEqual([]);
+      expect(report.warnings.join("\n")).toContain("would download GoogleService-Info.plist to tooltest/GoogleService-Info.plist");
+      expect(patch).toContain("TOPDataFirebasePlugin.framework");
+      expect(patch).toContain("GoogleService-Info.plist");
+    } finally {
+      fs.rmSync(tmp, { recursive: true, force: true });
+    }
+  });
+
+  it("apply: keeps launch initialization in AppDelegate and routes URL/lifecycle callbacks to SceneDelegate when present", async () => {
+    const tmp = copyProjectToTemp();
+    try {
+      fs.writeFileSync(
+        path.join(tmp, "tooltest", "AppDelegate.m"),
+        `#import "AppDelegate.h"
+
+@implementation AppDelegate
+
+- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
+    return YES;
+}
+
+@end
+`,
+        "utf8"
+      );
+      fs.writeFileSync(
+        path.join(tmp, "tooltest", "SceneDelegate.m"),
+        `#import "SceneDelegate.h"
+
+@implementation SceneDelegate
+
+@end
+`,
+        "utf8"
+      );
+
+      const ctx = buildWorkspaceContext(tmp, pkgRoot);
+      const { report } = await runPipeline(ctx, manifest(), { dryRun: false });
+      expect(report.errors).toEqual([]);
+
+      const appDelegate = fs.readFileSync(path.join(tmp, "tooltest", "AppDelegate.m"), "utf8");
+      expect(appDelegate).toContain("[TopSDK.sharedInstance application:application didFinishLaunchingWithOptions:launchOptions]");
+      expect(appDelegate).toContain("[TOPDataSDK application:application didFinishLaunchingWithOptions:launchOptions]");
+      expect(appDelegate).not.toContain("openURL:url options");
+      expect(appDelegate).not.toContain("continueUserActivity:userActivity restorationHandler");
+      expect(appDelegate).not.toContain("applicationDidEnterBackground");
+      expect(appDelegate).not.toContain("applicationWillEnterForeground");
+
+      const sceneDelegate = fs.readFileSync(path.join(tmp, "tooltest", "SceneDelegate.m"), "utf8");
+      expect(sceneDelegate).toContain("[TopSDK.sharedInstance scene:scene openURLContexts:URLContexts]");
+      expect(sceneDelegate).toContain("[TopSDK.sharedInstance scene:scene continueUserActivity:userActivity]");
+      expect(sceneDelegate).toContain("[TopSDK.sharedInstance sceneWillEnterForeground:scene]");
+      expect(sceneDelegate).toContain("[TopSDK.sharedInstance sceneDidEnterBackground:scene]");
+    } finally {
+      fs.rmSync(tmp, { recursive: true, force: true });
+    }
+  });
+
+  it("fails when the configured Info.plist file is missing", async () => {
+    const tmp = copyProjectToTemp();
+    try {
+      fs.rmSync(path.join(tmp, "tooltest", "Info.plist"));
+
+      const ctx = buildWorkspaceContext(tmp, pkgRoot);
+      const { report } = await runPipeline(ctx, manifest(), { dryRun: true });
+
+      expect(report.errors.join("\n")).toContain("Info.plist not found for iOS target tooltest");
+    } finally {
+      fs.rmSync(tmp, { recursive: true, force: true });
+    }
+  });
+
+  it("fails clearly when enabled iOS plugin is missing required remote params", async () => {
+    const tmp = copyProjectToTemp();
+    try {
+      const configPath = path.join(tmp, "meetsdk-remote-config.json");
+      const remote = JSON.parse(fs.readFileSync(configPath, "utf8")) as Record<string, unknown>;
+      remote.sdkModules = {
+        login: { google: {} },
+        payment: {},
+        analytics: {},
+      };
+      fs.writeFileSync(configPath, JSON.stringify(remote, null, 2), "utf8");
+
+      const ctx = buildWorkspaceContext(tmp, pkgRoot);
+      const { report } = await runPipeline(ctx, manifest(), { dryRun: false });
+      expect(report.errors.join("\n")).toContain("iOS remote config missing required channel params");
+      expect(report.errors.join("\n")).toContain("GoogleSignin: GOOGLE.scheme");
+      expect(report.errors.join("\n")).toContain("GoogleSignin: GOOGLE.clientId");
+      expect(report.results[0]?.changedFiles).toEqual([]);
+    } finally {
+      fs.rmSync(tmp, { recursive: true, force: true });
+    }
+  });
+});

package/tests/pipeline.preview.patch.test.ts

@@ -0,0 +1,85 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { loadAndroidIntegrationFile } from "../src/config/loadAndroidIntegration.js";
+import { loadManifestFile } from "../src/config/loadManifest.js";
+import type { AndroidIntegrationDocument, Manifest } from "../src/contracts/types.js";
+import { clearPreviewPatchFilesIfTargetInside } from "../src/core/previewPatches.js";
+import { buildWorkspaceContext } from "../src/core/workspace.js";
+import { runPipeline } from "../src/core/pipeline.js";
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const pkgRoot = path.resolve(here, "..");
+const fixtureRoot = path.join(pkgRoot, "fixtures", "android-test-project", "android-latest-project");
+const recipeFixtureRoot = path.join(pkgRoot, "fixtures", "recipes");
+const previewPatchPath = path.join(pkgRoot, "test-projects", "_preview", "pipeline.patch");
+
+function stubSdkHomeVersion(): void {
+  vi.stubGlobal(
+    "fetch",
+    vi.fn(async () => ({
+      ok: true,
+      status: 200,
+      text: async () =>
+        JSON.stringify({
+          code: 200,
+          data: {
+            result: {
+              android: { ver: "1.6.1.3", date: "2026-05-25" },
+              ios: { ver: "1.6.0.5", date: "2026-06-09" },
+            },
+          },
+        }),
+    })) as unknown as typeof fetch
+  );
+}
+
+function toManifest(doc: AndroidIntegrationDocument): Manifest {
+  const { meta: _m, remote: _r, ...rest } = doc;
+  void _m;
+  void _r;
+  return rest;
+}
+
+/**
+ * Single on-disk preview for humans / CI artifacts: both fixture manifests (dry-run only).
+ */
+describe("pipeline preview patch", () => {
+  beforeEach(() => {
+    stubSdkHomeVersion();
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it("writes test-projects/_preview/pipeline.patch (yaml + integration-json)", async () => {
+    const ctx = buildWorkspaceContext(fixtureRoot, pkgRoot);
+    expect(ctx.android?.ok).toBe(true);
+
+    const yamlManifest = loadManifestFile(path.join(recipeFixtureRoot, "android-default.fixture.yaml"));
+    const rYaml = await runPipeline(ctx, yamlManifest, { dryRun: true });
+    expect(rYaml.report.errors).toEqual([]);
+
+    const doc = loadAndroidIntegrationFile(path.join(recipeFixtureRoot, "android-integration.fixture.json"));
+    const rJson = await runPipeline(ctx, toManifest(doc), { dryRun: true });
+    expect(rJson.report.errors).toEqual([]);
+
+    const body = [
+      "# dry-run — fixtures/recipes/android-default.fixture.yaml",
+      rYaml.patch.trimEnd(),
+      "",
+      "# dry-run — android-integration.fixture.json",
+      rJson.patch.trimEnd(),
+      "",
+    ].join("\n");
+
+    clearPreviewPatchFilesIfTargetInside(pkgRoot, previewPatchPath);
+    fs.mkdirSync(path.dirname(previewPatchPath), { recursive: true });
+    fs.writeFileSync(previewPatchPath, body, "utf8");
+
+    expect(rYaml.patch).toContain("TOPSDK REPO AUTO");
+    expect(rJson.patch).toContain("TOPSDK AUTO");
+  });
+});

package/tests/platformSelection.test.ts

@@ -0,0 +1,77 @@
+import fs from "node:fs";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import {
+  manifestForPlatform,
+  detectSinglePlatform,
+  platformContext,
+} from "../src/core/platform.js";
+import { buildWorkspaceContext } from "../src/core/workspace.js";
+import type { Manifest } from "../src/contracts/types.js";
+
+const pkgRoot = path.resolve(__dirname, "..");
+const androidLatestRoot = path.join(pkgRoot, "fixtures", "android-test-project", "android-latest-project");
+const iosProjectRoot = path.join(pkgRoot, "fixtures", "ios-test-project", "tooltest");
+const hasIosProjectFixture = fs.existsSync(iosProjectRoot);
+
+describe("platform selection", () => {
+  it("detects Android project roots as Android only", () => {
+    const ctx = buildWorkspaceContext(androidLatestRoot, pkgRoot);
+    const detected = detectSinglePlatform(ctx);
+
+    expect(detected).toEqual({ ok: true, platform: "android" });
+    expect(platformContext(ctx, "android").android?.ok).toBe(true);
+    expect(platformContext(ctx, "android").ios).toBeUndefined();
+  });
+
+  it.skipIf(!hasIosProjectFixture)("detects iOS project roots as iOS only", () => {
+    const ctx = buildWorkspaceContext(iosProjectRoot, pkgRoot);
+    const detected = detectSinglePlatform(ctx);
+
+    expect(detected).toEqual({ ok: true, platform: "ios" });
+    expect(platformContext(ctx, "ios").ios?.ok).toBe(true);
+    expect(platformContext(ctx, "ios").android).toBeUndefined();
+  });
+
+  it("filters mixed manifests to the selected platform before running", () => {
+    const manifest: Manifest = {
+      version: 1,
+      steps: [
+        { op: "android.one", platform: "android" },
+        { op: "ios.one", platform: "ios" },
+        { op: "shared.one", platform: "all" },
+        { op: "shared.two" },
+      ],
+    };
+
+    expect(manifestForPlatform(manifest, "android").steps.map((s) => s.op)).toEqual([
+      "android.one",
+      "shared.one",
+      "shared.two",
+    ]);
+    expect(manifestForPlatform(manifest, "ios").steps.map((s) => s.op)).toEqual([
+      "ios.one",
+      "shared.one",
+      "shared.two",
+    ]);
+  });
+
+  it.skipIf(!hasIosProjectFixture)("overrides detected iOS target name when explicitly provided", () => {
+    const ctx = buildWorkspaceContext(iosProjectRoot, pkgRoot, {
+      appTarget: "tooltest",
+    });
+
+    expect(ctx.ios?.ok && ctx.ios.targetName).toBe("tooltest");
+    expect(ctx.ios?.ok && ctx.ios.targetNames).toContain("tooltest");
+  });
+
+  it.skipIf(!hasIosProjectFixture)("rejects missing iOS app target names during detection", () => {
+    const ctx = buildWorkspaceContext(iosProjectRoot, pkgRoot, {
+      appTarget: "GameRelease",
+    });
+
+    expect(ctx.ios?.ok).toBe(false);
+    expect(ctx.ios?.ok ? "" : ctx.ios?.error).toContain("IOS_APP_TARGET_NOT_FOUND: GameRelease");
+  });
+
+});

package/tests/sdkHomeDownload.test.ts

@@ -0,0 +1,124 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import {
+  DEFAULT_IOS_SDK_PLUGINS,
+  buildSdkHomeDownloadUrl,
+  buildSdkHomeVersionUrl,
+  fetchSdkHomeIosDownloadUrl,
+  fetchSdkHomeIosVersion,
+  fetchSdkHomeVersions,
+  resolveIosSdkRootFromDirectory,
+  resolveIosSdkZipFileName,
+} from "../src/remote/sdkHomeDownload.js";
+
+describe("sdk-home iOS SDK download client", () => {
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it("builds version and getDownLoadUrl URLs", () => {
+    expect(buildSdkHomeVersionUrl("https://business-api.meetgames.com")).toBe(
+      "https://business-api.meetgames.com/sdk/home/version"
+    );
+    const url = buildSdkHomeDownloadUrl({
+      baseUrl: "https://business-api.meetgames.com/",
+      version: "1.6.0.5",
+      plugins: DEFAULT_IOS_SDK_PLUGINS,
+      packageType: "native",
+    });
+    const u = new URL(url);
+    expect(u.pathname).toBe("/sdk/home/sdk-download/getDownLoadUrl");
+    expect(u.searchParams.get("version")).toBe("1.6.0.5");
+    expect(u.searchParams.get("platform")).toBe("ios");
+    expect(u.searchParams.get("plugins")).toBe(DEFAULT_IOS_SDK_PLUGINS.join(","));
+    expect(u.searchParams.get("packageType")).toBe("native");
+  });
+
+  it("parses the iOS version envelope", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(async () => ({
+        ok: true,
+        status: 200,
+        text: async () =>
+          JSON.stringify({
+            code: 200,
+            data: {
+              result: {
+                android: { ver: "1.6.1.3", date: "2026-05-25" },
+                ios: { ver: "1.6.0.5", date: "2026-06-09" },
+              },
+            },
+          }),
+      })) as unknown as typeof fetch
+    );
+
+    const { ios } = await fetchSdkHomeIosVersion({ baseUrl: "https://example.com" });
+    expect(ios).toEqual({ ver: "1.6.0.5", date: "2026-06-09" });
+  });
+
+  it("parses Android and iOS versions from the version envelope", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(async () => ({
+        ok: true,
+        status: 200,
+        text: async () =>
+          JSON.stringify({
+            code: 200,
+            data: {
+              result: {
+                android: { ver: "1.6.1.3", date: "2026-05-25" },
+                ios: { ver: "1.6.0.5", date: "2026-06-09" },
+              },
+            },
+          }),
+      })) as unknown as typeof fetch
+    );
+
+    const { versions } = await fetchSdkHomeVersions({ baseUrl: "https://example.com" });
+    expect(versions.android).toEqual({ ver: "1.6.1.3", date: "2026-05-25" });
+    expect(versions.ios).toEqual({ ver: "1.6.0.5", date: "2026-06-09" });
+  });
+
+  it("parses the download URL envelope", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(async () => ({
+        ok: true,
+        status: 200,
+        text: async () => JSON.stringify({ code: 200, data: "https://cdn.example.com/topSDK-ios.zip" }),
+      })) as unknown as typeof fetch
+    );
+
+    const { sdkZipUrl } = await fetchSdkHomeIosDownloadUrl({
+      baseUrl: "https://example.com",
+      version: "1.6.0.5",
+    });
+    expect(sdkZipUrl).toBe("https://cdn.example.com/topSDK-ios.zip");
+  });
+
+  it("uses the sdk-home generated iOS archive name", () => {
+    expect(resolveIosSdkZipFileName("1.6.0.5")).toBe("topSDK-ios--V1.6.0.5.zip");
+  });
+
+  it("resolves top-level and nested extracted SDK layouts", () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "meet-sdk-tool-ios-"));
+    try {
+      fs.mkdirSync(path.join(root, "sdk"), { recursive: true });
+      fs.mkdirSync(path.join(root, "plugins"), { recursive: true });
+      expect(resolveIosSdkRootFromDirectory(root)).toBe(root);
+
+      const nestedRoot = path.join(root, "nested");
+      fs.rmSync(path.join(root, "sdk"), { recursive: true, force: true });
+      fs.rmSync(path.join(root, "plugins"), { recursive: true, force: true });
+      fs.mkdirSync(path.join(nestedRoot, "sdk"), { recursive: true });
+      fs.mkdirSync(path.join(nestedRoot, "plugins"), { recursive: true });
+      expect(resolveIosSdkRootFromDirectory(root)).toBe(nestedRoot);
+    } finally {
+      fs.rmSync(root, { recursive: true, force: true });
+    }
+  });
+});