@leonxin/meetgames 0.1.8 → 0.1.12

package/src/cache.ts

@@ -0,0 +1,164 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { MEETSDK_REMOTE_CONFIG_FILENAME } from "./config/meetSdkRemoteConfig.js";
+
+export const MEET_SDK_TOOL_CACHE_ROOT = path.join(os.homedir(), ".cache", "meet-sdk-tool");
+
+function iosSdkZipFileName(version: string): string {
+  return `topSDK-ios--V${version}.zip`;
+}
+
+function safeSegment(value: string): string {
+  const cleaned = value.trim().replace(/[^a-zA-Z0-9._-]+/g, "_").replace(/^_+|_+$/g, "");
+  return cleaned || "unknown";
+}
+
+function sha256Hex(value: string, length = 16): string {
+  return crypto.createHash("sha256").update(value).digest("hex").slice(0, length);
+}
+
+function writeFileAtomic(absPath: string, content: string | Buffer): void {
+  ensureCacheRoot();
+  fs.mkdirSync(path.dirname(absPath), { recursive: true });
+  const tmp = path.join(path.dirname(absPath), `.${path.basename(absPath)}.${process.pid}.${Date.now()}.tmp`);
+  fs.writeFileSync(tmp, content);
+  fs.renameSync(tmp, absPath);
+}
+
+export function ensureCacheRoot(): string {
+  fs.mkdirSync(MEET_SDK_TOOL_CACHE_ROOT, { recursive: true, mode: 0o700 });
+  try {
+    fs.chmodSync(MEET_SDK_TOOL_CACHE_ROOT, 0o700);
+  } catch {
+    // Best-effort on filesystems that do not support POSIX modes.
+  }
+  return MEET_SDK_TOOL_CACHE_ROOT;
+}
+
+export function resolveRemoteConfigCachePath(params: {
+  env: string;
+  appId: string;
+  channelType: string;
+}): string {
+  return path.join(
+    MEET_SDK_TOOL_CACHE_ROOT,
+    "configs",
+    safeSegment(params.env),
+    safeSegment(params.appId),
+    safeSegment(params.channelType),
+    MEETSDK_REMOTE_CONFIG_FILENAME
+  );
+}
+
+export function writeRemoteConfigCache(params: {
+  env: string;
+  appId: string;
+  channelType: string;
+  requestUrl: string;
+  rawText: string;
+  warnings?: readonly string[];
+}): { configPath: string; metadataPath: string } {
+  const fetchedAt = new Date().toISOString();
+  const metadata = `${JSON.stringify(
+    {
+      fetchedAt,
+      env: params.env,
+      appId: params.appId,
+      channelType: params.channelType,
+      requestUrl: params.requestUrl,
+      sha256: crypto.createHash("sha256").update(params.rawText).digest("hex"),
+      warnings: params.warnings ?? [],
+    },
+    null,
+    2
+  )}\n`;
+  const configPath = resolveRemoteConfigCachePath(params);
+  const metadataPath = path.join(path.dirname(configPath), "metadata.json");
+
+  writeFileAtomic(configPath, params.rawText);
+  writeFileAtomic(metadataPath, metadata);
+
+  return { configPath, metadataPath };
+}
+
+function pluginsHash(plugins: readonly string[]): string {
+  return sha256Hex(plugins.join(","), 12);
+}
+
+export function resolveIosSdkCacheLayout(params: {
+  version: string;
+  packageType: string;
+  plugins: readonly string[];
+}): { baseDir: string; zipPath: string; extractDir: string; metadataPath: string; lockDir: string } {
+  const baseDir = path.join(
+    MEET_SDK_TOOL_CACHE_ROOT,
+    "sdk",
+    "ios",
+    safeSegment(params.packageType),
+    safeSegment(params.version),
+    pluginsHash(params.plugins)
+  );
+  return {
+    baseDir,
+    zipPath: path.join(baseDir, iosSdkZipFileName(params.version)),
+    extractDir: path.join(baseDir, "extracted"),
+    metadataPath: path.join(baseDir, "metadata.json"),
+    lockDir: path.join(baseDir, ".lock"),
+  };
+}
+
+export function writeIosSdkCacheMetadata(params: {
+  metadataPath: string;
+  version: string;
+  date?: string;
+  packageType: string;
+  plugins: readonly string[];
+  versionUrl: string;
+  downloadApiUrl: string;
+  sdkZipUrl: string;
+  zipPath: string;
+  extractDir: string;
+  resolvedSdkRoot: string;
+}): void {
+  const zipSha256 = fs.existsSync(params.zipPath)
+    ? crypto.createHash("sha256").update(fs.readFileSync(params.zipPath)).digest("hex")
+    : "";
+  writeFileAtomic(
+    params.metadataPath,
+    `${JSON.stringify(
+      {
+        fetchedAt: new Date().toISOString(),
+        version: params.version,
+        date: params.date,
+        packageType: params.packageType,
+        plugins: params.plugins,
+        versionUrl: params.versionUrl,
+        downloadApiUrl: params.downloadApiUrl,
+        sdkZipUrl: params.sdkZipUrl,
+        zipPath: params.zipPath,
+        extractDir: params.extractDir,
+        resolvedSdkRoot: params.resolvedSdkRoot,
+        zipSha256,
+      },
+      null,
+      2
+    )}\n`
+  );
+}
+
+export function withCacheLock<T>(lockDir: string, fn: () => Promise<T>): Promise<T> {
+  fs.mkdirSync(path.dirname(lockDir), { recursive: true });
+  try {
+    fs.mkdirSync(lockDir);
+  } catch (e) {
+    if ((e as NodeJS.ErrnoException).code === "EEXIST") {
+      throw new Error(`cache path is locked by another meet-sdk-tool process: ${lockDir}`);
+    }
+    throw e;
+  }
+  return fn().finally(() => {
+    fs.rmSync(lockDir, { recursive: true, force: true });
+  });
+}

