@leonxin/meetgames 0.1.8 → 0.1.12

package/src/remote/topsdkDownloadSdkConfig.ts

@@ -0,0 +1,93 @@
+import { topsdkMd5Base64Sign } from "./topsdkSign.js";
+import { defaultTopSdkBaseUrl, type TopSdkApiEnv } from "./topsdkGetSdkConfig.js";
+
+export { defaultTopSdkBaseUrl, type TopSdkApiEnv };
+
+const DOWNLOAD_SDK_CONFIG_PATH = "console/openSDK/downloadSDKConfig";
+
+function joinBaseAndPath(baseUrl: string, path: string): URL {
+  const base = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+  return new URL(path, base);
+}
+
+/**
+ * GET `console/openSDK/downloadSDKConfig` — same sign as `getSDKConfig`:
+ * sign = base64(md5(appId + appSecret + timestampMillis)), timestamp within 60s.
+ */
+export function buildTopSdkDownloadSdkConfigUrl(params: {
+  baseUrl: string;
+  appId: string;
+  appSecret: string;
+  channelType: string;
+  timestampMillis?: number;
+}): { url: string; timestampMillis: number } {
+  const timestampMillis = params.timestampMillis ?? Date.now();
+  const sign = topsdkMd5Base64Sign(params.appId, params.appSecret, timestampMillis);
+  const u = joinBaseAndPath(params.baseUrl, DOWNLOAD_SDK_CONFIG_PATH);
+  u.searchParams.set("appId", params.appId);
+  u.searchParams.set("channelType", params.channelType);
+  u.searchParams.set("sign", sign);
+  u.searchParams.set("timestamp", String(timestampMillis));
+  return { url: u.toString(), timestampMillis };
+}
+
+function isRecord(v: unknown): v is Record<string, unknown> {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+
+/** gp-sdk error envelope when the handler throws before streaming JSON. */
+export function parseTopSdkApiErrorBody(body: unknown): string | null {
+  if (!isRecord(body)) return null;
+  const code = body.code;
+  if (code === undefined || code === null) return null;
+  if (Number(code) === 200) return null;
+  const message = typeof body.message === "string" ? body.message : typeof body.error === "string" ? body.error : JSON.stringify(body);
+  return `TOPSDK API error (code=${code}): ${message}`;
+}
+
+export async function fetchTopSdkDownloadSdkConfig(params: {
+  baseUrl: string;
+  appId: string;
+  appSecret: string;
+  channelType: string;
+  timestampMillis?: number;
+  signal?: AbortSignal;
+}): Promise<{ url: string; body: unknown; text: string }> {
+  const { url } = buildTopSdkDownloadSdkConfigUrl(params);
+  let res: Response;
+  try {
+    res = await fetch(url, {
+      redirect: "follow",
+      signal: params.signal,
+      headers: { Accept: "application/json" },
+    });
+  } catch (e) {
+    const cause = e instanceof Error && "cause" in e && e.cause instanceof Error ? e.cause.message : null;
+    const detail = cause && cause !== (e instanceof Error ? e.message : String(e)) ? ` (${cause})` : "";
+    throw new Error(`GET ${url} failed: ${e instanceof Error ? e.message : String(e)}${detail}`);
+  }
+  if (!res.ok) {
+    let detail = "";
+    try {
+      const text = await res.text();
+      if (text.trim()) {
+        detail = `: ${text.trim().slice(0, 1000)}`;
+      }
+    } catch {
+      // Keep the original status-only error if the response body cannot be read.
+    }
+    throw new Error(`GET ${url} failed: HTTP ${res.status}${detail}`);
+  }
+  const text = await res.text();
+  let body: unknown;
+  try {
+    body = JSON.parse(text) as unknown;
+  } catch {
+    throw new Error("Remote response is not valid JSON");
+  }
+  const apiErr = parseTopSdkApiErrorBody(body);
+  if (apiErr) {
+    throw new Error(apiErr);
+  }
+  return { url, body, text };
+}

package/src/remote/topsdkGetSdkConfig.ts

@@ -0,0 +1,122 @@
+import { fetchJsonGet } from "./fetchJson.js";
+import { topsdkMd5Base64Sign } from "./topsdkSign.js";
+
+/**
+ * Console API host by environment.
+ * - `prod`: 正式服（与文档 `api-sdk-gameplus.meetsocial.com` 一致）
+ * - `pre`: 预发
+ * - `test`: 测试服（开发调试使用）
+ */
+export type TopSdkApiEnv = "prod" | "pre" | "test";
+
+export function defaultTopSdkBaseUrl(env: TopSdkApiEnv): string {
+  if (env === "test") return "https://test-api-sdk-gameplus.meetsocial.com/";
+  if (env === "pre") return "https://pre-api-sdk-gameplus.meetsocial.com/";
+  return "https://api-sdk-gameplus.meetsocial.com/";
+}
+
+const SDK_CONFIG_PATH = "console/openSDK/getSDKConfig";
+
+function joinBaseAndPath(baseUrl: string, path: string): URL {
+  const base = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+  return new URL(path, base);
+}
+
+/**
+ * Same query semantics as topsdk-tool-ios `ChannelConfigManager.getSdkConfig` /
+ * topsdk-tool `config_utils.getSdkConfig`: GET `console/openSDK/getSDKConfig` with
+ * appId, authType (multi), channelType, sign, timestamp.
+ */
+export function buildTopSdkGetSdkConfigUrl(params: {
+  baseUrl: string;
+  appId: string;
+  appSecret: string;
+  authTypes: readonly string[];
+  channelType: string;
+  timestampMillis?: number;
+}): { url: string; timestampMillis: number } {
+  const timestampMillis = params.timestampMillis ?? Date.now();
+  const sign = topsdkMd5Base64Sign(params.appId, params.appSecret, timestampMillis);
+  const u = joinBaseAndPath(params.baseUrl, SDK_CONFIG_PATH);
+  u.searchParams.set("appId", params.appId);
+  for (const t of params.authTypes) {
+    u.searchParams.append("authType", t);
+  }
+  u.searchParams.set("channelType", params.channelType);
+  u.searchParams.set("sign", sign);
+  u.searchParams.set("timestamp", String(timestampMillis));
+  return { url: u.toString(), timestampMillis };
+}
+
+/** Strips auth types not sent to the API (same list as topsdk-tool-ios ChannelConfigManager). */
+export function filterTopSdkAuthTypesForRequest(authTypes: readonly string[]): string[] {
+  const skip = new Set(["GUEST", "UI", "IAPPAY"]);
+  return authTypes.map((t) => t.trim()).filter(Boolean).filter((t) => !skip.has(t.toUpperCase()));
+}
+
+/**
+ * Upper-case names aligned with gp-sdk `ThirdPlatformType#getType`（不含 `MOCK`）。
+ * 当调用方未传任何 `authType` 时用于 `getSDKConfig`：服务端只返回该渠道已配置的子集。
+ */
+export const TOPSDK_GET_SDK_CONFIG_DISCOVERY_AUTH_TYPES: readonly string[] = [
+  "NORMAL",
+  "GUEST",
+  "FACEBOOK",
+  "GOOGLE",
+  "TOKEN",
+  "SNAPCHAT",
+  "TWITTER",
+  "INSTAGRAM",
+  "AMAZON",
+  "APPLE",
+  "GAMEPLUS",
+  "NAVER",
+  "KAKAO",
+  "LINE",
+  "XSOLLA",
+  "ONESTORE",
+  "SSO",
+  "APPSFLYER",
+  "ADJUST",
+  "FIREBASE",
+  "MEETGAMES",
+  "EMAIL",
+  "HUAWEI",
+  "XIAOMI",
+  "CATAPPULT",
+  "SAMSUNG",
+  "TIKTOK",
+];
+
+/** 显式列表为空时，用发现列表再按 `filterTopSdkAuthTypesForRequest` 过滤。 */
+export function resolveAuthTypesForGetSdkConfigRequest(explicit: readonly string[]): string[] {
+  const merged = explicit.length > 0 ? explicit : [...TOPSDK_GET_SDK_CONFIG_DISCOVERY_AUTH_TYPES];
+  return filterTopSdkAuthTypesForRequest(merged);
+}
+
+export async function fetchTopSdkGetSdkConfig(params: {
+  baseUrl: string;
+  appId: string;
+  appSecret: string;
+  authTypes: readonly string[];
+  channelType: string;
+  signal?: AbortSignal;
+}): Promise<{ url: string; timestampMillis: number; body: unknown }> {
+  const filtered = resolveAuthTypesForGetSdkConfigRequest(params.authTypes);
+  if (filtered.length === 0) {
+    return {
+      url: joinBaseAndPath(params.baseUrl, SDK_CONFIG_PATH).toString(),
+      timestampMillis: Date.now(),
+      body: { code: 200, data: { channelAuthConfig: [] }, message: "skipped_no_auth_types_after_filter" },
+    };
+  }
+  const { url, timestampMillis } = buildTopSdkGetSdkConfigUrl({
+    baseUrl: params.baseUrl,
+    appId: params.appId,
+    appSecret: params.appSecret,
+    authTypes: filtered,
+    channelType: params.channelType,
+  });
+  const body = await fetchJsonGet(url, { signal: params.signal });
+  return { url, timestampMillis, body };
+}

package/src/remote/topsdkSign.ts

@@ -0,0 +1,10 @@
+import crypto from "node:crypto";
+
+/**
+ * Same algorithm as topsdk-tool-ios `TOPSDKUtils/ChannelConfigManager.md5_base64_byte`:
+ * base64( md5_binary( appId + appSecret + timestampMillis ) )
+ */
+export function topsdkMd5Base64Sign(appId: string, appSecret: string, timestampMillis: number): string {
+  const plain = `${appId}${appSecret}${String(timestampMillis)}`;
+  return crypto.createHash("md5").update(plain, "utf8").digest("base64");
+}

package/src/shared/errors.ts

@@ -0,0 +1,16 @@
+export class UserFacingError extends Error {
+  readonly code: string;
+  readonly details?: string;
+
+  constructor(code: string, message: string, details?: string) {
+    super(message);
+    this.name = "UserFacingError";
+    this.code = code;
+    this.details = details;
+  }
+}
+
+export function errorMessage(error: unknown): string {
+  if (error instanceof Error) return error.message;
+  return String(error);
+}

package/tests/assemble.test.ts

@@ -0,0 +1,12 @@
+import { describe, expect, it } from "vitest";
+import { unwrapRemoteIntegrationPayload } from "../src/android/assembleIntegrationJson.js";
+
+describe("assembleIntegrationJson", () => {
+  it("unwraps common envelopes", () => {
+    const inner = { version: 1, steps: [{ op: "gradle.insertRepositories", args: { urls: ["mavenCentral"] } }] };
+    expect(unwrapRemoteIntegrationPayload(inner)).toBe(inner);
+    expect(unwrapRemoteIntegrationPayload({ data: inner })).toEqual(inner);
+    expect(unwrapRemoteIntegrationPayload({ config: inner })).toEqual(inner);
+    expect(unwrapRemoteIntegrationPayload({ android: inner })).toEqual(inner);
+  });
+});

package/tests/doctor.test.ts

@@ -0,0 +1,91 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { loadManifestFile } from "../src/config/loadManifest.js";
+import { runDoctor } from "../src/core/doctor.js";
+import { detectSinglePlatform, platformContext } from "../src/core/platform.js";
+import { runPipeline } from "../src/core/pipeline.js";
+import { buildWorkspaceContext } from "../src/core/workspace.js";
+import { resolveIosSdkRootFromDirectory } from "../src/remote/sdkHomeDownload.js";
+
+const pkgRoot = path.resolve(__dirname, "..");
+const androidLatestRoot = path.join(pkgRoot, "fixtures", "android-test-project", "android-latest-project");
+const iosProjectRoot = path.join(pkgRoot, "fixtures", "ios-test-project", "tooltest");
+const iosRemoteConfigFixture = path.join(pkgRoot, "fixtures", "meetsdk-remote-config.ios-tooltest.json");
+const hasIosProjectFixture = fs.existsSync(iosProjectRoot);
+const fixtureIosSdkRoot = resolveIosSdkRootFromDirectory(path.join(pkgRoot, "fixtures", "ios-sdk", "topSDK-ios--V1.6.0.5"));
+
+function copyIosProjectToTemp(): string {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "meet-ios-doctor-"));
+  fs.cpSync(iosProjectRoot, tmp, { recursive: true });
+  fs.copyFileSync(iosRemoteConfigFixture, path.join(tmp, "meetsdk-remote-config.json"));
+  return tmp;
+}
+
+function stubSdkHomeVersion(): void {
+  vi.stubGlobal(
+    "fetch",
+    vi.fn(async () => ({
+      ok: true,
+      status: 200,
+      text: async () =>
+        JSON.stringify({
+          code: 200,
+          data: {
+            result: {
+              android: { ver: "1.6.1.3", date: "2026-05-25" },
+              ios: { ver: "1.6.0.5", date: "2026-06-09" },
+            },
+          },
+        }),
+    })) as unknown as typeof fetch
+  );
+}
+
+describe("doctor", () => {
+  beforeEach(() => {
+    stubSdkHomeVersion();
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it("checks Android integration details from project-root config", async () => {
+    const ctx = buildWorkspaceContext(androidLatestRoot, pkgRoot);
+    const detected = detectSinglePlatform(ctx);
+    expect(detected.ok && detected.platform).toBe("android");
+
+    const report = await runDoctor(platformContext(ctx, "android"), "android");
+
+    expect(report.platform).toBe("android");
+    expect(report.checks.map((c) => c.name)).toContain("android.repositories");
+    expect(report.checks.map((c) => c.name)).toContain("android.dependencies");
+    expect(report.checks.map((c) => c.name)).toContain("android.resValues");
+  });
+
+  it.skipIf(!hasIosProjectFixture)("checks iOS integration details from project-root config", async () => {
+    const tmp = copyIosProjectToTemp();
+    try {
+      const manifest = loadManifestFile(path.join(pkgRoot, "recipes", "ios-default.yaml"));
+      const applyCtx = buildWorkspaceContext(tmp, pkgRoot, { iosSdkRoot: fixtureIosSdkRoot });
+      const { report: applyReport } = await runPipeline(applyCtx, manifest, { dryRun: false });
+      expect(applyReport.errors).toEqual([]);
+
+      const ctx = buildWorkspaceContext(tmp, pkgRoot, { iosSdkRoot: fixtureIosSdkRoot });
+      const detected = detectSinglePlatform(ctx);
+      expect(detected.ok && detected.platform).toBe("ios");
+
+      const report = await runDoctor(platformContext(ctx, "ios"), "ios");
+
+      expect(report.platform).toBe("ios");
+      expect(report.checks.map((c) => c.name)).toContain("ios.frameworkFiles");
+      expect(report.checks.map((c) => c.name)).toContain("ios.urlSchemes.present");
+      expect(report.checks.map((c) => c.name)).toContain("ios.appDelegateInjection");
+      expect(report.errors).toEqual([]);
+    } finally {
+      fs.rmSync(tmp, { recursive: true, force: true });
+    }
+  });
+});

package/tests/downloadGoogleServicesJson.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it } from "vitest";
+import { resolveGoogleServicesJsonTarget } from "../src/android/downloadGoogleServicesJson.js";
+
+describe("resolveGoogleServicesJsonTarget", () => {
+  const root = "/proj";
+
+  it("places file under detected application module with configured name", () => {
+    const abs = resolveGoogleServicesJsonTarget(
+      root,
+      {
+        firebase_file_url: "https://x/y.json",
+        firebase_file_name: "google-services.json",
+      },
+      "app"
+    );
+    expect(abs).toBe("/proj/app/google-services.json");
+  });
+
+  it("uses non-default module directory", () => {
+    const abs = resolveGoogleServicesJsonTarget(
+      root,
+      { firebase_file_url: "https://x/y.json", firebase_file_name: "google-services.json" },
+      "launcher"
+    );
+    expect(abs).toBe("/proj/launcher/google-services.json");
+  });
+
+  it("preserves upload file name with extension", () => {
+    const abs = resolveGoogleServicesJsonTarget(
+      root,
+      {
+        firebase_file_url: "https://x/y.json",
+        firebase_file_name: "google-services.json",
+      },
+      "app"
+    );
+    expect(abs.endsWith("google-services.json")).toBe(true);
+  });
+
+  it("falls back to project root when application module unknown", () => {
+    const abs = resolveGoogleServicesJsonTarget(root, {
+      firebase_file_url: "https://x/y.json",
+      firebase_file_name: "google-services.json",
+    });
+    expect(abs).toBe("/proj/google-services.json");
+  });
+});

package/tests/fetch-remote.test.ts

@@ -0,0 +1,23 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { fetchJsonGet } from "../src/remote/fetchJson.js";
+
+describe("fetchJsonGet", () => {
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it("parses JSON bodies", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(async () => ({
+        ok: true,
+        status: 200,
+        headers: { get: () => "application/json" },
+        text: async () => JSON.stringify({ hello: "world" }),
+      })) as unknown as typeof fetch
+    );
+
+    const body = await fetchJsonGet("https://example.com/cfg.json");
+    expect(body).toEqual({ hello: "world" });
+  });
+});

