@leonxin/meetgames 0.1.8 → 0.1.11

package/src/core/platform.ts

@@ -0,0 +1,47 @@
+import type { Manifest, WorkspaceContext } from "../contracts/types.js";
+
+export type DetectedPlatform = "android" | "ios";
+
+export function detectSinglePlatform(ctx: WorkspaceContext): {
+  ok: true;
+  platform: DetectedPlatform;
+} | {
+  ok: false;
+  error: string;
+} {
+  const androidOk = ctx.android?.ok === true;
+  const iosOk = ctx.ios?.ok === true;
+  if (androidOk && !iosOk) return { ok: true, platform: "android" };
+  if (iosOk && !androidOk) return { ok: true, platform: "ios" };
+  if (androidOk && iosOk) {
+    return {
+      ok: false,
+      error: "project root matches both Android and iOS projects; pass a narrower --project-root so exactly one platform is detected",
+    };
+  }
+  const androidError = ctx.android && !ctx.android.ok ? ctx.android.error : "not detected";
+  const iosError = ctx.ios && !ctx.ios.ok ? ctx.ios.error : "not detected";
+  const androidLooksLikeProject = Boolean(ctx.android && !ctx.android.ok && !androidError.includes("settings.gradle"));
+  const iosLooksLikeProject = Boolean(ctx.ios && !ctx.ios.ok && !iosError.includes("no .xcodeproj"));
+  if (androidLooksLikeProject && !iosLooksLikeProject) return { ok: false, error: androidError };
+  if (iosLooksLikeProject && !androidLooksLikeProject) return { ok: false, error: iosError };
+  return {
+    ok: false,
+    error: `project root is neither a supported Android nor iOS project (android: ${androidError}; ios: ${iosError})`,
+  };
+}
+
+export function platformContext(ctx: WorkspaceContext, platform: DetectedPlatform): WorkspaceContext {
+  if (platform === "android") {
+    return { ...ctx, ios: undefined, iosReserved: undefined };
+  }
+  return { ...ctx, android: undefined };
+}
+
+export function manifestForPlatform(manifest: Manifest, platform: DetectedPlatform): Manifest {
+  return {
+    ...manifest,
+    targets: manifest.targets?.filter((target) => target.platform === platform || target.platform === "all"),
+    steps: manifest.steps.filter((step) => !step.platform || step.platform === platform || step.platform === "all"),
+  };
+}

package/src/core/previewPatches.ts

@@ -0,0 +1,23 @@
+import fs from "node:fs";
+import path from "node:path";
+
+/** Default directory for `pipeline.patch` / `cli-preview.patch` (gitignored). */
+export function resolveDefaultPreviewPatchDir(packageRoot: string): string {
+  return path.join(packageRoot, "test-projects", "_preview");
+}
+
+/**
+ * Before writing a new patch under `test-projects/_preview/`, remove all existing files there
+ * so only the latest command output remains.
+ */
+export function clearPreviewPatchFilesIfTargetInside(packageRoot: string, patchFileAbs: string): void {
+  const previewDir = resolveDefaultPreviewPatchDir(packageRoot);
+  const target = path.resolve(patchFileAbs);
+  const prev = path.resolve(previewDir);
+  if (target !== prev && !target.startsWith(prev + path.sep)) return;
+  if (!fs.existsSync(prev)) return;
+  for (const ent of fs.readdirSync(prev, { withFileTypes: true })) {
+    const p = path.join(prev, ent.name);
+    if (ent.isFile()) fs.unlinkSync(p);
+  }
+}

package/src/core/reporter.ts

@@ -0,0 +1,24 @@
+import type { PipelineReport } from "../contracts/types.js";
+
+export function printReport(report: PipelineReport, patch: string, verbose: boolean): void {
+  console.log(`[meetgames] dryRun=${report.dryRun}`);
+  console.log(`[meetgames] steps run: ${report.stepsRun}, skipped: ${report.stepsSkipped}`);
+  if (report.warnings.length) {
+    for (const w of report.warnings) console.log(`[meetgames] warning: ${w}`);
+  }
+  if (report.errors.length) {
+    for (const e of report.errors) console.error(`[meetgames] error: ${e}`);
+  }
+
+  if (!patch.trim()) {
+    console.log("[meetgames] patch preview: no text file changes");
+    return;
+  }
+  const lines = patch.split("\n");
+  const max = verbose ? lines.length : Math.min(lines.length, 120);
+  console.log("[meetgames] patch preview:");
+  console.log(lines.slice(0, max).join("\n"));
+  if (!verbose && lines.length > max) {
+    console.log(`[meetgames] ... truncated ${lines.length - max} lines (use --verbose)`);
+  }
+}

