@leonxin/meetgames 0.1.8 → 0.1.11

package/src/cli.ts

@@ -0,0 +1,488 @@
+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,
+  writeDownloadSdkConfigRaw,
+} from "./config/fetchConfigWrite.js";
+import {
+  MEETSDK_REMOTE_CONFIG_FILENAME,
+  readMeetSdkRemoteChannel,
+  tryParseAsMeetSdkRemoteConfig,
+  type MeetSdkRemoteConfig,
+} from "./config/meetSdkRemoteConfig.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;
+  iosSdkOutputDir: string;
+}
+
+function printHelp(): void {
+  console.log(`
+meetgames — Android-first integration CLI (TypeScript)
+
+Usage:
+  meetgames integrate [--project-root <path>] [--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] [--output-dir <path>] [--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 to <project-root>/meetsdk-remote-config.json.
+  - setup runs fetch-config then integrate in one process (same flags as both subcommands).
+  - doctor / setup / integrate require --project-root and auto-select exactly one platform from that root.
+  - doctor first fetches downloadSDKConfig to <project-root>/meetsdk-remote-config.json, then validates the detected platform integration.
+  - integrate uses recipes/integrate-default.yaml, filtered to the detected platform before execution.
+  - iOS SDK is read from bundled/ios-sdk/ in the tool package (native iOS only).
+  - Android integrate/doctor reads the latest SDK version from sdk-home and stores it in meetsdk-android.json.
+  - download-ios-sdk calls sdk-home getDownLoadUrl, saves the iOS SDK zip under bundled/ios-sdk/, extracts it there, and stores the resolved version in meetsdk-ios.json.
+  - 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 <project-root>/meetsdk-remote-config.json.
+  - fetch-config requires --channel-type (or channel in local meetsdk-remote-config.json / TOPSDK_CHANNEL_TYPE); not inferred from Android/iOS detection.
+  - Recipe op gradle.applyMeetSdkRemoteConfig reads 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 override; default reads topsdk.appId from meetsdk-remote-config.json
+  --app-secret          fetch-config: required appSecret for downloadSDKConfig sign (or env TOPSDK_APP_SECRET)
+  --channel-type        fetch-config: channelType query param for downloadSDKConfig (required unless channel in local file or 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
+  --output-dir          download-ios-sdk: 解压目标目录；默认 <package-root>/bundled/ios-sdk
+  --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>/test-projects/_preview/, 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: "",
+    iosSdkOutputDir: "",
+  };
+  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 === "--output-dir") {
+      out.iosSdkOutputDir = path.resolve(rest[i + 1] ?? "");
+      if (!out.iosSdkOutputDir || rest[i + 1]?.startsWith("-")) fail("--output-dir requires a directory path", 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 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,
+  });
+  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);
+}
+
+/** 固定缓存路径：宿主工程根目录下的 meetsdk-remote-config.json */
+function meetSdkRemoteConfigCachePath(projectRoot: string): string {
+  return path.join(projectRoot, MEETSDK_REMOTE_CONFIG_FILENAME);
+}
+
+function readLocalMeetSdkRemoteConfig(projectRoot: string): MeetSdkRemoteConfig | null {
+  const configPath = meetSdkRemoteConfigCachePath(projectRoot);
+  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 out = meetSdkRemoteConfigCachePath(parsed.projectRoot);
+  const localConfig = readLocalMeetSdkRemoteConfig(parsed.projectRoot);
+
+  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}`);
+  }
+
+  writeDownloadSdkConfigRaw(out, rawText);
+  console.log(`[meetgames] wrote ${MEETSDK_REMOTE_CONFIG_FILENAME} (downloadSDKConfig response, unmodified): ${out}`);
+  if (parsed.verbose) {
+    console.log(`[meetgames] GET ${requestUrl}`);
+  }
+}
+
+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> {
+  selectedPlatformContext(parsed);
+  console.log("[meetgames] setup: fetching remote config…");
+  await cmdFetchConfig(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,
+      outputDir: parsed.iosSdkOutputDir || undefined,
+    });
+  } 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] updated iOS SDK config: ${result.iosConfigPath}`);
+  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");
+}

package/src/config/loadAndroidIntegration.ts

@@ -0,0 +1,41 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import type { ErrorObject } from "ajv";
+import type { AndroidIntegrationDocument } from "../contracts/types.js";
+
+const require = createRequire(import.meta.url);
+const Ajv: typeof import("ajv").default = require("ajv") as typeof import("ajv").default;
+const addFormats = require("ajv-formats") as (ajv: import("ajv").default) => import("ajv").default;
+
+const ajv = new Ajv({ allErrors: true, strict: true });
+addFormats(ajv);
+
+let validateCached: ReturnType<typeof ajv.compile<AndroidIntegrationDocument>> | undefined;
+
+function getValidator() {
+  if (validateCached) return validateCached;
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  const schemaPath = path.join(here, "..", "..", "schema", "android-integration.schema.json");
+  const raw = JSON.parse(fs.readFileSync(schemaPath, "utf8")) as object;
+  validateCached = ajv.compile<AndroidIntegrationDocument>(raw);
+  return validateCached;
+}
+
+export function parseAndroidIntegrationJson(data: unknown): AndroidIntegrationDocument {
+  const validate = getValidator();
+  if (!validate(data)) {
+    const msg =
+      validate.errors?.map((e: ErrorObject) => `${e.instancePath} ${e.message}`).join("; ") ||
+      "invalid android integration json";
+    throw new Error(`Android integration validation failed: ${msg}`);
+  }
+  return data as AndroidIntegrationDocument;
+}
+
+export function loadAndroidIntegrationFile(filePath: string): AndroidIntegrationDocument {
+  const text = fs.readFileSync(filePath, "utf8");
+  const data: unknown = JSON.parse(text);
+  return parseAndroidIntegrationJson(data);
+}

package/src/config/loadManifest.ts

@@ -0,0 +1,40 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import type { ErrorObject } from "ajv";
+import yaml from "js-yaml";
+import type { Manifest } from "../contracts/types.js";
+
+const require = createRequire(import.meta.url);
+const Ajv: typeof import("ajv").default = require("ajv") as typeof import("ajv").default;
+const addFormats = require("ajv-formats") as (ajv: import("ajv").default) => import("ajv").default;
+
+const ajv = new Ajv({ allErrors: true, strict: true });
+addFormats(ajv);
+
+let validateCached: ReturnType<typeof ajv.compile<Manifest>> | undefined;
+
+function getValidator() {
+  if (validateCached) return validateCached;
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  const schemaPath = path.join(here, "..", "..", "schema", "manifest.schema.json");
+  const raw = JSON.parse(fs.readFileSync(schemaPath, "utf8")) as object;
+  validateCached = ajv.compile<Manifest>(raw);
+  return validateCached;
+}
+
+export function loadManifestFile(filePath: string): Manifest {
+  const text = fs.readFileSync(filePath, "utf8");
+  const ext = path.extname(filePath).toLowerCase();
+  const data: unknown =
+    ext === ".yaml" || ext === ".yml" ? yaml.load(text) : JSON.parse(text);
+  const validate = getValidator();
+  if (!validate(data)) {
+    const msg =
+      validate.errors?.map((e: ErrorObject) => `${e.instancePath} ${e.message}`).join("; ") ||
+      "invalid manifest";
+    throw new Error(`Manifest validation failed: ${msg}`);
+  }
+  return data as Manifest;
+}