package/tests/fetchConfigOverrides.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, it } from "vitest";
+import { applyFetchConfigCliOverrides, defaultSdkModules } from "../src/config/meetSdkRemoteConfig.js";
+
+describe("applyFetchConfigCliOverrides", () => {
+  const base = {
+    packageName: "com.from.server",
+    channel: "google",
+    topsdk: {
+      appId: "111",
+      appSecret: "server-secret",
+      version: "",
+      groupId: "",
+      repositories: [],
+    },
+    sdkModules: defaultSdkModules(),
+  };
+
+  it("overrides topsdk appId and root channel only", () => {
+    const out = applyFetchConfigCliOverrides(base, {
+      appId: "222",
+      channelType: "google",
+    });
+    expect(out.topsdk.appId).toBe("222");
+    expect(out.channel).toBe("GOOGLE");
+    expect(out.topsdk.appSecret).toBe("server-secret");
+    expect(out.packageName).toBe("com.from.server");
+  });
+});

package/tests/fetchConfigWrite.test.ts

@@ -0,0 +1,54 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+  validateDownloadSdkConfigForWrite,
+  writeDownloadSdkConfigRaw,
+} from "../src/config/fetchConfigWrite.js";
+
+describe("fetchConfigWrite", () => {
+  const tmpDirs: string[] = [];
+
+  afterEach(() => {
+    for (const dir of tmpDirs) {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+    tmpDirs.length = 0;
+  });
+
+  it("writeDownloadSdkConfigRaw preserves response bytes (no JSON re-serialize)", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "meet-fetch-"));
+    tmpDirs.push(dir);
+    const out = path.join(dir, "meetsdk-remote-config.json");
+    const raw = `{
+  "packageName": "com.example.game",
+  "channel": "GOOGLE",
+  "devicePlatform": "android",
+  "topsdk": { "appId": "1", "appSecret": "sec" },
+  "sdkModules": { "login": {}, "payment": {}, "analytics": {} }
+}`;
+
+    writeDownloadSdkConfigRaw(out, raw);
+    expect(fs.readFileSync(out, "utf8")).toBe(raw);
+  });
+
+  it("validateDownloadSdkConfigForWrite accepts valid remote config without meetsdk-android fields", () => {
+    const body = {
+      packageName: "com.example.game",
+      channel: "GOOGLE",
+      devicePlatform: "android",
+      topsdk: { appId: "1", appSecret: "sec" },
+      sdkModules: { login: {}, payment: {}, analytics: {} },
+    };
+    const result = validateDownloadSdkConfigForWrite(body);
+    expect(result?.parsed.packageName).toBe("com.example.game");
+    expect(result?.parsed.topsdk.version).toBe("");
+    expect((result?.parsed as { dependencies?: unknown }).dependencies).toBeUndefined();
+  });
+
+  it("validateDownloadSdkConfigForWrite rejects invalid documents", () => {
+    expect(validateDownloadSdkConfigForWrite(null)).toBeNull();
+    expect(validateDownloadSdkConfigForWrite({ topsdk: {} })).toBeNull();
+  });
+});