package/src/core/workspace.ts

@@ -0,0 +1,29 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import type { WorkspaceContext, WorkspaceContextOptions } from "../contracts/types.js";
+import { detectAndroid } from "../android/detect.js";
+import { detectIOS } from "../ios/detect.js";
+import { iosToolingReserved } from "../ios/reserved.js";
+
+/** Package root: parent of dist/ when running compiled cli */
+export function resolvePackageRoot(): string {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, "..", "..");
+}
+
+export function buildWorkspaceContext(
+  projectRoot: string,
+  packageRoot?: string,
+  options: WorkspaceContextOptions = {}
+): WorkspaceContext {
+  const root = path.resolve(projectRoot);
+  const pkg = packageRoot ?? resolvePackageRoot();
+  return {
+    projectRoot: root,
+    packageRoot: pkg,
+    sdkHomeApiBaseUrl: options.sdkHomeApiBaseUrl,
+    android: detectAndroid(root, { appTarget: options.appTarget }),
+    ios: detectIOS(root, { appTarget: options.appTarget }),
+    iosReserved: iosToolingReserved,
+  };
+}

package/src/entry.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { main } from "./cli.js";
+
+main().catch((err: unknown) => {
+  console.error(err);
+  process.exit(1);
+});

package/src/index.ts

