@leonxin/meetgames 0.1.8 → 0.1.12

package/src/core/doctor.ts

@@ -0,0 +1,485 @@
+import fs from "node:fs";
+import path from "node:path";
+import {
+  applicationModuleRelPath,
+} from "../android/detect.js";
+import {
+  detectModuleGradlePluginStyle,
+  extractImplementationKey,
+  extractResValueKey,
+  mavenGroupArtifactKey,
+} from "../android/meetSdkRemoteGradle.js";
+import {
+  MEETSDK_REMOTE_CONFIG_FILENAME,
+  applyMeetSdkDefaultConfig,
+  collectMeetSdkRemoteBuildscriptClasspaths,
+  collectMeetSdkRemoteBuildscriptRepositories,
+  collectMeetSdkRemotePluginsDslForModule,
+  collectMeetSdkRemotePluginsDslForRoot,
+  collectMeetSdkRemoteRepositories,
+  hasSdkModuleKey,
+  tryParseAsMeetSdkRemoteConfig,
+  validateMeetSdkRemoteConfig,
+  type MeetSdkRemoteConfig,
+} from "../config/meetSdkRemoteConfig.js";
+import { loadMeetSdkDefaultConfigWithLatestAndroidVersion } from "../config/meetSdkDefaultConfig.js";
+import {
+  TOPSDK_FEATURE_MODULES,
+} from "../config/topsdkFeatureModules.js";
+import type { WorkspaceContext } from "../contracts/types.js";
+import { buildChannelConfigMap, enabledIosPluginFolders, unsupportedIosModuleKeys } from "../ios/channelConfig.js";
+import { findDelegateFiles, findSceneDelegateFiles } from "../ios/codeUtils.js";
+import { parsePlistXml } from "../ios/infoPlist.js";
+import { findInfoPlistPathsFromPbx, loadPbxFromStore } from "../ios/pbxprojEditor.js";
+import { findPluginByFolder, listSdkCoreConfigs, validateLoadedPluginResources } from "../ios/pluginConfig.js";
+import { resolveIosSdkRoot } from "../ios/sdkBundle.js";
+import { applyChannelTemplate, applyChannelTemplateValue } from "../ios/template.js";
+import type { CodeConfig, LoadedPluginConfig } from "../ios/types.js";
+import { TextFileStore } from "../ops/fileStore.js";
+
+export interface DoctorCheck {
+  name: string;
+  ok: boolean;
+  details?: string;
+}
+
+export interface DoctorReport {
+  projectRoot: string;
+  platform: "android" | "ios";
+  configPath: string;
+  ok: boolean;
+  checks: DoctorCheck[];
+  warnings: string[];
+  errors: string[];
+}
+
+function addCheck(report: DoctorReport, name: string, ok: boolean, details?: string): void {
+  report.checks.push({ name, ok, ...(details ? { details } : {}) });
+  if (!ok) report.errors.push(details ? `${name}: ${details}` : name);
+}
+
+function readJsonConfig(configPath: string): MeetSdkRemoteConfig | null {
+  const abs = configPath;
+  if (!fs.existsSync(abs)) return null;
+  try {
+    return tryParseAsMeetSdkRemoteConfig(JSON.parse(fs.readFileSync(abs, "utf8")) as unknown);
+  } catch {
+    return null;
+  }
+}
+
+function readFileIfExists(abs: string): string {
+  return fs.existsSync(abs) ? fs.readFileSync(abs, "utf8") : "";
+}
+
+function lineDeclaresRepository(line: string, repo: string): boolean {
+  const t = line.trim();
+  if (repo === "google") return /\bgoogle\s*\(\s*\)/.test(t);
+  if (repo === "mavenCentral") return /\bmavenCentral\s*\(\s*\)/.test(t);
+  return t.includes("maven") && t.includes(repo);
+}
+
+function fileContainsRepository(text: string, repo: string): boolean {
+  return text.split("\n").some((line) => lineDeclaresRepository(line, repo));
+}
+
+function moduleBuildGradlePath(ctx: WorkspaceContext): string | null {
+  if (!ctx.android?.ok) return null;
+  const groovy = path.join(ctx.android.moduleDir, "build.gradle");
+  if (fs.existsSync(groovy)) return groovy;
+  const kts = path.join(ctx.android.moduleDir, "build.gradle.kts");
+  return fs.existsSync(kts) ? kts : null;
+}
+
+function rootBuildGradlePath(projectRoot: string): string | null {
+  for (const name of ["build.gradle", "build.gradle.kts"]) {
+    const abs = path.join(projectRoot, name);
+    if (fs.existsSync(abs)) return abs;
+  }
+  return null;
+}
+
+function settingsGradlePath(projectRoot: string): string | null {
+  for (const name of ["settings.gradle", "settings.gradle.kts"]) {
+    const abs = path.join(projectRoot, name);
+    if (fs.existsSync(abs)) return abs;
+  }
+  return null;
+}
+
+function extractResValues(text: string): Map<string, string> {
+  const out = new Map<string, string>();
+  for (const line of text.split("\n")) {
+    const key = extractResValueKey(line);
+    if (!key) continue;
+    const m = line.match(/resValue\s*\(\s*['"][^'"]+['"]\s*,\s*['"][^'"]+['"]\s*,\s*(.*?)\s*\)\s*$/);
+    if (!m) continue;
+    out.set(key, m[1].replace(/^['"]|['"]$/g, ""));
+  }
+  return out;
+}
+
+function putExpected(out: Map<string, string>, key: string, value: unknown): void {
+  if (value === undefined || value === null || String(value).length === 0) return;
+  out.set(key, String(value));
+}
+
+function expectedAndroidResValues(config: MeetSdkRemoteConfig): Map<string, string> {
+  const out = new Map<string, string>();
+  putExpected(out, "top_channel_id", config.channel);
+  putExpected(out, "top_app_id", config.topsdk.appId);
+  const L = config.sdkModules.login;
+  const A = config.sdkModules.analytics;
+  if (typeof L.facebook === "object" && L.facebook) {
+    putExpected(out, "facebook_app_id", L.facebook.facebookAppId);
+    putExpected(out, "fb_login_protocol_scheme", L.facebook.fbLoginProtocolScheme);
+    putExpected(out, "facebook_client_token", L.facebook.facebookClientToken);
+  }
+  if (typeof L.google === "object" && L.google) putExpected(out, "google_client_id", L.google.googleClientId);
+  if (typeof L.twitter === "object" && L.twitter) {
+    putExpected(out, "twitter_client_id", L.twitter.clientId);
+    putExpected(out, "twitter_client_secret", L.twitter.secret);
+    putExpected(out, "twitter_redirect_url", L.twitter.redirect);
+  }
+  if (typeof L.snapchat === "object" && L.snapchat) {
+    putExpected(out, "snapchat_client_id", L.snapchat.clientId);
+    putExpected(out, "snapchat_redirect_uri", L.snapchat.redirect);
+  }
+  if (typeof L.tiktok === "object" && L.tiktok) {
+    putExpected(out, "tiktok_client_id", L.tiktok.clientId);
+    putExpected(out, "tiktok_client_secret", L.tiktok.secret);
+    putExpected(out, "tiktok_redirect_uri", L.tiktok.redirect);
+  }
+  if (typeof L.discord === "object" && L.discord) {
+    putExpected(out, "discord_client_id", L.discord.clientId);
+    putExpected(out, "discord_client_secret", L.discord.secret);
+    putExpected(out, "discord_redirect_uri", L.discord.redirect);
+  }
+  if (typeof L.line === "object" && L.line) putExpected(out, "line_channel_id", L.line.clientId);
+  if (typeof L.kakao === "object" && L.kakao) {
+    putExpected(out, "kakao_app_id", L.kakao.clientId);
+    putExpected(out, "kakao_scheme", L.kakao.scheme);
+  }
+  if (typeof L.naver === "object" && L.naver) {
+    putExpected(out, "naver_client_id", L.naver.clientId);
+    putExpected(out, "naver_client_secret", L.naver.secret);
+    putExpected(out, "naver_client_name", L.naver.name);
+  }
+  if (typeof A.appsflyer === "object" && A.appsflyer) {
+    putExpected(out, "appsflyer_enable_debug_log", Boolean(A.appsflyer.enableDebugLog));
+    putExpected(out, "af_dev_key", A.appsflyer.devKey);
+  }
+  if (typeof A.adjust === "object" && A.adjust) {
+    putExpected(out, "adjust_enable_sandbox", Boolean(A.adjust.enableSandbox));
+    putExpected(out, "adjust_app_token", A.adjust.appId);
+  }
+  if (typeof A.facebookdata === "object" && A.facebookdata) {
+    putExpected(out, "facebook_data_app_id", A.facebookdata.facebookAppId);
+    putExpected(out, "facebook_data_client_token", A.facebookdata.facebookClientToken);
+  }
+  return out;
+}
+
+function checkAndroidDependency(moduleGradle: string, groupId: string, artifact: string): boolean {
+  for (const line of moduleGradle.split("\n")) {
+    const key = extractImplementationKey(line, moduleGradle, groupId);
+    if (key === `${groupId}:${artifact}`) return true;
+  }
+  return false;
+}
+
+async function checkAndroid(ctx: WorkspaceContext, report: DoctorReport, config: MeetSdkRemoteConfig): Promise<void> {
+  if (!ctx.android?.ok) {
+    addCheck(report, "android.detect", false, "android application module not detected");
+    return;
+  }
+  const resolved = applyMeetSdkDefaultConfig(
+    config,
+    await loadMeetSdkDefaultConfigWithLatestAndroidVersion({
+      sdkHomeApiBaseUrl: ctx.sdkHomeApiBaseUrl,
+      packageRoot: ctx.packageRoot,
+    })
+  );
+  const moduleGradleAbs = moduleBuildGradlePath(ctx);
+  const rootGradleAbs = rootBuildGradlePath(ctx.projectRoot);
+  const settingsGradleAbs = settingsGradlePath(ctx.projectRoot);
+  const moduleGradle = moduleGradleAbs ? readFileIfExists(moduleGradleAbs) : "";
+  const rootGradle = rootGradleAbs ? readFileIfExists(rootGradleAbs) : "";
+  const settingsGradle = settingsGradleAbs ? readFileIfExists(settingsGradleAbs) : "";
+
+  addCheck(report, "android.moduleGradle.exists", Boolean(moduleGradleAbs), moduleGradleAbs ?? "module build.gradle not found");
+  addCheck(report, "android.applicationId", moduleGradle.includes(`applicationId "${resolved.packageName}"`) || moduleGradle.includes(`applicationId '${resolved.packageName}'`), resolved.packageName);
+
+  const repoText = `${settingsGradle}\n${rootGradle}`;
+  const missingRepos = collectMeetSdkRemoteRepositories(resolved).filter((repo) => !fileContainsRepository(repoText, repo));
+  addCheck(report, "android.repositories", missingRepos.length === 0, missingRepos.length ? `missing: ${missingRepos.join(", ")}` : "all expected repositories found");
+
+  const style = moduleGradle ? detectModuleGradlePluginStyle(moduleGradle) : "apply-plugin";
+  const rootPluginIds = collectMeetSdkRemotePluginsDslForRoot(resolved).map((p) => p.id);
+  const modulePluginIds = collectMeetSdkRemotePluginsDslForModule(resolved).map((p) => p.id);
+  if (style === "plugins-dsl") {
+    const missingRootPlugins = rootPluginIds.filter((id) => !rootGradle.includes(id));
+    const missingModulePlugins = modulePluginIds.filter((id) => !moduleGradle.includes(id));
+    addCheck(report, "android.gradlePlugins", missingRootPlugins.length + missingModulePlugins.length === 0, [...missingRootPlugins, ...missingModulePlugins].join(", ") || "all expected plugins found");
+  } else {
+    const missingClasspaths = collectMeetSdkRemoteBuildscriptClasspaths(resolved).filter((cp) => !rootGradle.includes(cp));
+    const missingBuildscriptRepos = collectMeetSdkRemoteBuildscriptRepositories(resolved).filter((repo) => !fileContainsRepository(rootGradle, repo));
+    addCheck(report, "android.buildscript", missingClasspaths.length + missingBuildscriptRepos.length === 0, [...missingClasspaths, ...missingBuildscriptRepos].join(", ") || "buildscript is configured");
+  }
+
+  const expectedArtifacts = ["ui"];
+  for (const m of TOPSDK_FEATURE_MODULES) {
+    const bucket = resolved.sdkModules[m.scope] as unknown as Record<string, unknown>;
+    if (hasSdkModuleKey(bucket, m.subKey)) expectedArtifacts.push(m.topsdkArtifact);
+  }
+  const missingDeps = expectedArtifacts.filter((artifact) => !checkAndroidDependency(moduleGradle, resolved.topsdk.groupId, artifact));
+  addCheck(report, "android.dependencies", missingDeps.length === 0, missingDeps.length ? `missing artifacts: ${missingDeps.join(", ")}` : "all expected dependencies found");
+
+  const actualResValues = extractResValues(moduleGradle);
+  const missingResValues: string[] = [];
+  for (const [key, expected] of expectedAndroidResValues(resolved)) {
+    if (actualResValues.get(key) !== expected) missingResValues.push(`${key}=${expected}`);
+  }
+  addCheck(report, "android.resValues", missingResValues.length === 0, missingResValues.length ? `missing/mismatch: ${missingResValues.join(", ")}` : "all expected resValue entries found");
+
+  const firebase = resolved.sdkModules.analytics.firebase;
+  if (typeof firebase === "object" && firebase) {
+    const moduleRel = applicationModuleRelPath(ctx.projectRoot, ctx.android);
+    const fileName = firebase.firebase_file_name || "google-services.json";
+    const googleServices = path.join(ctx.projectRoot, moduleRel, fileName);
+    addCheck(report, "android.firebaseFile", fs.existsSync(googleServices), path.relative(ctx.projectRoot, googleServices));
+  }
+}
+
+function normalizeCode(text: string): string {
+  return text.replace(/\s/g, "");
+}
+
+function readDottedPath(obj: Record<string, unknown>, dottedPath: string): unknown {
+  let cur: unknown = obj;
+  for (const part of dottedPath.split(".")) {
+    if (!part) continue;
+    if (cur && typeof cur === "object" && part in (cur as Record<string, unknown>)) {
+      cur = (cur as Record<string, unknown>)[part];
+    } else {
+      return undefined;
+    }
+  }
+  return cur;
+}
+
+function validateRequiredChannelConfigs(loadedConfigs: LoadedPluginConfig[], channelConfig: Record<string, unknown>): string[] {
+  const missing: string[] = [];
+  for (const loaded of loadedConfigs) {
+    for (const required of loaded.config.requireConfigs ?? []) {
+      const value = readDottedPath(channelConfig, required);
+      if (value === undefined || value === null || String(value).length === 0) missing.push(`${loaded.config.name}: ${required}`);
+    }
+  }
+  return missing;
+}
+
+function plistUrlSchemes(plist: Record<string, unknown>): string[] {
+  const out: string[] = [];
+  const types = Array.isArray(plist.CFBundleURLTypes) ? plist.CFBundleURLTypes : [];
+  for (const entry of types) {
+    if (!entry || typeof entry !== "object") continue;
+    const schemes = (entry as Record<string, unknown>).CFBundleURLSchemes;
+    if (Array.isArray(schemes)) out.push(...schemes.map(String));
+  }
+  return out;
+}
+
+function pluginListByName(list: unknown): Map<string, Record<string, unknown>> {
+  const out = new Map<string, Record<string, unknown>>();
+  if (!Array.isArray(list)) return out;
+  for (const item of list) {
+    if (!item || typeof item !== "object") continue;
+    const rec = item as Record<string, unknown>;
+    const name = typeof rec.name === "string" ? rec.name : "";
+    if (name) out.set(name, rec);
+  }
+  return out;
+}
+
+function expectedIosCopiedPaths(loaded: LoadedPluginConfig): string[] {
+  const out: string[] = [];
+  for (const fw of loaded.config.frameworks ?? []) {
+    if (!fw.system) out.push(path.basename(fw.name));
+  }
+  for (const lib of loaded.config.libs ?? []) {
+    if (!lib.system) out.push(path.basename(lib.name));
+  }
+  for (const source of loaded.config.sources ?? []) {
+    if (loaded.config.name === "FirebaseManager" && source === "GoogleService-Info.plist") continue;
+    out.push(path.basename(source));
+  }
+  return [...new Set(out)];
+}
+
+function appDelegateCodeShouldMoveToSceneDelegate(code: CodeConfig): boolean {
+  if (code.type === "header") return false;
+  const method = code.method ?? "";
+  return (
+    method.includes("openURL") ||
+    method.includes("continueUserActivity") ||
+    method.includes("applicationDidEnterBackground") ||
+    method.includes("applicationWillEnterForeground")
+  );
+}
+
+function appDelegateCodesForLifecycle(loaded: LoadedPluginConfig, hasUniqueSceneDelegate: boolean): CodeConfig[] {
+  const codes = loaded.config.appDelegateCodes ?? [];
+  if (!hasUniqueSceneDelegate) return codes;
+  return codes.filter((code) => !appDelegateCodeShouldMoveToSceneDelegate(code));
+}
+
+function validateLoadedPluginResourcesForDoctor(loaded: LoadedPluginConfig): string[] {
+  const errors = validateLoadedPluginResources(loaded);
+  if (loaded.config.name !== "FirebaseManager") return errors;
+  return errors.filter((error) => !error.includes("missing source resource for FirebaseManager: GoogleService-Info.plist"));
+}
+
+async function checkIos(ctx: WorkspaceContext, report: DoctorReport, config: MeetSdkRemoteConfig): Promise<void> {
+  if (!ctx.ios?.ok) {
+    addCheck(report, "ios.detect", false, "iOS project not detected");
+    return;
+  }
+  const sdkRoot = ctx.iosSdkRoot ?? resolveIosSdkRoot(ctx.packageRoot);
+  const channelConfig = buildChannelConfigMap(config);
+  const coreConfigs = listSdkCoreConfigs(sdkRoot);
+  const pluginConfigs: LoadedPluginConfig[] = [];
+  for (const key of unsupportedIosModuleKeys(config)) {
+    report.warnings.push(`iOS plugin mapping not found for sdkModules.${key}; skipped`);
+  }
+  for (const folder of enabledIosPluginFolders(config)) {
+    const plugin = findPluginByFolder(sdkRoot, folder);
+    if (plugin) pluginConfigs.push(plugin);
+    else report.warnings.push(`iOS plugin folder not in SDK package: plugins/${folder}`);
+  }
+  const loadedConfigs = [...coreConfigs, ...pluginConfigs];
+  const resourceErrors = loadedConfigs.flatMap(validateLoadedPluginResourcesForDoctor);
+  addCheck(report, "ios.sdkResources", resourceErrors.length === 0, resourceErrors.join(", ") || "SDK resources complete");
+  const missingRequired = validateRequiredChannelConfigs(pluginConfigs, channelConfig);
+  addCheck(report, "ios.remoteParams", missingRequired.length === 0, missingRequired.join(", ") || "all required plugin params present");
+
+  const pbxRel = path.relative(ctx.projectRoot, path.join(ctx.ios.xcodeprojPath!, "project.pbxproj")).split(path.sep).join("/");
+  const pbxText = readFileIfExists(path.join(ctx.projectRoot, pbxRel));
+  const topSdkRoot = path.join(ctx.projectRoot, "topSDK");
+  const missingCopied = loadedConfigs.flatMap(expectedIosCopiedPaths).filter((name) => !fs.existsSync(path.join(topSdkRoot, name)));
+  addCheck(report, "ios.frameworkFiles", missingCopied.length === 0, missingCopied.length ? `missing in topSDK: ${missingCopied.join(", ")}` : "all expected SDK files copied");
+  const missingPbxRefs = loadedConfigs
+    .flatMap((loaded) => [...(loaded.config.frameworks ?? []), ...(loaded.config.libs ?? [])].map((x) => x.name))
+    .filter((name) => !pbxText.includes(path.basename(name)));
+  addCheck(report, "ios.pbxprojReferences", missingPbxRefs.length === 0, missingPbxRefs.length ? `missing refs: ${missingPbxRefs.join(", ")}` : "all expected Xcode references found");
+
+  const store = new TextFileStore(ctx.projectRoot);
+  const pbx = await loadPbxFromStore(store, ctx.projectRoot, ctx.ios.xcodeprojPath!, ctx.ios.targetName ?? path.basename(ctx.ios.xcodeprojPath!, ".xcodeproj"));
+  const plistPaths = findInfoPlistPathsFromPbx(pbx);
+  addCheck(report, "ios.infoPlist.exists", plistPaths.length > 0, plistPaths.map((p) => path.relative(ctx.projectRoot, p)).join(", ") || "Info.plist not found from pbxproj");
+  if (typeof config.sdkModules.analytics.firebase === "object" && config.sdkModules.analytics.firebase) {
+    const firebasePlist = plistPaths[0] ? path.join(path.dirname(plistPaths[0]), "GoogleService-Info.plist") : "";
+    addCheck(
+      report,
+      "ios.firebasePlist",
+      Boolean(firebasePlist && fs.existsSync(firebasePlist)),
+      firebasePlist ? path.relative(ctx.projectRoot, firebasePlist) : "GoogleService-Info.plist target path unavailable"
+    );
+  }
+  const plist = plistPaths.length ? parsePlistXml(readFileIfExists(plistPaths[0])) : {};
+  const topSdk = plist.TOPSDK && typeof plist.TOPSDK === "object" ? plist.TOPSDK as Record<string, unknown> : {};
+  addCheck(report, "ios.topSdkAppId", topSdk.APP_ID === config.topsdk.appId, `expected ${config.topsdk.appId}`);
+
+  const normalPlugins = pluginConfigs.filter((p) => p.config.type !== 4);
+  const dataPlugins = pluginConfigs.filter((p) => p.config.type === 4);
+  const actualPlugins = pluginListByName(topSdk.Plugins);
+  const actualDataPlugins = pluginListByName(topSdk.dataPlugins);
+  const missingPluginNames = normalPlugins.map((p) => p.config.name).filter((name) => !actualPlugins.has(name));
+  const missingDataPluginNames = dataPlugins.map((p) => p.config.name).filter((name) => !actualDataPlugins.has(name));
+  addCheck(report, "ios.topSdkPlugins", missingPluginNames.length + missingDataPluginNames.length === 0, [...missingPluginNames, ...missingDataPluginNames].join(", ") || "all enabled plugins are listed");
+
+  const missingPluginParams: string[] = [];
+  for (const loaded of pluginConfigs) {
+    const target = loaded.config.type === 4 ? actualDataPlugins.get(loaded.config.name) : actualPlugins.get(loaded.config.name);
+    const params = target?.params && typeof target.params === "object" ? target.params as Record<string, unknown> : {};
+    for (const [key, raw] of Object.entries(loaded.config.pluginParams ?? {})) {
+      const expected = applyChannelTemplate(String(raw), channelConfig);
+      if (params[key] !== expected) missingPluginParams.push(`${loaded.config.name}.${key}=${expected}`);
+    }
+  }
+  addCheck(report, "ios.pluginParams", missingPluginParams.length === 0, missingPluginParams.join(", ") || "all plugin params match");
+
+  const schemes = plistUrlSchemes(plist);
+  const expectedSchemes: string[] = [];
+  for (const loaded of loadedConfigs) {
+    if (!loaded.config.urlScheme) continue;
+    let scheme = applyChannelTemplate(loaded.config.urlScheme, channelConfig);
+    if (scheme.endsWith("://")) scheme = scheme.replace("://", "");
+    if (scheme) expectedSchemes.push(scheme);
+  }
+  const missingSchemes = expectedSchemes.filter((scheme) => !schemes.includes(scheme));
+  addCheck(report, "ios.urlSchemes.present", missingSchemes.length === 0, missingSchemes.join(", ") || "all expected URL schemes present");
+
+  const missingInfoParams: string[] = [];
+  for (const loaded of loadedConfigs) {
+    for (const [key, raw] of Object.entries(loaded.config.infoParams ?? {})) {
+      const expected = applyChannelTemplateValue(raw, channelConfig);
+      if (JSON.stringify(plist[key]) !== JSON.stringify(expected)) missingInfoParams.push(`${loaded.config.name}.${key}`);
+    }
+  }
+  addCheck(report, "ios.infoParams", missingInfoParams.length === 0, missingInfoParams.join(", ") || "all Info.plist params match");
+
+  const scenes = findSceneDelegateFiles(pbx.srcRoot);
+  const hasUniqueSceneDelegate = scenes.length === 1;
+  const delegates = findDelegateFiles(pbx.srcRoot);
+  const appDelegateMissing: string[] = [];
+  if (delegates.length === 1) {
+    const text = normalizeCode(readFileIfExists(delegates[0]));
+    for (const loaded of loadedConfigs) {
+      for (const code of appDelegateCodesForLifecycle(loaded, hasUniqueSceneDelegate)) {
+        if (!text.includes(normalizeCode(code.content))) appDelegateMissing.push(`${loaded.config.name}: ${code.content}`);
+      }
+    }
+  } else {
+    appDelegateMissing.push(delegates.length ? `multiple delegates: ${delegates.join(", ")}` : "no UIApplicationDelegate .m/.mm found");
+  }
+  addCheck(report, "ios.appDelegateInjection", appDelegateMissing.length === 0, appDelegateMissing.join(", ") || "AppDelegate injection complete");
+
+  const sceneMissing: string[] = [];
+  if (scenes.length === 1) {
+    const text = normalizeCode(readFileIfExists(scenes[0]));
+    for (const loaded of loadedConfigs) {
+      for (const code of loaded.config.sceneDelegateCodes ?? []) {
+        if (!text.includes(normalizeCode(code.content))) sceneMissing.push(`${loaded.config.name}: ${code.content}`);
+      }
+    }
+  } else if (scenes.length > 1) {
+    sceneMissing.push(`multiple scene delegates: ${scenes.join(", ")}`);
+  }
+  addCheck(report, "ios.sceneDelegateInjection", sceneMissing.length === 0, sceneMissing.join(", ") || "SceneDelegate injection complete or not required");
+}
+
+export async function runDoctor(ctx: WorkspaceContext, platform: "android" | "ios"): Promise<DoctorReport> {
+  const configPath = ctx.remoteConfigPath ?? path.join(ctx.projectRoot, MEETSDK_REMOTE_CONFIG_FILENAME);
+  const report: DoctorReport = {
+    projectRoot: ctx.projectRoot,
+    platform,
+    configPath,
+    ok: false,
+    checks: [],
+    warnings: [],
+    errors: [],
+  };
+  const config = readJsonConfig(configPath);
+  addCheck(report, "remoteConfig.existsAndParses", Boolean(config), configPath);
+  if (!config) {
+    report.ok = false;
+    return report;
+  }
+  const validation = validateMeetSdkRemoteConfig(config);
+  addCheck(report, "remoteConfig.requiredFields", validation.ok, validation.ok ? "required fields present" : validation.missing.join(", "));
+  if (platform === "android") await checkAndroid(ctx, report, config);
+  else await checkIos(ctx, report, config);
+  report.ok = report.errors.length === 0;
+  return report;
+}

package/src/core/patch.ts

@@ -0,0 +1,64 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+
+export function generatePatchForFile(relativePath: string, originalContent: string, updatedContent: string): string {
+  if (originalContent === updatedContent) return "";
+
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "meetgames-"));
+  const leftPath = path.join(tempRoot, "left", relativePath);
+  const rightPath = path.join(tempRoot, "right", relativePath);
+
+  try {
+    fs.mkdirSync(path.dirname(leftPath), { recursive: true });
+    fs.mkdirSync(path.dirname(rightPath), { recursive: true });
+    fs.writeFileSync(leftPath, originalContent);
+    fs.writeFileSync(rightPath, updatedContent);
+
+    let diffOutput = "";
+    try {
+      diffOutput = execFileSync("git", ["diff", "--no-index", "--text", "--", leftPath, rightPath], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+      });
+    } catch (error: unknown) {
+      const err = error as { status?: number; stdout?: string };
+      if (err && err.status === 1 && typeof err.stdout === "string") {
+        diffOutput = err.stdout;
+      } else {
+        throw error;
+      }
+    }
+
+    return normalizePatchHeaders(diffOutput, relativePath);
+  } finally {
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+  }
+}
+
+function normalizePatchHeaders(patchText: string, relativePath: string): string {
+  const lines = patchText.split("\n");
+  const out: string[] = [];
+  let headerReplaced = 0;
+
+  for (const line of lines) {
+    if (line.startsWith("diff --git ")) {
+      out.push(`diff --git a/${relativePath} b/${relativePath}`);
+      continue;
+    }
+    if (line.startsWith("--- ") && headerReplaced === 0) {
+      out.push(`--- a/${relativePath}`);
+      headerReplaced += 1;
+      continue;
+    }
+    if (line.startsWith("+++ ") && headerReplaced === 1) {
+      out.push(`+++ b/${relativePath}`);
+      headerReplaced += 1;
+      continue;
+    }
+    out.push(line);
+  }
+
+  return out.join("\n");
+}