package/tests/fixtures-hosts.test.ts

@@ -0,0 +1,78 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+import { buildWorkspaceContext } from "../src/core/workspace.js";
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const pkgRoot = path.resolve(here, "..");
+const androidFixtureRoot = path.join(pkgRoot, "fixtures", "android-test-project");
+
+function fixtureProjectRoot(...names: string[]): string {
+  for (const name of names) {
+    const candidate = path.join(androidFixtureRoot, name);
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  return path.join(androidFixtureRoot, names[0] ?? "");
+}
+
+function createAndroidAppModule(root: string, name: string, applicationId: string): void {
+  const moduleDir = path.join(root, name);
+  fs.mkdirSync(path.join(moduleDir, "src", "main"), { recursive: true });
+  fs.writeFileSync(
+    path.join(moduleDir, "build.gradle"),
+    [
+      "plugins {",
+      "    id 'com.android.application'",
+      "}",
+      "android {",
+      "    defaultConfig {",
+      `        applicationId '${applicationId}'`,
+      "    }",
+      "}",
+      "",
+    ].join("\n"),
+    "utf8"
+  );
+  fs.writeFileSync(path.join(moduleDir, "src", "main", "AndroidManifest.xml"), "<manifest />\n", "utf8");
+}
+
+describe("fixture host trees", () => {
+  const powerRaidRoot = fixtureProjectRoot("power-raid");
+
+  it("android-latest-project (plugins DSL) resolves application module :app", () => {
+    const root = path.join(androidFixtureRoot, "android-latest-project");
+    const ctx = buildWorkspaceContext(root, pkgRoot);
+    expect(ctx.android?.ok).toBe(true);
+    expect(ctx.android?.ok && ctx.android.moduleName).toBe(":app");
+    expect(ctx.android?.ok && ctx.android.moduleDir.endsWith(`${path.sep}app`)).toBe(true);
+  });
+
+  it.skipIf(!fs.existsSync(powerRaidRoot))("power-raid resolves launcher application module", () => {
+    const ctx = buildWorkspaceContext(powerRaidRoot, pkgRoot);
+    expect(ctx.android?.ok).toBe(true);
+    expect(ctx.android?.ok && ctx.android.moduleName).toBe(":launcher");
+    expect(ctx.android?.ok && ctx.android.moduleDir.endsWith(`${path.sep}launcher`)).toBe(true);
+  });
+
+  it("requires an Android app module selector when multiple application modules exist", () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "meet-android-multi-app-"));
+    fs.writeFileSync(path.join(root, "settings.gradle"), "include ':app'\ninclude ':demo'\n", "utf8");
+    createAndroidAppModule(root, "app", "com.example.app");
+    createAndroidAppModule(root, "demo", "com.example.demo");
+
+    const ambiguous = buildWorkspaceContext(root, pkgRoot);
+    expect(ambiguous.android?.ok).toBe(false);
+    expect(ambiguous.android?.ok ? "" : ambiguous.android?.error).toContain("MULTIPLE_APPLICATION_MODULES_FOUND: :app, :demo");
+
+    const selected = buildWorkspaceContext(root, pkgRoot, { appTarget: "demo" });
+    expect(selected.android?.ok).toBe(true);
+    expect(selected.android?.ok && selected.android.moduleName).toBe(":demo");
+    expect(selected.android?.ok && selected.android.moduleDir.endsWith(`${path.sep}demo`)).toBe(true);
+
+    const missing = buildWorkspaceContext(root, pkgRoot, { appTarget: "missing" });
+    expect(missing.android?.ok).toBe(false);
+    expect(missing.android?.ok ? "" : missing.android?.error).toContain("ANDROID_APPLICATION_MODULE_NOT_FOUND: :missing");
+  });
+});