@@ -0,0 +1,133 @@
+export type * from "./contracts/types.js";
+export { loadManifestFile } from "./config/loadManifest.js";
+export { loadAndroidIntegrationFile, parseAndroidIntegrationJson } from "./config/loadAndroidIntegration.js";
+export {
+  type MeetSdkAnalyticsAdjustCredentials,
+  type MeetSdkAnalyticsAdjustModule,
+  type MeetSdkAnalyticsAppsflyerCredentials,
+  type MeetSdkAnalyticsAppsflyerModule,
+  type MeetSdkAnalyticsFirebaseCredentials,
+  type MeetSdkAnalyticsFirebaseModule,
+  type MeetSdkAnalyticsModules,
+  type MeetSdkDefaultConfig,
+  type MeetSdkFeatureScope,
+  type MeetSdkGradleDependency,
+  type MeetSdkLoginFacebookCredentials,
+  type MeetSdkLoginFacebookModule,
+  type MeetSdkLoginGoogleCredentials,
+  type MeetSdkLoginGoogleModule,
+  type MeetSdkLoginKakaoCredentials,
+  type MeetSdkLoginKakaoModule,
+  type MeetSdkLoginLineCredentials,
+  type MeetSdkLoginLineModule,
+  type MeetSdkLoginModules,
+  type MeetSdkLoginNaverCredentials,
+  type MeetSdkLoginNaverModule,
+  type MeetSdkLoginSnapchatCredentials,
+  type MeetSdkLoginSnapchatModule,
+  type MeetSdkLoginTiktokCredentials,
+  type MeetSdkLoginTiktokModule,
+  type MeetSdkLoginTwitterCredentials,
+  type MeetSdkLoginTwitterModule,
+  type MeetSdkModuleToggles,
+  type MeetSdkPaymentModules,
+  type MeetSdkRemoteConfig,
+  type MeetSdkRemoteTopsdkBlock,
+  type MeetSdkSimpleModule,
+  type MeetSdkSimplePluginConfig,
+  DEFAULT_TOPSDK_PLUGIN_DEPENDENCIES,
+  MEETSDK_REMOTE_CONFIG_FILENAME,
+  applyMeetSdkDefaultConfig,
+  applyFetchConfigCliOverrides,
+  collectMeetSdkRemoteApplyPlugins,
+  collectMeetSdkRemoteBuildscriptClasspaths,
+  collectMeetSdkRemoteBuildscriptRepositories,
+  collectMeetSdkRemotePluginsDslForModule,
+  collectMeetSdkRemotePluginsDslForRoot,
+  collectMeetSdkRemoteRepositories,
+  type MeetSdkGradlePluginDslSpec,
+  defaultSdkModules,
+  emptySdkModules,
+  hasSdkModuleKey,
+  isSdkModuleToggleOn,
+  mapTopSdkGetSdkConfigToMeetSdkRemoteConfig,
+  readMeetSdkRemoteChannel,
+  normalizeSdkModulesFromUnknown,
+  tryParseAsMeetSdkDefaultConfig,
+  tryParseAsMeetSdkRemoteConfig,
+  validateMeetSdkRemoteConfig,
+} from "./config/meetSdkRemoteConfig.js";
+export {
+  loadBuiltInMeetSdkDefaultConfig,
+  loadMeetSdkDefaultConfigWithLatestAndroidVersion,
+  resolveMeetSdkAndroidConfigPath,
+  syncMeetSdkAndroidVersionToConfig,
+} from "./config/meetSdkDefaultConfig.js";
+export {
+  MEETSDK_IOS_CONFIG_FILENAME,
+  loadMeetSdkIosConfig,
+  resolveMeetSdkIosConfigPath,
+  syncMeetSdkIosVersionToConfig,
+  tryParseAsMeetSdkIosConfig,
+  writeMeetSdkIosConfig,
+  type MeetSdkIosConfig,
+} from "./config/meetSdkIosConfig.js";
+export {
+  type MeetSdkFeatureCategory,
+  type TopSdkFeatureModule,
+  TOPSDK_FEATURE_MODULES,
+  buildTopSdkFeatureImplementationLines,
+  isTopSdkFeatureModuleEnabled,
+} from "./config/topsdkFeatureModules.js";
+export { clearPreviewPatchFilesIfTargetInside, resolveDefaultPreviewPatchDir } from "./core/previewPatches.js";
+export { buildWorkspaceContext, resolvePackageRoot } from "./core/workspace.js";
+export { runPipeline } from "./core/pipeline.js";
+export { generatePatchForFile } from "./core/patch.js";
+export { androidPlatformAdapter } from "./android/adapter.js";
+export { fetchJsonGet } from "./remote/fetchJson.js";
+export { topsdkMd5Base64Sign } from "./remote/topsdkSign.js";
+export {
+  TOPSDK_GET_SDK_CONFIG_DISCOVERY_AUTH_TYPES,
+  defaultTopSdkBaseUrl,
+  fetchTopSdkGetSdkConfig,
+  filterTopSdkAuthTypesForRequest,
+  resolveAuthTypesForGetSdkConfigRequest,
+  buildTopSdkGetSdkConfigUrl,
+} from "./remote/topsdkGetSdkConfig.js";
+export {
+  buildTopSdkDownloadSdkConfigUrl,
+  fetchTopSdkDownloadSdkConfig,
+  parseTopSdkApiErrorBody,
+} from "./remote/topsdkDownloadSdkConfig.js";
+export {
+  DEFAULT_IOS_SDK_PACKAGE_TYPE,
+  DEFAULT_IOS_SDK_PLUGINS,
+  buildSdkHomeDownloadUrl,
+  buildSdkHomeVersionUrl,
+  defaultSdkHomeApiBaseUrl,
+  downloadBinaryFile,
+  downloadIosSdkToBundled,
+  extractZip,
+  fetchSdkHomeIosDownloadUrl,
+  fetchSdkHomeIosVersion,
+  fetchSdkHomeVersions,
+  resolveIosSdkRootFromDirectory,
+  resolveIosSdkZipFileName,
+  type DownloadIosSdkOptions,
+  type DownloadIosSdkResult,
+  type SdkHomeDownloadUrlRequest,
+  type SdkHomePlatformVersion,
+  type SdkHomeVersions,
+} from "./remote/sdkHomeDownload.js";
+export { unwrapRemoteIntegrationPayload, attachIntegrationMeta } from "./android/assembleIntegrationJson.js";
+export { iosToolingReserved, detectIOSPlaceholder } from "./ios/reserved.js";
+export { detectIOS } from "./ios/detect.js";
+export { runIosIntegrateTopSdk } from "./ios/integrate.js";
+export { resolveIosSdkRoot } from "./ios/sdkBundle.js";
+export { createMeetgamesMcpServer, startMeetgamesMcpServer } from "./mcp/server.js";
+export {
+  meetgamesDoctor,
+  meetgamesFetchConfig,
+  meetgamesIntegrate,
+  meetgamesSetup,
+} from "./mcp/service.js";

