@leonxin/meetgames 0.1.11 → 0.1.12

package/src/ios/integrate.ts

@@ -333,9 +333,9 @@ export async function runIosIntegrateTopSdk(
   const warnings: string[] = [];
   const changed = new Set<string>();
 
-  const configPath = path.join(ctx.projectRoot, MEETSDK_REMOTE_CONFIG_FILENAME);
+  const configPath = ctx.remoteConfigPath ?? 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`]);
+    return fail([`${MEETSDK_REMOTE_CONFIG_FILENAME} not found at ${configPath}; run fetch-config or setup first`]);
   }
   let remote: ReturnType<typeof tryParseAsMeetSdkRemoteConfig>;
   try {
@@ -353,7 +353,7 @@ export async function runIosIntegrateTopSdk(
 
   let sdkRoot: string;
   try {
-    sdkRoot = resolveIosSdkRoot(ctx.packageRoot);
+    sdkRoot = ctx.iosSdkRoot ?? resolveIosSdkRoot(ctx.packageRoot);
   } catch (e) {
     return fail([e instanceof Error ? e.message : String(e)]);
   }
@@ -375,6 +375,7 @@ export async function runIosIntegrateTopSdk(
     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);

package/src/ios/pbxprojEditor.ts

@@ -69,9 +69,70 @@ export async function loadPbxFromStore(
 }
 
 export function savePbxToStore(store: TextFileStore, ctx: PbxContext): void {
+  stripUndefinedValues(ctx.proj.hash?.project?.objects);
+  sanitizePbxBuildSettings(ctx.proj);
   store.write(ctx.rel, ctx.proj.writeSync());
 }
 
+function stripUndefinedValues(value: unknown): void {
+  if (Array.isArray(value)) {
+    for (const item of value) stripUndefinedValues(item);
+    return;
+  }
+  if (!value || typeof value !== "object") return;
+
+  const record = value as Record<string, unknown>;
+  for (const [key, nested] of Object.entries(record)) {
+    if (nested === undefined || nested === "undefined") {
+      delete record[key];
+      continue;
+    }
+    stripUndefinedValues(nested);
+  }
+}
+
+function sanitizePbxBuildSettings(proj: XcodeProject): void {
+  const buildConfigs = proj.pbxXCBuildConfigurationSection?.() ?? {};
+  for (const [uuid, cfg] of Object.entries(buildConfigs)) {
+    if (uuid.endsWith("_comment") || !cfg || typeof cfg !== "object") continue;
+    const settings = (cfg as { buildSettings?: Record<string, unknown> }).buildSettings;
+    if (!settings) continue;
+    for (const [key, raw] of Object.entries(settings)) {
+      if (typeof raw === "string") {
+        settings[key] = quotePbxStringIfNeeded(raw);
+        continue;
+      }
+      if (Array.isArray(raw)) {
+        settings[key] = raw.map((value) => (typeof value === "string" ? quotePbxStringIfNeeded(value) : value));
+      }
+    }
+  }
+}
+
+function isPbxQuotedString(value: string): boolean {
+  return value.length >= 2 && value.startsWith('"') && value.endsWith('"');
+}
+
+function unquotePbxString(value: string): string {
+  if (!isPbxQuotedString(value)) return value;
+  return value.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+}
+
+function quotePbxStringIfNeeded(value: string): string {
+  if (isPbxQuotedString(value)) return value;
+  if (!pbxStringNeedsQuotes(value)) return value;
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+
+function pbxStringNeedsQuotes(value: string): boolean {
+  if (value.length === 0 || value.startsWith("-")) return true;
+  return /[^A-Za-z0-9_.$/{}()+-]/.test(value);
+}
+
+function samePbxStringValue(a: unknown, b: string): boolean {
+  return typeof a === "string" && unquotePbxString(a) === unquotePbxString(b);
+}
+
 function targetUuid(proj: XcodeProject, targetName: string): string | undefined {
   const targets = proj.pbxNativeTargetSection?.() ?? {};
   for (const [uuid, t] of Object.entries(targets)) {
@@ -317,12 +378,18 @@ export function addOtherLinkerFlag(ctx: PbxContext, flag: string): void {
     if (!cfg || typeof cfg !== "object") continue;
     const settings = (cfg as { buildSettings?: Record<string, unknown> }).buildSettings ?? {};
     const cur = settings.OTHER_LDFLAGS;
+    const normalizedFlag = unquotePbxString(flag);
+    const nextFlag = quotePbxStringIfNeeded(normalizedFlag);
     if (typeof cur === "string") {
-      if (!cur.includes(flag)) settings.OTHER_LDFLAGS = `${cur} ${flag}`.trim();
+      if (!unquotePbxString(cur).split(/\s+/).includes(normalizedFlag)) {
+        settings.OTHER_LDFLAGS = [quotePbxStringIfNeeded(cur), nextFlag];
+      }
     } else if (Array.isArray(cur)) {
-      if (!cur.includes(flag)) settings.OTHER_LDFLAGS = [...cur, flag];
+      const values = cur.map((value) => (typeof value === "string" ? quotePbxStringIfNeeded(value) : value));
+      if (!values.some((value) => samePbxStringValue(value, normalizedFlag))) values.push(nextFlag);
+      settings.OTHER_LDFLAGS = values;
     } else {
-      settings.OTHER_LDFLAGS = [flag];
+      settings.OTHER_LDFLAGS = [nextFlag];
     }
     (cfg as { buildSettings: Record<string, unknown> }).buildSettings = settings;
   }

package/src/ios/sdkBundle.ts

@@ -1,25 +1,17 @@
 import fs from "node:fs";
 import path from "node:path";
-
-const BUNDLED_IOS_REL = path.join("bundled", "ios-sdk");
-
-export function defaultBundledIosSdkRoot(packageRoot: string): string {
-  return path.join(packageRoot, BUNDLED_IOS_REL);
-}
+import { MEET_SDK_TOOL_CACHE_ROOT } from "../cache.js";
 
 /**
- * TopSDK iOS package root: `bundled/ios-sdk` or a child version dir (e.g. `ios--V1.6.0.4/`).
- * Native iOS only; SDK is vendored in the tool package.
+ * TopSDK iOS package root from cache.
+ * Native iOS only.
  */
-export function resolveIosSdkRoot(packageRoot: string): string {
-  const bundled = defaultBundledIosSdkRoot(packageRoot);
-  if (!fs.existsSync(bundled)) {
-    throw new Error(`iOS SDK not found at ${BUNDLED_IOS_REL} (expected sdk/ and plugins/ inside).`);
-  }
+function findIosSdkRoot(container: string): string | null {
+  if (!fs.existsSync(container)) return null;
   const children = fs
-    .readdirSync(bundled, { withFileTypes: true })
+    .readdirSync(container, { withFileTypes: true })
     .filter((d) => d.isDirectory() && !d.name.startsWith("."))
-    .map((d) => path.join(bundled, d.name))
+    .map((d) => path.join(container, d.name))
     .sort()
     .reverse();
   for (const dir of children) {
@@ -27,10 +19,41 @@ export function resolveIosSdkRoot(packageRoot: string): string {
       return dir;
     }
   }
-  if (fs.existsSync(path.join(bundled, "sdk")) && fs.existsSync(path.join(bundled, "plugins"))) {
-    return bundled;
+  if (fs.existsSync(path.join(container, "sdk")) && fs.existsSync(path.join(container, "plugins"))) {
+    return container;
   }
+  return null;
+}
+
+function findLatestCachedIosSdkRoot(): string | null {
+  const iosCache = path.join(MEET_SDK_TOOL_CACHE_ROOT, "sdk", "ios");
+  if (!fs.existsSync(iosCache)) return null;
+  const candidates: string[] = [];
+  const walk = (dir: string): void => {
+    for (const ent of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (!ent.isDirectory() || ent.name.startsWith(".")) continue;
+      const abs = path.join(dir, ent.name);
+      if (ent.name === "extracted") {
+        candidates.push(abs);
+      } else {
+        walk(abs);
+      }
+    }
+  };
+  walk(iosCache);
+  candidates.sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs);
+  for (const candidate of candidates) {
+    const found = findIosSdkRoot(candidate);
+    if (found) return found;
+  }
+  return null;
+}
+
+export function resolveIosSdkRoot(_packageRoot: string): string {
+  const cached = findLatestCachedIosSdkRoot();
+  if (cached) return cached;
+
   throw new Error(
-    `iOS SDK layout invalid under ${BUNDLED_IOS_REL}: need sdk/ + plugins/ at top level or under one version directory.`
+    `iOS SDK not found in ${path.join(MEET_SDK_TOOL_CACHE_ROOT, "sdk", "ios")}; run download-ios-sdk or setup first.`
   );
 }

package/src/mcp/server.ts

@@ -46,7 +46,7 @@ export function createMeetgamesMcpServer(): McpServer {
     "meetgames_fetch_config",
     {
       description:
-        "Download TOPSDK meetsdk-remote-config.json via downloadSDKConfig and write it into project root.",
+        "Download TOPSDK meetsdk-remote-config.json via downloadSDKConfig and write it into ~/.cache/meet-sdk-tool.",
       inputSchema: {
         projectRoot: z.string().optional().describe("Absolute or relative project root; default is current working directory."),
         env: z.enum(["prod", "pre", "test"]).optional().describe("TOPSDK API environment."),
@@ -78,11 +78,14 @@ export function createMeetgamesMcpServer(): McpServer {
       inputSchema: {
         projectRoot: z.string().optional().describe("Absolute or relative project root; default is current working directory."),
         appTarget: z.string().optional().describe("App target to integrate/check: Android application Gradle module or iOS App target name."),
+        env: z.enum(["prod", "pre", "test"]).optional().describe("TOPSDK API environment for selecting cached config."),
+        appId: z.string().optional().describe("Application id for selecting cached config."),
+        channelType: z.string().optional().describe("Channel type for selecting cached config."),
       },
     },
-    async ({ projectRoot, appTarget }) => {
+    async ({ projectRoot, appTarget, env, appId, channelType }) => {
       try {
-        const result = await meetgamesIntegrate({ projectRoot, appTarget, dryRun: true });
+        const result = await meetgamesIntegrate({ projectRoot, appTarget, env, appId, channelType, dryRun: true });
         if (result.hasErrors) {
           return {
             ...toSuccessResult(result),
@@ -103,11 +106,14 @@ export function createMeetgamesMcpServer(): McpServer {
       inputSchema: {
         projectRoot: z.string().optional().describe("Absolute or relative project root; default is current working directory."),
         appTarget: z.string().optional().describe("App target to integrate/check: Android application Gradle module or iOS App target name."),
+        env: z.enum(["prod", "pre", "test"]).optional().describe("TOPSDK API environment for selecting cached config."),
+        appId: z.string().optional().describe("Application id for selecting cached config."),
+        channelType: z.string().optional().describe("Channel type for selecting cached config."),
       },
     },
-    async ({ projectRoot, appTarget }) => {
+    async ({ projectRoot, appTarget, env, appId, channelType }) => {
       try {
-        const result = await meetgamesIntegrate({ projectRoot, appTarget, dryRun: false });
+        const result = await meetgamesIntegrate({ projectRoot, appTarget, env, appId, channelType, dryRun: false });
         if (result.hasErrors) {
           return {
             ...toSuccessResult(result),
@@ -125,7 +131,7 @@ export function createMeetgamesMcpServer(): McpServer {
     "meetgames_setup",
     {
       description:
-        "Download meetsdk-remote-config.json then run default integrate recipe (fetch-config + integrate).",
+        "Download meetsdk-remote-config.json into ~/.cache/meet-sdk-tool, ensure iOS SDK cache when needed, then run the default integrate recipe.",
       inputSchema: {
         projectRoot: z.string().optional().describe("Absolute or relative project root; default is current working directory."),
         env: z.enum(["prod", "pre", "test"]).optional().describe("TOPSDK API environment."),

package/src/mcp/service.ts

@@ -9,7 +9,6 @@ import {
 } from "../config/meetSdkRemoteConfig.js";
 import {
   validateDownloadSdkConfigForWrite,
-  writeDownloadSdkConfigRaw,
 } from "../config/fetchConfigWrite.js";
 import type { PipelineReport } from "../contracts/types.js";
 import type { BinaryCopy } from "../ops/handlers.js";
@@ -22,6 +21,8 @@ import {
 } from "../core/platform.js";
 import { buildWorkspaceContext, resolvePackageRoot } from "../core/workspace.js";
 import { defaultTopSdkBaseUrl, fetchTopSdkDownloadSdkConfig, type TopSdkApiEnv } from "../remote/topsdkDownloadSdkConfig.js";
+import { downloadIosSdkToBundled, defaultSdkHomeApiBaseUrl } from "../remote/sdkHomeDownload.js";
+import { resolveRemoteConfigCachePath, writeRemoteConfigCache } from "../cache.js";
 
 const DEFAULT_MANIFEST_REL = "recipes/integrate-default.yaml";
 
@@ -43,6 +44,17 @@ function readLocalMeetSdkRemoteConfig(projectRoot: string): MeetSdkRemoteConfig
   }
 }
 
+function resolveCachedRemoteConfigPath(params: {
+  env?: TopSdkApiEnv;
+  appId?: string;
+  channelType?: string;
+}): string | undefined {
+  const appId = params.appId || process.env.TOPSDK_APP_ID || "";
+  const channelType = params.channelType || process.env.TOPSDK_CHANNEL_TYPE || "";
+  if (!appId || !channelType) return undefined;
+  return resolveRemoteConfigCachePath({ env: params.env ?? "prod", appId, channelType });
+}
+
 function ensureDefaultManifestPath(packageRoot: string): string {
   const manifestPath = path.join(packageRoot, DEFAULT_MANIFEST_REL);
   if (!fs.existsSync(manifestPath)) {
@@ -54,12 +66,13 @@ function ensureDefaultManifestPath(packageRoot: string): string {
 function ensureSinglePlatformContext(
   projectRoot: string,
   packageRoot: string,
-  appTarget?: string
+  appTarget?: string,
+  remoteConfigPath?: string
 ): {
   platform: DetectedPlatform;
   ctx: ReturnType<typeof buildWorkspaceContext>;
 } {
-  const detectedCtx = buildWorkspaceContext(projectRoot, packageRoot, { appTarget });
+  const detectedCtx = buildWorkspaceContext(projectRoot, packageRoot, { appTarget, remoteConfigPath });
   const detected = detectSinglePlatform(detectedCtx);
   if (!detected.ok) throw new Error(detected.error);
   const platformCtx = platformContext(detectedCtx, detected.platform);
@@ -121,7 +134,6 @@ export async function meetgamesFetchConfig(params: {
   warnings: string[];
 }> {
   const projectRoot = ensureProjectRoot(params.projectRoot);
-  const out = path.join(projectRoot, MEETSDK_REMOTE_CONFIG_FILENAME);
   const localConfig = readLocalMeetSdkRemoteConfig(projectRoot);
 
   const appId = params.appId || localConfig?.topsdk.appId || process.env.TOPSDK_APP_ID || "";
@@ -153,13 +165,23 @@ export async function meetgamesFetchConfig(params: {
   }
   warnings.push(...validation.warnings);
 
-  writeDownloadSdkConfigRaw(out, res.text);
-  return { outputPath: out, requestUrl: res.url, env, warnings };
+  const written = writeRemoteConfigCache({
+    env,
+    appId,
+    channelType,
+    requestUrl: res.url,
+    rawText: res.text,
+    warnings,
+  });
+  return { outputPath: written.configPath, requestUrl: res.url, env, warnings };
 }
 
 export async function meetgamesIntegrate(params: {
   projectRoot?: string;
   appTarget?: string;
+  env?: TopSdkApiEnv;
+  appId?: string;
+  channelType?: string;
   dryRun: boolean;
 }): Promise<{
   dryRun: boolean;
@@ -176,7 +198,8 @@ export async function meetgamesIntegrate(params: {
   const { platform, ctx } = ensureSinglePlatformContext(
     projectRoot,
     packageRoot,
-    resolveAppTarget(params)
+    resolveAppTarget(params),
+    resolveCachedRemoteConfigPath(params)
   );
   const { report, patch, binaryCopies } = await runPipeline(ctx, manifestForPlatform(manifest, platform), { dryRun: params.dryRun });
   return {
@@ -205,7 +228,7 @@ export async function meetgamesSetup(params: {
   const projectRoot = ensureProjectRoot(params.projectRoot);
   const packageRoot = resolvePackageRoot();
   const appTarget = resolveAppTarget(params);
-  ensureSinglePlatformContext(projectRoot, packageRoot, appTarget);
+  const { platform } = ensureSinglePlatformContext(projectRoot, packageRoot, appTarget);
   const fetch = await meetgamesFetchConfig({
     projectRoot,
     env: params.env,
@@ -213,9 +236,17 @@ export async function meetgamesSetup(params: {
     appSecret: params.appSecret,
     channelType: params.channelType,
   });
+  if (platform === "ios") {
+    await downloadIosSdkToBundled(packageRoot, {
+      baseUrl: process.env.MEETGAMES_SDK_HOME_API_BASE_URL?.trim() || defaultSdkHomeApiBaseUrl,
+    });
+  }
   const integrate = await meetgamesIntegrate({
     projectRoot,
     appTarget,
+    env: params.env,
+    appId: params.appId,
+    channelType: params.channelType,
     dryRun: params.dryRun,
   });
   return { fetch, integrate };

package/src/ops/handlers.ts

@@ -59,6 +59,18 @@ function moduleGradleRel(ctx: WorkspaceContext): string | null {
   return null;
 }
 
+function resolveRemoteConfigInput(ctx: WorkspaceContext, configFile: unknown): { abs: string; label: string } {
+  if (typeof configFile === "string" && configFile.trim()) {
+    const normalized = configFile.trim().replace(/\\/g, "/");
+    return {
+      abs: path.isAbsolute(normalized) ? normalized : path.join(ctx.projectRoot, normalized),
+      label: normalized,
+    };
+  }
+  const abs = ctx.remoteConfigPath ?? path.join(ctx.projectRoot, MEETSDK_REMOTE_CONFIG_FILENAME);
+  return { abs, label: abs };
+}
+
 export interface BinaryCopy {
   fromAbs: string;
   relTo: string;
@@ -80,23 +92,19 @@ export const opHandlers: Record<string, OpHandler> = {
    */
   "gradle.applyMeetSdkRemoteConfig": async (ctx, store, args, _dry, _bc) => {
     if (!ctx.android?.ok) return fail(["android application module not detected"]);
-    const configRel =
-      typeof args.configFile === "string" && args.configFile.trim()
-        ? args.configFile.trim().replace(/\\/g, "/")
-        : MEETSDK_REMOTE_CONFIG_FILENAME;
-    const abs = path.join(ctx.projectRoot, configRel);
-    if (!fs.existsSync(abs)) return fail([`meet sdk remote config not found: ${configRel}`]);
+    const config = resolveRemoteConfigInput(ctx, args.configFile);
+    if (!fs.existsSync(config.abs)) return fail([`meet sdk remote config not found: ${config.label}`]);
     let raw: unknown;
     try {
-      raw = JSON.parse(fs.readFileSync(abs, "utf8")) as unknown;
+      raw = JSON.parse(fs.readFileSync(config.abs, "utf8")) as unknown;
     } catch {
-      return fail([`failed to parse JSON: ${configRel}`]);
+      return fail([`failed to parse JSON: ${config.label}`]);
     }
     const parsed = tryParseAsMeetSdkRemoteConfig(raw);
-    if (!parsed) return fail([`not a meetsdk-remote-config document: ${configRel}`]);
+    if (!parsed) return fail([`not a meetsdk-remote-config document: ${config.label}`]);
     const v = validateMeetSdkRemoteConfig(parsed);
     if (!v.ok) {
-      return fail([`meetsdk-remote-config validation failed (${configRel}): ${v.missing.join(", ")}`]);
+      return fail([`meetsdk-remote-config validation failed (${config.label}): ${v.missing.join(", ")}`]);
     }
     const resolved = applyMeetSdkDefaultConfig(
       parsed,
@@ -244,20 +252,16 @@ export const opHandlers: Record<string, OpHandler> = {
 
   "files.downloadGoogleServicesJson": async (ctx, _store, args, dryRun, _bc) => {
     if (!ctx.android?.ok) return fail(["android application module not detected"]);
-    const configRel =
-      typeof args.configFile === "string" && args.configFile.trim()
-        ? args.configFile.trim().replace(/\\/g, "/")
-        : MEETSDK_REMOTE_CONFIG_FILENAME;
-    const abs = path.join(ctx.projectRoot, configRel);
-    if (!fs.existsSync(abs)) return fail([`meet sdk remote config not found: ${configRel}`]);
+    const config = resolveRemoteConfigInput(ctx, args.configFile);
+    if (!fs.existsSync(config.abs)) return fail([`meet sdk remote config not found: ${config.label}`]);
     let raw: unknown;
     try {
-      raw = JSON.parse(fs.readFileSync(abs, "utf8")) as unknown;
+      raw = JSON.parse(fs.readFileSync(config.abs, "utf8")) as unknown;
     } catch {
-      return fail([`failed to parse JSON: ${configRel}`]);
+      return fail([`failed to parse JSON: ${config.label}`]);
     }
     const parsed = tryParseAsMeetSdkRemoteConfig(raw);
-    if (!parsed) return fail([`not a meetsdk-remote-config document: ${configRel}`]);
+    if (!parsed) return fail([`not a meetsdk-remote-config document: ${config.label}`]);
     const resolved = applyMeetSdkDefaultConfig(
       parsed,
       await loadMeetSdkDefaultConfigWithLatestAndroidVersion({

package/src/remote/sdkHomeDownload.ts

@@ -1,8 +1,8 @@
 import { spawn } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
-import { defaultBundledIosSdkRoot } from "../ios/sdkBundle.js";
 import { syncMeetSdkIosVersionToConfig } from "../config/meetSdkIosConfig.js";
+import { resolveIosSdkCacheLayout, withCacheLock, writeIosSdkCacheMetadata } from "../cache.js";
 
 export const defaultSdkHomeApiBaseUrl = "https://business-api.meetgames.com";
 export const DEFAULT_IOS_SDK_PLUGINS = ["guest", "facebook", "google", "apple", "apple_pay", "dataAppsFlyer"] as const;
@@ -36,7 +36,6 @@ export interface DownloadIosSdkOptions {
   version?: string;
   plugins?: readonly string[] | string;
   packageType?: string;
-  outputDir?: string;
   signal?: AbortSignal;
 }
 
@@ -50,6 +49,7 @@ export interface DownloadIosSdkResult {
   extractDir: string;
   resolvedSdkRoot: string;
   iosConfigPath: string;
+  cacheMetadataPath: string;
 }
 
 function isRecord(value: unknown): value is JsonRecord {
@@ -247,11 +247,16 @@ export async function downloadIosSdkToBundled(
     packageType,
     signal: options.signal,
   });
-  const extractDir = path.resolve(options.outputDir || defaultBundledIosSdkRoot(packageRoot));
-  const zipPath = path.join(extractDir, resolveIosSdkZipFileName(version));
+  const cacheLayout = resolveIosSdkCacheLayout({ version, packageType, plugins });
+  const extractDir = cacheLayout.extractDir;
+  const zipPath = cacheLayout.zipPath;
 
-  await downloadBinaryFile(downloadResult.sdkZipUrl, zipPath, options.signal);
-  await extractZip(zipPath, extractDir);
+  const downloadAndExtract = async (): Promise<void> => {
+    await downloadBinaryFile(downloadResult.sdkZipUrl, zipPath, options.signal);
+    fs.rmSync(extractDir, { recursive: true, force: true });
+    await extractZip(zipPath, extractDir);
+  };
+  await withCacheLock(cacheLayout.lockDir, downloadAndExtract);
   const iosConfigPath = syncMeetSdkIosVersionToConfig({
     packageRoot,
     version,
@@ -259,6 +264,21 @@ export async function downloadIosSdkToBundled(
     packageType,
     plugins,
   });
+  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,
+  });
 
   return {
     version,
@@ -268,7 +288,8 @@ export async function downloadIosSdkToBundled(
     sdkZipUrl: downloadResult.sdkZipUrl,
     zipPath,
     extractDir,
-    resolvedSdkRoot: resolveIosSdkRootFromDirectory(extractDir),
+    resolvedSdkRoot,
     iosConfigPath,
+    cacheMetadataPath,
   };
 }

package/tests/doctor.test.ts

@@ -7,12 +7,14 @@ import { runDoctor } from "../src/core/doctor.js";
 import { detectSinglePlatform, platformContext } from "../src/core/platform.js";
 import { runPipeline } from "../src/core/pipeline.js";
 import { buildWorkspaceContext } from "../src/core/workspace.js";
+import { resolveIosSdkRootFromDirectory } from "../src/remote/sdkHomeDownload.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 iosRemoteConfigFixture = path.join(pkgRoot, "fixtures", "meetsdk-remote-config.ios-tooltest.json");
 const hasIosProjectFixture = fs.existsSync(iosProjectRoot);
+const fixtureIosSdkRoot = resolveIosSdkRootFromDirectory(path.join(pkgRoot, "fixtures", "ios-sdk", "topSDK-ios--V1.6.0.5"));
 
 function copyIosProjectToTemp(): string {
   const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "meet-ios-doctor-"));
@@ -67,11 +69,11 @@ describe("doctor", () => {
     const tmp = copyIosProjectToTemp();
     try {
       const manifest = loadManifestFile(path.join(pkgRoot, "recipes", "ios-default.yaml"));
-      const applyCtx = buildWorkspaceContext(tmp, pkgRoot);
+      const applyCtx = buildWorkspaceContext(tmp, pkgRoot, { iosSdkRoot: fixtureIosSdkRoot });
       const { report: applyReport } = await runPipeline(applyCtx, manifest, { dryRun: false });
       expect(applyReport.errors).toEqual([]);
 
-      const ctx = buildWorkspaceContext(tmp, pkgRoot);
+      const ctx = buildWorkspaceContext(tmp, pkgRoot, { iosSdkRoot: fixtureIosSdkRoot });
       const detected = detectSinglePlatform(ctx);
       expect(detected.ok && detected.platform).toBe("ios");
 

package/tests/{test-projects-hosts.test.ts → fixtures-hosts.test.ts}

@@ -9,7 +9,7 @@ const here = path.dirname(fileURLToPath(import.meta.url));
 const pkgRoot = path.resolve(here, "..");
 const androidFixtureRoot = path.join(pkgRoot, "fixtures", "android-test-project");
 
-function testProjectRoot(...names: string[]): string {
+function fixtureProjectRoot(...names: string[]): string {
   for (const name of names) {
     const candidate = path.join(androidFixtureRoot, name);
     if (fs.existsSync(candidate)) return candidate;
@@ -39,7 +39,7 @@ function createAndroidAppModule(root: string, name: string, applicationId: strin
 }
 
 describe("fixture host trees", () => {
-  const powerRaidRoot = testProjectRoot("power-raid");
+  const powerRaidRoot = fixtureProjectRoot("power-raid");
 
   it("android-latest-project (plugins DSL) resolves application module :app", () => {
     const root = path.join(androidFixtureRoot, "android-latest-project");

package/tests/ios.sdkBundle.test.ts

@@ -3,14 +3,19 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { describe, expect, it } from "vitest";
 import { resolveIosSdkRoot } from "../src/ios/sdkBundle.js";
+import { MEET_SDK_TOOL_CACHE_ROOT } from "../src/cache.js";
 
 const pkgRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 
 describe("resolveIosSdkRoot", () => {
-  it("finds nested TopSDK package under bundled/ios-sdk", () => {
-    const root = resolveIosSdkRoot(pkgRoot);
-    expect(root).toContain(`${path.sep}bundled${path.sep}ios-sdk`);
-    expect(fs.existsSync(path.join(root, "sdk", "topsdkConfig.t.json"))).toBe(true);
-    expect(fs.existsSync(path.join(root, "plugins", "GuestSignin", "config.t.json"))).toBe(true);
+  it("uses only the iOS SDK cache", () => {
+    try {
+      const root = resolveIosSdkRoot(pkgRoot);
+      expect(root).toContain(`${path.sep}.cache${path.sep}meet-sdk-tool${path.sep}sdk${path.sep}ios`);
+      expect(fs.existsSync(path.join(root, "sdk", "topsdkConfig.t.json"))).toBe(true);
+      expect(fs.existsSync(path.join(root, "plugins"))).toBe(true);
+    } catch (e) {
+      expect(e instanceof Error ? e.message : String(e)).toContain(path.join(MEET_SDK_TOOL_CACHE_ROOT, "sdk", "ios"));
+    }
   });
 });

package/tests/mcp.e2e.ts

@@ -153,7 +153,6 @@ describe("meetgames MCP stdio server", () => {
     expect(dryRun.dryRun).toBe(true);
     expect(dryRun.hasErrors).toBe(false);
     expect(String(dryRun.patch)).toContain("TOPSDK AUTO");
-    expect(fs.existsSync(path.join(projectRoot, "vendor", "meet-integrate", "sample.txt"))).toBe(false);
   });
 
   it("runs fetch-config and setup dry-run through stdio", async () => {
@@ -175,9 +174,8 @@ describe("meetgames MCP stdio server", () => {
     );
     expect(fetched.env).toBe("test");
     expect(String(fetched.requestUrl)).toContain("/console/openSDK/downloadSDKConfig");
-    expect(fs.readFileSync(path.join(projectRoot, "meetsdk-remote-config.json"), "utf8")).toBe(
-      fs.readFileSync(remoteConfigFixture, "utf8")
-    );
+    expect(fs.existsSync(path.join(projectRoot, "meetsdk-remote-config.json"))).toBe(false);
+    expect(fs.readFileSync(String(fetched.outputPath), "utf8")).toBe(fs.readFileSync(remoteConfigFixture, "utf8"));
 
     const setup = structured(
       await client.callTool({
@@ -211,7 +209,6 @@ describe("meetgames MCP stdio server", () => {
     expect(applied.dryRun).toBe(false);
     expect((applied.report as { errors?: string[] }).errors).toEqual([]);
     expect(applied.hasErrors).toBe(false);
-    expect(fs.existsSync(path.join(projectRoot, "vendor", "meet-integrate", "sample.txt"))).toBe(true);
     expect(fs.readFileSync(path.join(projectRoot, "app", "build.gradle"), "utf8")).toContain("TOPSDK AUTO");
   });
 });

package/tests/meetSdkRemoteConfig.test.ts

@@ -236,6 +236,31 @@ describe("meetSdkRemoteConfig", () => {
     });
   });
 
+  it("parses Adjust eventUrl under analytics.adjust", () => {
+    const parsed = tryParseAsMeetSdkRemoteConfig({
+      packageName: "com.example",
+      channel: "APPLE",
+      devicePlatform: "ios",
+      topsdk: { appId: "1", appSecret: "s" },
+      sdkModules: {
+        login: {},
+        payment: {},
+        analytics: {
+          adjust: {
+            appCode: "adjust-app-code",
+            eventUrl: "https://example.invalid/events.json",
+          },
+        },
+      },
+    });
+
+    expect(parsed?.sdkModules.analytics.adjust).toMatchObject({
+      appId: "adjust-app-code",
+      eventUrl: "https://example.invalid/events.json",
+      enableSandbox: false,
+    });
+  });
+
   it("maps TWITTER / LINE / KAKAO from channelAuthConfig", () => {
     const body = {
       code: 200,