package/tests/gradle.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from "vitest";
+import { updateModuleBuildGradleDependencies, updateRootBuildGradleRepositories } from "../src/android/gradle.js";
+
+describe("gradle editors", () => {
+  it("inserts managed repositories", () => {
+    const root = `
+allprojects {
+    repositories {
+        google()
+    }
+}
+`;
+    const res = updateRootBuildGradleRepositories(root, ["https://m.example.com"]);
+    expect(res.ok).toBe(true);
+    if (!res.ok) return;
+    expect(res.content).toContain("MEET_INTEGRATE REPOS");
+    expect(res.content).toContain("m.example.com");
+  });
+
+  it("inserts managed dependencies", () => {
+    const mod = `
+apply plugin: 'com.android.application'
+android { defaultConfig { } }
+dependencies {
+}
+`;
+    const res = updateModuleBuildGradleDependencies(mod, [`    implementation 'com.demo:lib:1.0'`]);
+    expect(res.ok).toBe(true);
+    if (!res.ok) return;
+    expect(res.content).toContain("MEET_INTEGRATE BLOCK");
+    expect(res.content).toContain("com.demo:lib");
+  });
+});

package/tests/integration-json.test.ts

@@ -0,0 +1,29 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import { loadAndroidIntegrationFile } from "../src/config/loadAndroidIntegration.js";
+
+describe("android integration json", () => {
+  it("loads and validates integration file", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "meet-int-json-"));
+    const p = path.join(dir, "cfg.json");
+    fs.writeFileSync(
+      p,
+      JSON.stringify(
+        {
+          version: 1,
+          meta: { sourceUrl: "https://example.com/cfg", fetchedAt: "2026-01-01T00:00:00.000Z" },
+          steps: [{ op: "gradle.insertRepositories", platform: "android", args: { urls: ["mavenCentral"] } }],
+        },
+        null,
+        2
+      ),
+      "utf8"
+    );
+    const doc = loadAndroidIntegrationFile(p);
+    expect(doc.version).toBe(1);
+    expect(doc.steps.length).toBe(1);
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+});

package/tests/ios.codeUtils.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from "vitest";
+import { CodeUtils } from "../src/ios/codeUtils.js";
+
+describe("CodeUtils", () => {
+  it("adds header and method body without duplicating", () => {
+    const initial = `@implementation AppDelegate
+- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
+    return YES;
+}
+@end
+`;
+    const cu = new CodeUtils("AppDelegate.m", initial);
+    cu.addHeader('#import <TOPSDK/TopSDK.h>');
+    cu.addCodeToMethod(
+      "- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions",
+      "[TopSDK.sharedInstance application:application didFinishLaunchingWithOptions:launchOptions]"
+    );
+    cu.addHeader('#import <TOPSDK/TopSDK.h>');
+    expect(cu.text).toContain("#import <TOPSDK/TopSDK.h>");
+    expect(cu.text).toContain("TopSDK.sharedInstance");
+    expect(cu.text.split("#import <TOPSDK/TopSDK.h>").length - 1).toBe(1);
+  });
+});