@leonxin/meetgames 0.1.8 → 0.1.11

package/tests/aab-converter.test.ts

@@ -0,0 +1,213 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import zlib from "node:zlib";
+import { afterEach, describe, expect, it } from "vitest";
+import { extractUniversalApk } from "../src/aab-converter/apksExtractor.js";
+import { buildBundletoolArgs, redactedBundletoolCommand } from "../src/aab-converter/bundletoolRunner.js";
+import { parseAabCliArgv, validateConvertArgs } from "../src/aab-converter/cliArgs.js";
+import { resolveOutputPaths } from "../src/aab-converter/convertAabToApk.js";
+
+const tempDirs: string[] = [];
+
+afterEach(() => {
+  for (const dir of tempDirs.splice(0)) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+  delete process.env.TEST_KS_PASS;
+  delete process.env.TEST_KEY_PASS;
+});
+
+function tempDir(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "aab-converter-test-"));
+  tempDirs.push(dir);
+  return dir;
+}
+
+function crc32(buf: Buffer): number {
+  let crc = 0xffffffff;
+  for (const b of buf) {
+    crc ^= b;
+    for (let i = 0; i < 8; i += 1) {
+      crc = (crc >>> 1) ^ (0xedb88320 & -(crc & 1));
+    }
+  }
+  return (crc ^ 0xffffffff) >>> 0;
+}
+
+function u16(value: number): Buffer {
+  const buf = Buffer.alloc(2);
+  buf.writeUInt16LE(value);
+  return buf;
+}
+
+function u32(value: number): Buffer {
+  const buf = Buffer.alloc(4);
+  buf.writeUInt32LE(value);
+  return buf;
+}
+
+function createZip(entries: Array<{ name: string; content: Buffer }>): Buffer {
+  const localParts: Buffer[] = [];
+  const centralParts: Buffer[] = [];
+  let offset = 0;
+  for (const entry of entries) {
+    const name = Buffer.from(entry.name, "utf8");
+    const compressed = zlib.deflateRawSync(entry.content);
+    const crc = crc32(entry.content);
+    const local = Buffer.concat([
+      u32(0x04034b50),
+      u16(20),
+      u16(0),
+      u16(8),
+      u16(0),
+      u16(0),
+      u32(crc),
+      u32(compressed.length),
+      u32(entry.content.length),
+      u16(name.length),
+      u16(0),
+      name,
+      compressed,
+    ]);
+    localParts.push(local);
+    centralParts.push(
+      Buffer.concat([
+        u32(0x02014b50),
+        u16(20),
+        u16(20),
+        u16(0),
+        u16(8),
+        u16(0),
+        u16(0),
+        u32(crc),
+        u32(compressed.length),
+        u32(entry.content.length),
+        u16(name.length),
+        u16(0),
+        u16(0),
+        u16(0),
+        u16(0),
+        u32(0),
+        u32(offset),
+        name,
+      ])
+    );
+    offset += local.length;
+  }
+  const centralDir = Buffer.concat(centralParts);
+  const eocd = Buffer.concat([
+    u32(0x06054b50),
+    u16(0),
+    u16(0),
+    u16(entries.length),
+    u16(entries.length),
+    u32(centralDir.length),
+    u32(offset),
+    u16(0),
+  ]);
+  return Buffer.concat([...localParts, centralDir, eocd]);
+}
+
+describe("AAB converter CLI args", () => {
+  it("parses env passwords and defaults to overwrite", () => {
+    const dir = tempDir();
+    const aab = path.join(dir, "sample.aab");
+    const jks = path.join(dir, "sample.jks");
+    fs.writeFileSync(aab, "aab");
+    fs.writeFileSync(jks, "jks");
+    process.env.TEST_KS_PASS = "store-pass";
+    process.env.TEST_KEY_PASS = "key-pass";
+
+    const parsed = parseAabCliArgv([
+      "node",
+      "aab-entry.js",
+      "convert",
+      "--aab",
+      aab,
+      "--out-dir",
+      path.join(dir, "out"),
+      "--ks",
+      jks,
+      "--ks-key-alias",
+      "release",
+      "--ks-pass-env",
+      "TEST_KS_PASS",
+      "--key-pass-env",
+      "TEST_KEY_PASS",
+    ]);
+    const validated = validateConvertArgs(parsed);
+    expect(validated.overwrite).toBe(true);
+    expect(validated.signing.keyStorePassword).toBe("store-pass");
+    expect(validated.signing.keyPassword).toBe("key-pass");
+  });
+
+  it("supports --no-overwrite", () => {
+    const parsed = parseAabCliArgv(["node", "aab-entry.js", "convert", "--no-overwrite"]);
+    expect(parsed.overwrite).toBe(false);
+  });
+});
+
+describe("bundletool command", () => {
+  it("builds signed universal APK set args and redacts passwords", () => {
+    const args = buildBundletoolArgs({
+      bundletoolPath: "tools/bundletool.jar",
+      aabPath: "game.aab",
+      apksPath: "game.apks",
+      overwrite: true,
+      signing: {
+        keyStorePath: "release.jks",
+        keyAlias: "release",
+        keyStorePassword: "store-secret-value",
+        keyPassword: "key-secret-value",
+      },
+    });
+    expect(args).toContain("build-apks");
+    expect(args).toContain("--mode=universal");
+    expect(args).toContain("--overwrite");
+    expect(args).toContain("--ks-pass=pass:store-secret-value");
+    expect(args).toContain("--key-pass=pass:key-secret-value");
+    const redacted = redactedBundletoolCommand("java", args);
+    expect(redacted).toContain("--ks-pass=pass:******");
+    expect(redacted).toContain("--key-pass=pass:******");
+    expect(redacted).not.toContain("store-secret-value");
+    expect(redacted).not.toContain("key-secret-value");
+  });
+});
+
+describe("APKS extraction", () => {
+  it("extracts universal.apk from a zip based .apks file", async () => {
+    const dir = tempDir();
+    const apks = path.join(dir, "sample.apks");
+    const apk = path.join(dir, "sample.apk");
+    fs.writeFileSync(
+      apks,
+      createZip([
+        { name: "toc.pb", content: Buffer.from("toc") },
+        { name: "universal.apk", content: Buffer.from("apk-binary") },
+      ])
+    );
+    await extractUniversalApk(apks, apk, true);
+    expect(fs.readFileSync(apk, "utf8")).toBe("apk-binary");
+  });
+
+  it("fails when output exists and overwrite is disabled", async () => {
+    const dir = tempDir();
+    const apks = path.join(dir, "sample.apks");
+    const apk = path.join(dir, "sample.apk");
+    fs.writeFileSync(apks, createZip([{ name: "universal.apk", content: Buffer.from("new") }]));
+    fs.writeFileSync(apk, "old");
+    await expect(extractUniversalApk(apks, apk, false)).rejects.toThrow(/already exists/);
+  });
+});
+
+describe("output paths", () => {
+  it("uses the AAB base name for default APK and APKS outputs", () => {
+    const paths = resolveOutputPaths({
+      aabPath: path.join("D:", "pkg", "game.aab"),
+      outDir: path.join("D:", "out"),
+    });
+    expect(paths.apksPath.endsWith(`${path.sep}game.apks`)).toBe(true);
+    expect(paths.apkPath.endsWith(`${path.sep}game_universal.apk`)).toBe(true);
+  });
+});

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,89 @@
+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";
+
+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);
+
+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);
+      const { report: applyReport } = await runPipeline(applyCtx, manifest, { dryRun: false });
+      expect(applyReport.errors).toEqual([]);
+
+      const ctx = buildWorkspaceContext(tmp, pkgRoot);
+      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/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);
+  });
+});