package/src/cli.ts

@@ -0,0 +1,496 @@
+import fs from "node:fs";
+import path from "node:path";
+import { loadManifestFile } from "./config/loadManifest.js";
+import { buildWorkspaceContext, resolvePackageRoot } from "./core/workspace.js";
+import { runPipeline } from "./core/pipeline.js";
+import {
+  detectSinglePlatform,
+  manifestForPlatform,
+  platformContext,
+} from "./core/platform.js";
+import { runDoctor } from "./core/doctor.js";
+import { clearPreviewPatchFilesIfTargetInside } from "./core/previewPatches.js";
+import { printReport } from "./core/reporter.js";
+import { defaultTopSdkBaseUrl, fetchTopSdkDownloadSdkConfig, type TopSdkApiEnv } from "./remote/topsdkDownloadSdkConfig.js";
+import {
+  defaultSdkHomeApiBaseUrl,
+  downloadIosSdkToBundled,
+  DEFAULT_IOS_SDK_PACKAGE_TYPE,
+} from "./remote/sdkHomeDownload.js";
+import type { Manifest } from "./contracts/types.js";
+import {
+  validateDownloadSdkConfigForWrite,
+} from "./config/fetchConfigWrite.js";
+import {
+  MEETSDK_REMOTE_CONFIG_FILENAME,
+  readMeetSdkRemoteChannel,
+  tryParseAsMeetSdkRemoteConfig,
+  type MeetSdkRemoteConfig,
+} from "./config/meetSdkRemoteConfig.js";
+import {
+  MEET_SDK_TOOL_CACHE_ROOT,
+  resolveRemoteConfigCachePath,
+  writeRemoteConfigCache,
+} from "./cache.js";
+
+const EXIT = {
+  OK: 0,
+  INVALID_ARGS: 2,
+  PROJECT_ERROR: 3,
+  CONFIG_ERROR: 4,
+  PIPELINE_ERROR: 5,
+  NETWORK_ERROR: 6,
+} as const;
+
+function fail(message: string, code: number): never {
+  console.error(`[meetgames] ERROR: ${message}`);
+  process.exit(code);
+}
+
+interface Parsed {
+  command: string;
+  projectRoot: string;
+  projectRootProvided: boolean;
+  dryRun: boolean;
+  verbose: boolean;
+  reportFile: string;
+  patchFile: string;
+  help: boolean;
+  topsdkEnv: TopSdkApiEnv;
+  topsdkAppId: string;
+  topsdkAppSecret: string;
+  topsdkChannelType: string;
+  topsdkPackageName: string;
+  appTarget: string;
+  sdkHomeApiBaseUrl: string;
+  iosSdkVersion: string;
+  iosSdkPlugins: string;
+  iosSdkPackageType: string;
+}
+
+function printHelp(): void {
+  console.log(`
+meetgames — Android-first integration CLI (TypeScript)
+
+Usage:
+  meetgames integrate [--project-root <path>] [--app-id ID] [--channel-type TYPE] [--env prod|pre|test] [--app-target <target>] [--dry-run] [--verbose] [--patch-file <path>]
+  meetgames fetch-config [--app-id ID] [--app-secret SECRET] [--channel-type TYPE] [--env prod|pre|test] [--project-root <path>] [--verbose]
+  meetgames download-ios-sdk [--version VERSION] [--plugins csv] [--package-type native|unity|cocos] [--sdk-api-base-url URL] [--verbose]
+  meetgames setup [--app-id ID] [--app-secret SECRET] [--channel-type TYPE] [--env prod|pre|test] [--project-root <path>] [--app-target <target>] [--dry-run] [--verbose] [--patch-file <path>]
+  meetgames doctor [--app-id ID] [--app-secret SECRET] [--channel-type TYPE] [--env prod|pre|test] --project-root <path> [--app-target <target>] [--verbose]
+
+Notes:
+  - Source code is TypeScript only; published bin runs compiled output under dist/.
+  - iOS: copies frameworks to topSDK/, edits project.pbxproj & Info.plist, injects AppDelegate (.m/.mm) when present (topsdk-tool-ios parity).
+  - fetch-config calls TOPSDK downloadSDKConfig and writes the response body unchanged under ${MEET_SDK_TOOL_CACHE_ROOT}.
+  - setup runs fetch-config, then download-ios-sdk for iOS projects, then integrate in one process.
+  - doctor / setup / integrate require --project-root and auto-select exactly one platform from that root.
+  - doctor first fetches downloadSDKConfig to the cache, then validates the detected platform integration.
+  - integrate uses recipes/integrate-default.yaml, filtered to the detected platform before execution.
+  - iOS SDK is read from ${MEET_SDK_TOOL_CACHE_ROOT}/sdk/ios/.
+  - Android integrate/doctor reads the latest SDK version from sdk-home and stores it in config/meetsdk-android.json.
+  - download-ios-sdk calls sdk-home getDownLoadUrl, saves and extracts the iOS SDK under ${MEET_SDK_TOOL_CACHE_ROOT}/sdk/ios/.
+  - fetch-config requires --app-secret (or TOPSDK_APP_SECRET) to sign downloadSDKConfig; appSecret is never read from meetsdk-remote-config.json.
+  - When analytics.firebase is enabled, Android downloads google-services.json to the detected/selected app module; iOS downloads GoogleService-Info.plist next to Info.plist.
+  - fetch-config writes to ${MEET_SDK_TOOL_CACHE_ROOT}/configs/<env>/<appId>/<channelType>/meetsdk-remote-config.json.
+  - integrate/doctor read the cache entry selected by --env, --app-id, and --channel-type; without those flags they only read an existing project-root meetsdk-remote-config.json for compatibility.
+  - Recipe op gradle.applyMeetSdkRemoteConfig reads cached meetsdk-remote-config.json and writes TOPSDK marker blocks to root + app build.gradle (same idea as sdk-integration-agent gradleEditor).
+
+Options (global where noted):
+  --project-root        Host project directory (default: cwd); for iOS it may point to the project root or directly to a .xcodeproj directory
+  --app-target          App target to integrate/check: Android application Gradle module (e.g. :app or launcher) or iOS App target name
+  --app-id              fetch-config/integrate/doctor cache selector; default TOPSDK_APP_ID
+  --app-secret          fetch-config: required appSecret for downloadSDKConfig sign (or env TOPSDK_APP_SECRET)
+  --channel-type        fetch-config/integrate/doctor cache selector; default TOPSDK_CHANNEL_TYPE
+  --env                 fetch-config: prod（正式服，默认）| pre | test（开发调试）
+  TOPSDK_API_BASE_URL   fetch-config: 覆盖 API 根地址（如 http://localhost:18080/ 联调本机 console）
+  MEETGAMES_SDK_HOME_API_BASE_URL  覆盖 sdk-home API 根地址（默认 https://business-api.meetgames.com）；用于 Android 最新版本查询和 iOS SDK 下载
+  --sdk-api-base-url    sdk-home API 根地址；用于 Android 最新版本查询和 iOS SDK 下载
+  --version             download-ios-sdk: 指定 iOS SDK 版本；不传时从 /sdk/home/version 读取最新 iOS 版本
+  --plugins             download-ios-sdk: 逗号分隔插件列表；默认与下载页 iOS 默认选择一致
+  --package-type        download-ios-sdk: native（默认）| unity | cocos
+  --dry-run             integrate: compute changes and patch preview without writing host project files (default is write to disk)
+  --report-file         Write JSON report to path
+  --patch-file          integrate: write unified diff to this path (works with --dry-run). If under <pkg>/preview-patches/, all existing files in that dir are removed first so only the latest patch remains.
+  --verbose             Verbose logs and full patch preview
+
+Subcommand notes:
+  - integrate defaults to writing files; use --dry-run for CI preview / diff-only.
+  - setup: step 1 always writes meetsdk-remote-config.json; step 2 honors --dry-run / --patch-file / --report-file.
+  - fetch-config ignores --dry-run, --report-file, --patch-file (shared parser only).
+`);
+}
+
+function parseArgv(argv: string[]): Parsed {
+  const out: Parsed = {
+    command: "",
+    projectRoot: process.cwd(),
+    projectRootProvided: false,
+    dryRun: false,
+    verbose: false,
+    reportFile: "",
+    patchFile: "",
+    help: false,
+    topsdkEnv: "prod",
+    topsdkAppId: "",
+    topsdkAppSecret: "",
+    topsdkChannelType: "",
+    topsdkPackageName: "",
+    appTarget: "",
+    sdkHomeApiBaseUrl: "",
+    iosSdkVersion: "",
+    iosSdkPlugins: "",
+    iosSdkPackageType: "",
+  };
+  const rest = argv.slice(2);
+  if (!rest.length || (rest[0]?.startsWith("-") ?? false)) {
+    out.help = true;
+    return out;
+  }
+  out.command = rest[0] ?? "";
+  for (let i = 1; i < rest.length; i += 1) {
+    const t = rest[i];
+    if (t === "--help" || t === "-h") {
+      out.help = true;
+      return out;
+    }
+    if (t === "--verbose") {
+      out.verbose = true;
+      continue;
+    }
+    if (t === "--dry-run") {
+      out.dryRun = true;
+      continue;
+    }
+    if (t === "--project-root") {
+      out.projectRoot = path.resolve(rest[i + 1] ?? "");
+      out.projectRootProvided = true;
+      i += 1;
+      continue;
+    }
+    if (t === "--app-target") {
+      out.appTarget = rest[i + 1] ?? "";
+      if (!out.appTarget || out.appTarget.startsWith("-")) fail("--app-target requires a target name", EXIT.INVALID_ARGS);
+      i += 1;
+      continue;
+    }
+    if (t === "--sdk-api-base-url") {
+      out.sdkHomeApiBaseUrl = rest[i + 1] ?? "";
+      if (!out.sdkHomeApiBaseUrl || out.sdkHomeApiBaseUrl.startsWith("-")) {
+        fail("--sdk-api-base-url requires a URL", EXIT.INVALID_ARGS);
+      }
+      i += 1;
+      continue;
+    }
+    if (t === "--version") {
+      out.iosSdkVersion = rest[i + 1] ?? "";
+      if (!out.iosSdkVersion || out.iosSdkVersion.startsWith("-")) fail("--version requires a version", EXIT.INVALID_ARGS);
+      i += 1;
+      continue;
+    }
+    if (t === "--plugins") {
+      out.iosSdkPlugins = rest[i + 1] ?? "";
+      if (!out.iosSdkPlugins || out.iosSdkPlugins.startsWith("-")) fail("--plugins requires a comma-separated list", EXIT.INVALID_ARGS);
+      i += 1;
+      continue;
+    }
+    if (t === "--package-type") {
+      out.iosSdkPackageType = rest[i + 1] ?? "";
+      if (!out.iosSdkPackageType || out.iosSdkPackageType.startsWith("-")) {
+        fail("--package-type requires native, unity, or cocos", EXIT.INVALID_ARGS);
+      }
+      i += 1;
+      continue;
+    }
+    if (t === "--env") {
+      const v = (rest[i + 1] ?? "").toLowerCase();
+      i += 1;
+      if (v === "prod" || v === "pre" || v === "test") out.topsdkEnv = v;
+      else fail(`invalid --env (use prod, pre, or test): ${v}`, EXIT.INVALID_ARGS);
+      continue;
+    }
+    if (t === "--app-id") {
+      out.topsdkAppId = rest[i + 1] ?? "";
+      i += 1;
+      continue;
+    }
+    if (t === "--app-secret") {
+      out.topsdkAppSecret = rest[i + 1] ?? "";
+      i += 1;
+      continue;
+    }
+    if (t === "--channel-type") {
+      out.topsdkChannelType = rest[i + 1] ?? "";
+      i += 1;
+      continue;
+    }
+    if (t === "--report-file") {
+      out.reportFile = path.resolve(rest[i + 1] ?? "");
+      i += 1;
+      continue;
+    }
+    if (t === "--patch-file") {
+      out.patchFile = path.resolve(rest[i + 1] ?? "");
+      i += 1;
+      continue;
+    }
+    fail(`unsupported argument: ${t}`, EXIT.INVALID_ARGS);
+  }
+  return out;
+}
+
+const DEFAULT_MANIFEST = "recipes/integrate-default.yaml";
+
+function requiresProjectRoot(command: string): boolean {
+  return command === "doctor" || command === "setup" || command === "integrate";
+}
+
+function resolvedAppTarget(parsed: Parsed): string {
+  return parsed.appTarget;
+}
+
+function cachedRemoteConfigPathFromArgs(parsed: Parsed): string {
+  const appId = parsed.topsdkAppId || process.env.TOPSDK_APP_ID || "";
+  const channelType = parsed.topsdkChannelType || process.env.TOPSDK_CHANNEL_TYPE || "";
+  if (!appId || !channelType) return "";
+  return resolveRemoteConfigCachePath({ env: parsed.topsdkEnv, appId, channelType });
+}
+
+function selectedPlatformContext(parsed: Parsed): {
+  platform: "android" | "ios";
+  ctx: ReturnType<typeof buildWorkspaceContext>;
+  selectedCtx: ReturnType<typeof buildWorkspaceContext>;
+} {
+  const ctx = buildWorkspaceContext(parsed.projectRoot, resolvePackageRoot(), {
+    appTarget: resolvedAppTarget(parsed),
+    sdkHomeApiBaseUrl: parsed.sdkHomeApiBaseUrl || undefined,
+    remoteConfigPath: cachedRemoteConfigPathFromArgs(parsed) || undefined,
+  });
+  const detected = detectSinglePlatform(ctx);
+  if (!detected.ok) fail(detected.error, EXIT.PROJECT_ERROR);
+  return {
+    platform: detected.platform,
+    ctx,
+    selectedCtx: platformContext(ctx, detected.platform),
+  };
+}
+
+async function cmdDoctor(parsed: Parsed): Promise<void> {
+  const { platform, selectedCtx } = selectedPlatformContext(parsed);
+  console.log("[meetgames] doctor: fetching remote config…");
+  await cmdFetchConfig(parsed);
+  console.log("[meetgames] doctor: checking project integration…");
+  const report = await runDoctor(selectedCtx, platform);
+  console.log(JSON.stringify(report, null, 2));
+  if (!report.ok) process.exit(EXIT.CONFIG_ERROR);
+}
+
+function readLocalMeetSdkRemoteConfig(configPath: string): MeetSdkRemoteConfig | null {
+  if (!fs.existsSync(configPath)) return null;
+  try {
+    return tryParseAsMeetSdkRemoteConfig(JSON.parse(fs.readFileSync(configPath, "utf8")) as unknown);
+  } catch {
+    return null;
+  }
+}
+
+async function cmdFetchConfig(parsed: Parsed): Promise<void> {
+  const selectedConfigPath = cachedRemoteConfigPathFromArgs(parsed);
+  const localConfig = selectedConfigPath ? readLocalMeetSdkRemoteConfig(selectedConfigPath) : null;
+
+  const appId = parsed.topsdkAppId || localConfig?.topsdk.appId || process.env.TOPSDK_APP_ID || "";
+  const appSecret = parsed.topsdkAppSecret || process.env.TOPSDK_APP_SECRET || "";
+  const channelType =
+    parsed.topsdkChannelType ||
+    (localConfig ? readMeetSdkRemoteChannel(localConfig) : "") ||
+    process.env.TOPSDK_CHANNEL_TYPE ||
+    "";
+
+  if (!appId || !channelType || !appSecret) {
+    fail(
+      `fetch-config requires --app-id, --app-secret, and --channel-type (or TOPSDK_APP_ID / TOPSDK_APP_SECRET / TOPSDK_CHANNEL_TYPE; appSecret is not read from ${MEETSDK_REMOTE_CONFIG_FILENAME}).`,
+      EXIT.INVALID_ARGS
+    );
+  }
+
+  const baseUrl = process.env.TOPSDK_API_BASE_URL?.trim() || defaultTopSdkBaseUrl(parsed.topsdkEnv);
+
+  let body: unknown;
+  let requestUrl: string;
+  let rawText: string;
+  try {
+    const res = await fetchTopSdkDownloadSdkConfig({
+      baseUrl,
+      appId,
+      appSecret,
+      channelType,
+    });
+    body = res.body;
+    requestUrl = res.url;
+    rawText = res.text;
+  } catch (e) {
+    fail(e instanceof Error ? e.message : String(e), EXIT.NETWORK_ERROR);
+  }
+
+  const validation = validateDownloadSdkConfigForWrite(body);
+  if (!validation) {
+    fail(
+      `downloadSDKConfig response is not a valid ${MEETSDK_REMOTE_CONFIG_FILENAME} document (GET ${requestUrl})`,
+      EXIT.CONFIG_ERROR
+    );
+  }
+
+  for (const warning of validation.warnings) {
+    console.warn(`[meetgames] warning: ${warning}`);
+  }
+
+  const written = writeRemoteConfigCache({
+    env: parsed.topsdkEnv,
+    appId,
+    channelType,
+    requestUrl,
+    rawText,
+    warnings: validation.warnings,
+  });
+  console.log(`[meetgames] wrote ${MEETSDK_REMOTE_CONFIG_FILENAME} (downloadSDKConfig response, unmodified): ${written.configPath}`);
+  if (parsed.verbose) {
+    console.log(`[meetgames] GET ${requestUrl}`);
+    console.log(`[meetgames] metadata: ${written.metadataPath}`);
+  }
+}
+
+async function cmdIntegrate(parsed: Parsed): Promise<void> {
+  const manifestPath = path.join(resolvePackageRoot(), DEFAULT_MANIFEST);
+  if (!fs.existsSync(manifestPath)) {
+    fail(`config file not found: ${manifestPath}`, EXIT.PROJECT_ERROR);
+  }
+
+  let manifest: Manifest;
+  try {
+    manifest = loadManifestFile(manifestPath);
+  } catch (e) {
+    fail(e instanceof Error ? e.message : String(e), EXIT.CONFIG_ERROR);
+  }
+
+  const { platform, ctx, selectedCtx } = selectedPlatformContext(parsed);
+  const selectedManifest = manifestForPlatform(manifest, platform);
+  const { report, patch, binaryCopies } = await runPipeline(selectedCtx, selectedManifest, { dryRun: parsed.dryRun });
+  printReport(report, patch, parsed.verbose);
+  if (binaryCopies.length) {
+    console.log("[meetgames] planned binary copies:");
+    for (const c of binaryCopies) {
+      console.log(`  ${c.fromAbs} -> ${path.join(ctx.projectRoot, c.relTo)}`);
+    }
+  }
+
+  if (parsed.reportFile) {
+    fs.mkdirSync(path.dirname(parsed.reportFile), { recursive: true });
+    fs.writeFileSync(parsed.reportFile, JSON.stringify({ ...report, binaryCopies }, null, 2), "utf8");
+  }
+  if (parsed.patchFile) {
+    const patchAbs = path.resolve(parsed.patchFile);
+    clearPreviewPatchFilesIfTargetInside(resolvePackageRoot(), patchAbs);
+    fs.mkdirSync(path.dirname(patchAbs), { recursive: true });
+    fs.writeFileSync(patchAbs, patch || "# no text changes\n", "utf8");
+    console.log(`[meetgames] wrote patch file: ${patchAbs}`);
+  }
+
+  if (report.errors.length) {
+    process.exit(EXIT.PIPELINE_ERROR);
+  }
+}
+
+async function cmdSetup(parsed: Parsed): Promise<void> {
+  const { platform } = selectedPlatformContext(parsed);
+  console.log("[meetgames] setup: fetching remote config…");
+  await cmdFetchConfig(parsed);
+  if (platform === "ios") {
+    console.log("[meetgames] setup: downloading iOS SDK…");
+    await cmdDownloadIosSdk(parsed);
+  }
+  console.log("[meetgames] setup: integrating project…");
+  await cmdIntegrate(parsed);
+}
+
+async function cmdDownloadIosSdk(parsed: Parsed): Promise<void> {
+  const baseUrl =
+    parsed.sdkHomeApiBaseUrl || process.env.MEETGAMES_SDK_HOME_API_BASE_URL?.trim() || defaultSdkHomeApiBaseUrl;
+  const packageType = parsed.iosSdkPackageType || DEFAULT_IOS_SDK_PACKAGE_TYPE;
+  if (!["native", "unity", "cocos"].includes(packageType)) {
+    fail(`invalid --package-type (use native, unity, or cocos): ${packageType}`, EXIT.INVALID_ARGS);
+  }
+  const plugins = parsed.iosSdkPlugins
+    ? parsed.iosSdkPlugins
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean)
+    : undefined;
+  if (parsed.iosSdkPlugins && !plugins?.length) {
+    fail("--plugins must contain at least one plugin", EXIT.INVALID_ARGS);
+  }
+
+  console.log("[meetgames] download-ios-sdk: resolving sdk-home iOS SDK…");
+  let result;
+  try {
+    result = await downloadIosSdkToBundled(resolvePackageRoot(), {
+      baseUrl,
+      version: parsed.iosSdkVersion || undefined,
+      plugins,
+      packageType,
+    });
+  } catch (e) {
+    fail(e instanceof Error ? e.message : String(e), EXIT.NETWORK_ERROR);
+  }
+
+  console.log(`[meetgames] downloaded iOS SDK ${result.version} zip: ${result.zipPath}`);
+  console.log(`[meetgames] extracted iOS SDK to: ${result.extractDir}`);
+  console.log(`[meetgames] resolved iOS SDK root: ${result.resolvedSdkRoot}`);
+  console.log(`[meetgames] wrote iOS SDK metadata: ${result.cacheMetadataPath}`);
+  if (parsed.verbose) {
+    console.log(`[meetgames] GET ${result.versionUrl}`);
+    console.log(`[meetgames] GET ${result.downloadApiUrl}`);
+    console.log(`[meetgames] SDK zip URL: ${result.sdkZipUrl}`);
+  }
+}
+
+export async function main(): Promise<void> {
+  const parsed = parseArgv(process.argv);
+  if (parsed.help) {
+    printHelp();
+    process.exit(EXIT.OK);
+  }
+  if (!parsed.command) {
+    printHelp();
+    process.exit(EXIT.INVALID_ARGS);
+  }
+  if (requiresProjectRoot(parsed.command) && !parsed.projectRootProvided) {
+    fail(`${parsed.command} requires --project-root`, EXIT.INVALID_ARGS);
+  }
+  if (!fs.existsSync(parsed.projectRoot) || !fs.statSync(parsed.projectRoot).isDirectory()) {
+    fail("project root does not exist or is not a directory", EXIT.INVALID_ARGS);
+  }
+  if (parsed.appTarget && !["doctor", "setup", "integrate"].includes(parsed.command)) {
+    fail("--app-target is only supported by doctor, setup, and integrate", EXIT.INVALID_ARGS);
+  }
+  resolvedAppTarget(parsed);
+
+  switch (parsed.command) {
+    case "doctor":
+      await cmdDoctor(parsed);
+      break;
+    case "integrate":
+      await cmdIntegrate(parsed);
+      break;
+    case "fetch-config":
+      await cmdFetchConfig(parsed);
+      break;
+    case "download-ios-sdk":
+      await cmdDownloadIosSdk(parsed);
+      break;
+    case "setup":
+      await cmdSetup(parsed);
+      break;
+    default:
+      fail(`unknown command: ${parsed.command}`, EXIT.INVALID_ARGS);
+  }
+}