package/src/ios/channelConfig.ts

@@ -0,0 +1,128 @@
+import type { MeetSdkRemoteConfig } from "../config/meetSdkRemoteConfig.js";
+import { hasSdkModuleKey } from "../config/meetSdkRemoteConfig.js";
+
+/** Flat map for `{topsdk.appId}` style templates in plugin config. */
+export function buildChannelConfigMap(config: MeetSdkRemoteConfig): Record<string, unknown> {
+  const out: Record<string, unknown> = {
+    packageName: config.packageName,
+    channel: config.channel,
+    devicePlatform: config.devicePlatform,
+    topsdk: { ...config.topsdk },
+    sdkModules: config.sdkModules,
+  };
+  for (const [scope, bucket] of Object.entries(config.sdkModules)) {
+    if (!bucket || typeof bucket !== "object") continue;
+    const scopeRecord = bucket as Record<string, unknown>;
+    for (const [key, val] of Object.entries(scopeRecord)) {
+      if (!hasSdkModuleKey(scopeRecord, key)) continue;
+      if (typeof val === "object" && val !== null) {
+        const normalized = normalizeIosChannelConfig(key, val as Record<string, unknown>);
+        out[`${scope}.${key}`] = val;
+        out[key] = val;
+        out[key.toUpperCase()] = normalized;
+        if (key === "facebookdata" && !out.FACEBOOK) {
+          out.FACEBOOK = normalized;
+        }
+      }
+    }
+  }
+  return out;
+}
+
+function normalizeIosChannelConfig(subKey: string, value: Record<string, unknown>): Record<string, unknown> {
+  const normalized: Record<string, unknown> = { ...value };
+  if (subKey === "facebook") {
+    normalized.clientId = normalized.clientId ?? normalized.facebookAppId ?? normalized.appId;
+    normalized.name = normalized.name ?? normalized.facebookDisplayName ?? normalized.displayName;
+    normalized.scheme = normalized.scheme ?? normalized.fbLoginProtocolScheme;
+    normalized.secret = normalized.secret ?? normalized.facebookClientToken ?? normalized.clientToken;
+    normalized.openMessenger = normalized.openMessenger ?? "0";
+  }
+  if (subKey === "facebookdata") {
+    normalized.clientId = normalized.clientId ?? normalized.facebookAppId ?? normalized.appId;
+    normalized.name = normalized.name ?? normalized.facebookDisplayName ?? normalized.displayName;
+    normalized.scheme = normalized.scheme ?? normalized.fbLoginProtocolScheme;
+    normalized.secret = normalized.secret ?? normalized.facebookClientToken ?? normalized.clientToken;
+  }
+  if (subKey === "google") {
+    normalized.clientId = normalized.clientId ?? normalized.googleClientId;
+    normalized.scheme = normalized.scheme ?? normalized.reversedClientId ?? normalized.reversed_client_id;
+  }
+  if (subKey === "appsflyer") {
+    normalized.clientId = normalized.clientId ?? normalized.appleAppId ?? normalized.appId;
+    normalized.secret = normalized.secret ?? normalized.devKey;
+  }
+  if (subKey === "adjust") {
+    normalized.clientId = normalized.clientId ?? normalized.appId ?? normalized.appToken;
+  }
+  if (subKey === "firebase") {
+    normalized.clientId = normalized.clientId ?? normalized.firebase_file_url ?? normalized.googleServicesUrl;
+  }
+  if (subKey === "snapchat") {
+    normalized.scheme = normalized.scheme ?? schemeFromNonHttpUrl(normalized.redirect);
+  }
+  if (subKey === "line" || subKey === "naver") {
+    normalized.scheme = normalized.scheme ?? schemeFromNonHttpUrl(normalized.redirect);
+  }
+  return normalized;
+}
+
+function schemeFromNonHttpUrl(value: unknown): string | undefined {
+  if (typeof value !== "string" || !value.trim()) return undefined;
+  try {
+    const u = new URL(value);
+    const scheme = u.protocol.replace(/:$/, "");
+    if (!scheme || scheme === "http" || scheme === "https") return undefined;
+    return scheme;
+  } catch {
+    const match = value.match(/^([A-Za-z][A-Za-z0-9+.-]*):\/\//);
+    return match?.[1];
+  }
+}
+
+/** `meetsdk-remote-config` subKey → TopSDK iOS `plugins/<folder>/` name (native iOS package). */
+export const IOS_PLUGIN_FOLDER_BY_SUBKEY: Record<string, string> = {
+  guest: "GuestSignin",
+  email: "EmailSignin",
+  facebook: "FacebookSignin",
+  google: "GoogleSignin",
+  snapchat: "SnapchatSignin",
+  discord: "DiscordSignin",
+  line: "LineSignin",
+  naver: "NaverSignin",
+  kakao: "KakaoSignin",
+  tiktok: "TiktokSignin",
+  googleIap: "IAPPay",
+  apple: "AppleSignin",
+  appsflyer: "AppsFlyerManager",
+  firebase: "FirebaseManager",
+  adjust: "AdjustManager",
+  facebookdata: "FacebookManager",
+};
+
+export function enabledIosPluginFolders(config: MeetSdkRemoteConfig): string[] {
+  const folders: string[] = [];
+  for (const [scope, bucket] of Object.entries(config.sdkModules)) {
+    if (!bucket || typeof bucket !== "object") continue;
+    const scopeRecord = bucket as Record<string, unknown>;
+    for (const [subKey, val] of Object.entries(scopeRecord)) {
+      if (!hasSdkModuleKey(scopeRecord, subKey)) continue;
+      const folder = IOS_PLUGIN_FOLDER_BY_SUBKEY[subKey];
+      if (folder) folders.push(folder);
+    }
+  }
+  return [...new Set(folders)];
+}
+
+export function unsupportedIosModuleKeys(config: MeetSdkRemoteConfig): string[] {
+  const keys: string[] = [];
+  for (const [scope, bucket] of Object.entries(config.sdkModules)) {
+    if (!bucket || typeof bucket !== "object") continue;
+    const scopeRecord = bucket as Record<string, unknown>;
+    for (const [subKey] of Object.entries(scopeRecord)) {
+      if (!hasSdkModuleKey(scopeRecord, subKey)) continue;
+      if (!IOS_PLUGIN_FOLDER_BY_SUBKEY[subKey]) keys.push(`${scope}.${subKey}`);
+    }
+  }
+  return keys;
+}

package/src/ios/codeUtils.ts

@@ -0,0 +1,160 @@
+import fs from "node:fs";
+import path from "node:path";
+
+/** Objective-C AppDelegate injection (topsdk-tool-ios CodeUtils). */
+export class CodeUtils {
+  constructor(private filePath: string, private content: string) {}
+
+  static fromFile(filePath: string): CodeUtils {
+    if (!fs.existsSync(filePath)) throw new Error(`code file not found: ${filePath}`);
+    return new CodeUtils(filePath, fs.readFileSync(filePath, "utf8"));
+  }
+
+  get text(): string {
+    return this.content;
+  }
+
+  private checkExisted(code: string): boolean {
+    const norm = (s: string) => s.replace(/\s/g, "");
+    return norm(this.content).includes(norm(code));
+  }
+
+  addHeader(code: string): boolean {
+    if (this.checkExisted(code)) return true;
+    this.content = `${code}\n${this.content}`;
+    return true;
+  }
+
+  addCodeToMethod(method: string, code: string, addToReturn = false): boolean {
+    if (this.checkExisted(code)) return true;
+    const bodyCode = code.replace(/;/g, "");
+    const methodSig = method.replace(/[{}\s]/g, "");
+
+    if (this.checkExisted(methodSig)) {
+      const lines = this.content.split("\n");
+      const out: string[] = [];
+      let methodStart = false;
+      let added = false;
+      for (const line of lines) {
+        if (!addToReturn) {
+          out.push(line);
+          const temp = line.replace(/\s/g, "");
+          if (temp.includes(methodSig)) methodStart = true;
+          if (line.includes("{") && methodStart && !added) {
+            out.push(`\t${bodyCode};\n`);
+            added = true;
+          }
+        } else {
+          const temp = line.replace(/\s/g, "");
+          if (temp.includes(methodSig)) {
+            methodStart = true;
+            out.push(line);
+          } else if (line.includes("return") && methodStart && !added) {
+            if (line.includes("return YES;") || line.includes("return NO;")) {
+              out.push(`\treturn ${bodyCode};\n`);
+            } else {
+              const returnIndex = line.indexOf("return ");
+              const semi = line.indexOf(";");
+              const current = line.slice(returnIndex + 7, semi);
+              out.push(`\treturn (${current} && ${bodyCode});\n`);
+            }
+            added = true;
+          } else {
+            out.push(line);
+          }
+        }
+      }
+      if (added) {
+        this.content = out.join("\n");
+        return true;
+      }
+      return false;
+    }
+
+    const lines = this.content.split("\n");
+    const out: string[] = [];
+    let blockStart = false;
+    let added = false;
+    for (const line of lines) {
+      if (line.includes("@implementation")) {
+        out.push(line);
+        blockStart = true;
+      } else if (line.includes("@end") && blockStart && !added) {
+        out.push(`${method} {`);
+        if (addToReturn) out.push(`\treturn ${bodyCode};\n`);
+        else out.push(`\t${bodyCode};\n`);
+        out.push("}\n");
+        out.push("@end\n");
+        added = true;
+      } else {
+        out.push(line);
+      }
+    }
+    if (added) {
+      this.content = out.join("\n");
+      return true;
+    }
+    return false;
+  }
+
+  writeIfChanged(): boolean {
+    const before = fs.readFileSync(this.filePath, "utf8");
+    if (before === this.content) return false;
+    fs.writeFileSync(this.filePath, this.content, "utf8");
+    return true;
+  }
+
+  applyToStore(write: (content: string) => void): boolean {
+    write(this.content);
+    return true;
+  }
+}
+
+function findObjectiveCDelegateFiles(srcRoot: string, marker: string): string[] {
+  const paths: string[] = [];
+  const walk = (dir: string): void => {
+    let entries: fs.Dirent[];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (e.name.startsWith(".")) continue;
+      const full = path.join(dir, e.name);
+      if (e.isDirectory()) {
+        if (!["Pods", "build", "DerivedData", "topSDK"].includes(e.name)) walk(full);
+        continue;
+      }
+      if (!/\.(m|mm|h)$/.test(e.name)) continue;
+      let text: string;
+      try {
+        text = fs.readFileSync(full, "utf8");
+      } catch {
+        continue;
+      }
+      if (!text.includes(marker)) continue;
+      if (e.name.endsWith(".h")) {
+        const m = full.replace(/\.h$/, ".m");
+        const mm = full.replace(/\.h$/, ".mm");
+        if (fs.existsSync(m)) paths.push(m);
+        if (fs.existsSync(mm)) paths.push(mm);
+      } else {
+        paths.push(full);
+      }
+    }
+  };
+  walk(srcRoot);
+  return [...new Set(paths)];
+}
+
+export function findDelegateFiles(srcRoot: string): string[] {
+  return findObjectiveCDelegateFiles(srcRoot, "UIApplicationDelegate").filter((p) => {
+    const name = path.basename(p);
+    return name !== "Unity_iPhone_Tests.m" && name !== "UnityAppController+ViewHandling.mm";
+  });
+}
+
+export function findSceneDelegateFiles(srcRoot: string): string[] {
+  return findObjectiveCDelegateFiles(srcRoot, "UIWindowSceneDelegate");
+}