package/tests/ios.sdkBundle.test.ts

@@ -0,0 +1,16 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+import { resolveIosSdkRoot } from "../src/ios/sdkBundle.js";
+
+const pkgRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+describe("resolveIosSdkRoot", () => {
+  it("finds nested TopSDK package under bundled/ios-sdk", () => {
+    const root = resolveIosSdkRoot(pkgRoot);
+    expect(root).toContain(`${path.sep}bundled${path.sep}ios-sdk`);
+    expect(fs.existsSync(path.join(root, "sdk", "topsdkConfig.t.json"))).toBe(true);
+    expect(fs.existsSync(path.join(root, "plugins", "GuestSignin", "config.t.json"))).toBe(true);
+  });
+});

package/tests/loadManifest.test.ts

@@ -0,0 +1,15 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import { loadManifestFile } from "../src/config/loadManifest.js";
+
+describe("loadManifest", () => {
+  it("rejects invalid manifests", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "meet-int-"));
+    const p = path.join(dir, "bad.yaml");
+    fs.writeFileSync(p, "version: 1\n", "utf8");
+    expect(() => loadManifestFile(p)).toThrow(/Manifest validation failed/);
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+});

package/tests/manifest-xml.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from "vitest";
+import { extractPermissionName, insertPermissions } from "../src/android/manifest.js";
+
+describe("android manifest", () => {
+  it("inserts permissions block before closing manifest", () => {
+    const xml = `<?xml version="1.0" encoding="utf-8"?>
+<manifest package="a.b">
+    <application />
+</manifest>`;
+    const { content, changed } = insertPermissions(xml, ["android.permission.INTERNET"]);
+    expect(changed).toBe(true);
+    expect(content).toContain("uses-permission");
+    expect(content).toContain("INTERNET");
+  });
+
+  it("updates permission by android:name instead of duplicating", () => {
+    const xml = `<?xml version="1.0" encoding="utf-8"?>
+<manifest package="a.b">
+    <uses-permission android:name="android.permission.INTERNET" />
+<!-- MEET_INTEGRATE PERMISSIONS START -->
+    <uses-permission android:name="android.permission.INTERNET" />
+<!-- MEET_INTEGRATE PERMISSIONS END -->
+    <application />
+</manifest>`;
+    const { content } = insertPermissions(xml, ["android.permission.INTERNET"]);
+    const permLines = content.split("\n").filter((l) => extractPermissionName(l));
+    expect(permLines.length).toBe(1);
+    expect(content).toContain('android:name="android.permission.INTERNET"');
+  });
+});