package/src/core/pipeline.ts

@@ -0,0 +1,107 @@
+import fs from "node:fs";
+import path from "node:path";
+import type { Manifest, ManifestStep, PipelineReport, StepResult, WorkspaceContext } from "../contracts/types.js";
+import { getOpHandler, type BinaryCopy } from "../ops/handlers.js";
+import { TextFileStore } from "../ops/fileStore.js";
+import { generatePatchForFile } from "./patch.js";
+
+function stepPlatform(step: ManifestStep): "android" | "ios" | "all" {
+  return step.platform ?? "all";
+}
+
+function shouldRunStep(ctx: WorkspaceContext, step: ManifestStep): { run: boolean; reason?: string } {
+  const pf = stepPlatform(step);
+  if (pf === "all") return { run: true };
+  if (pf === "android") {
+    if (!ctx.android?.ok) return { run: false, reason: "android not detected" };
+    return { run: true };
+  }
+  if (pf === "ios") {
+    if (!ctx.ios?.ok) return { run: false, reason: "ios not detected" };
+    return { run: true };
+  }
+  return { run: true };
+}
+
+export interface RunPipelineOptions {
+  dryRun: boolean;
+}
+
+export interface RunPipelineResult {
+  report: PipelineReport;
+  patch: string;
+  binaryCopies: BinaryCopy[];
+}
+
+function applyBinaryCopies(projectRoot: string, copies: BinaryCopy[]): void {
+  for (const c of copies) {
+    const dest = path.join(projectRoot, c.relTo);
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    if (fs.statSync(c.fromAbs).isDirectory()) {
+      fs.cpSync(c.fromAbs, dest, { recursive: true });
+    } else {
+      fs.copyFileSync(c.fromAbs, dest);
+    }
+  }
+}
+
+export async function runPipeline(
+  ctx: WorkspaceContext,
+  manifest: Manifest,
+  options: RunPipelineOptions
+): Promise<RunPipelineResult> {
+  const results: StepResult[] = [];
+  const warnings: string[] = [];
+  const errors: string[] = [];
+  let stepsRun = 0;
+  let stepsSkipped = 0;
+
+  const store = new TextFileStore(ctx.projectRoot);
+  const binaryCopies: BinaryCopy[] = [];
+
+  for (const step of manifest.steps) {
+    const decision = shouldRunStep(ctx, step);
+    if (!decision.run) {
+      stepsSkipped += 1;
+      warnings.push(`skipped op=${step.op}: ${decision.reason ?? "platform mismatch"}`);
+      continue;
+    }
+    const handler = getOpHandler(step.op);
+    if (!handler) {
+      const r: StepResult = { ok: false, changedFiles: [], warnings: [], errors: [`unknown op: ${step.op}`] };
+      results.push(r);
+      errors.push(...r.errors);
+      break;
+    }
+    const r = await Promise.resolve(handler(ctx, store, step.args ?? {}, options.dryRun, binaryCopies));
+    results.push(r);
+    stepsRun += 1;
+    warnings.push(...r.warnings);
+    if (!r.ok) {
+      errors.push(...r.errors);
+      break;
+    }
+  }
+
+  const patchParts: string[] = [];
+  for (const { rel, original, current } of store.changedEntries()) {
+    patchParts.push(generatePatchForFile(rel, original, current));
+  }
+
+  if (!options.dryRun && errors.length === 0) {
+    store.flushToDisk();
+    applyBinaryCopies(ctx.projectRoot, binaryCopies);
+  }
+
+  const report: PipelineReport = {
+    dryRun: options.dryRun,
+    projectRoot: ctx.projectRoot,
+    stepsRun,
+    stepsSkipped,
+    results,
+    warnings,
+    errors,
+  };
+
+  return { report, patch: patchParts.filter(Boolean).join("\n"), binaryCopies };
+}