package/src/ios/detect.ts

@@ -0,0 +1,105 @@
+import fs from "node:fs";
+import path from "node:path";
+import type { IOSDetectOptions, IOSDetectResult } from "../contracts/types.js";
+
+function findXcodeprojDirs(root: string, maxDepth: number): string[] {
+  const found: string[] = [];
+  const walk = (dir: string, depth: number): void => {
+    if (depth > maxDepth) return;
+    let entries: fs.Dirent[];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (e.name.startsWith(".")) continue;
+      const full = path.join(dir, e.name);
+      if (e.isDirectory() && e.name.endsWith(".xcodeproj")) {
+        found.push(full);
+        continue;
+      }
+      if (e.isDirectory() && !["node_modules", "Pods", "build", "DerivedData"].includes(e.name)) {
+        walk(full, depth + 1);
+      }
+    }
+  };
+  walk(root, 0);
+  return found.sort();
+}
+
+function readPrimaryTargetName(pbxprojContent: string): string | null {
+  return readApplicationTargetNames(pbxprojContent)[0] ?? null;
+}
+
+function unquotePbxValue(value: string): string {
+  return value.trim().replace(/^"|"$/g, "");
+}
+
+function readApplicationTargetNames(pbxprojContent: string): string[] {
+  const names: string[] = [];
+  const targetBlock = /^[ \t]*[A-Za-z0-9]+ \/\*[^*]*\*\/ = \{\s*isa = PBXNativeTarget;[\s\S]*?^[ \t]*\};/gm;
+  let match = targetBlock.exec(pbxprojContent);
+  while (match) {
+    const block = match[0];
+    if (/\bproductType\s*=\s*"com\.apple\.product-type\.application"\s*;/.test(block)) {
+      const name = block.match(/\bname\s*=\s*([^;]+);/);
+      if (name) names.push(unquotePbxValue(name[1]));
+    }
+    match = targetBlock.exec(pbxprojContent);
+  }
+  return names;
+}
+
+function targetList(targetNames: string[]): string {
+  return targetNames.join(", ");
+}
+
+export function detectIOS(projectRoot: string, options: IOSDetectOptions = {}): IOSDetectResult {
+  const root = path.resolve(projectRoot);
+  let xcodeprojPath: string;
+  if (root.endsWith(".xcodeproj")) {
+    if (!fs.existsSync(root) || !fs.statSync(root).isDirectory()) {
+      return { ok: false, error: `xcodeproj path does not exist or is not a directory: ${root}` };
+    }
+    xcodeprojPath = root;
+  } else {
+    const xcodeprojs = findXcodeprojDirs(root, 4);
+    if (!xcodeprojs.length) {
+      return { ok: false, error: "no .xcodeproj found under project root" };
+    }
+    xcodeprojPath = xcodeprojs[0];
+  }
+  const iosRoot = path.dirname(xcodeprojPath);
+  const pbxprojPath = path.join(xcodeprojPath, "project.pbxproj");
+  if (!fs.existsSync(pbxprojPath)) {
+    return { ok: false, error: `missing project.pbxproj: ${pbxprojPath}` };
+  }
+  const pbx = fs.readFileSync(pbxprojPath, "utf8");
+  const targetNames = readApplicationTargetNames(pbx);
+  if (!targetNames.length) {
+    return { ok: false, error: "NO_IOS_APP_TARGET_FOUND" };
+  }
+  const requestedTarget = options.appTarget?.trim() ?? "";
+  if (requestedTarget && !targetNames.includes(requestedTarget)) {
+    return {
+      ok: false,
+      error: `IOS_APP_TARGET_NOT_FOUND: ${requestedTarget}; available app targets: ${targetList(targetNames)}`,
+    };
+  }
+  const targetName = requestedTarget || readPrimaryTargetName(pbx) || path.basename(xcodeprojPath, ".xcodeproj");
+  const podfilePath = path.join(iosRoot, "Podfile");
+  const workspaceCandidates = fs
+    .readdirSync(iosRoot)
+    .filter((n) => n.endsWith(".xcworkspace"))
+    .map((n) => path.join(iosRoot, n));
+  return {
+    ok: true,
+    iosRoot,
+    xcodeprojPath,
+    workspacePath: workspaceCandidates[0],
+    podfilePath: fs.existsSync(podfilePath) ? podfilePath : undefined,
+    targetName,
+    targetNames,
+  };
+}