package/src/config/fetchConfigWrite.ts

@@ -0,0 +1,30 @@
+import fs from "node:fs";
+import path from "node:path";
+import {
+  tryParseAsMeetSdkRemoteConfig,
+  validateMeetSdkRemoteConfig,
+  type MeetSdkRemoteConfig,
+} from "./meetSdkRemoteConfig.js";
+
+export interface FetchConfigWriteValidation {
+  parsed: MeetSdkRemoteConfig;
+  warnings: string[];
+}
+
+/** Shape check only; does not normalize or merge meetsdk-android.json. */
+export function validateDownloadSdkConfigForWrite(body: unknown): FetchConfigWriteValidation | null {
+  const parsed = tryParseAsMeetSdkRemoteConfig(body);
+  if (!parsed) return null;
+  const warnings: string[] = [];
+  const validation = validateMeetSdkRemoteConfig(parsed);
+  if (!validation.ok) {
+    warnings.push(`remote-config missing or empty fields: ${validation.missing.join(", ")}`);
+  }
+  return { parsed, warnings };
+}
+
+/** Write gp-sdk response bytes as-is (no normalize / no meetsdk-android merge). */
+export function writeDownloadSdkConfigRaw(outPath: string, rawText: string): void {
+  fs.mkdirSync(path.dirname(outPath), { recursive: true });
+  fs.writeFileSync(outPath, rawText, "utf8");
+}