@leonxin/meetgames 0.1.7 → 0.1.11

package/src/aab-converter/cliArgs.ts

@@ -0,0 +1,194 @@
+import path from "node:path";
+import { UserFacingError } from "../shared/errors.js";
+import { toAbsolutePath } from "../shared/pathUtils.js";
+import { resolveSigningOptions } from "./signingOptions.js";
+import type { SigningOptions } from "./types.js";
+
+export interface ParsedAabCli {
+  help: boolean;
+  command: string;
+  aabPath: string;
+  outDir: string;
+  keyStorePath: string;
+  keyAlias: string;
+  keyStorePassword?: string;
+  keyPassword?: string;
+  apkName?: string;
+  keepApks: boolean;
+  overwrite: boolean;
+  verbose: boolean;
+}
+
+function valueAfter(args: string[], index: number, flag: string): string {
+  const value = args[index + 1] ?? "";
+  if (!value || value.startsWith("--")) {
+    throw new UserFacingError("INVALID_ARGS", `${flag} requires a value`);
+  }
+  return value;
+}
+
+function passwordFromEnv(envName: string, flag: string): string {
+  const value = process.env[envName];
+  if (!value) {
+    throw new UserFacingError("ENV_PASSWORD_MISSING", `${flag} points to an empty or missing environment variable: ${envName}`);
+  }
+  return value;
+}
+
+export function printAabHelp(): void {
+  console.log(`
+aab2apk — Convert Android App Bundle (.aab) to signed universal APK
+
+Usage:
+  aab2apk.cmd convert --aab <file.aab> --out-dir <dir> --ks <file.jks> --ks-key-alias <alias> [password options]
+
+Required:
+  --aab              AAB file path
+  --out-dir          Output directory
+  --ks               Keystore/JKS file path
+  --ks-key-alias     Key alias in keystore
+
+Password options:
+  --ks-pass-env      Read keystore password from environment variable (recommended)
+  --key-pass-env     Read key password from environment variable (recommended)
+  --ks-pass          Keystore password as command argument (not recommended)
+  --key-pass         Key password as command argument (not recommended)
+
+Other options:
+  --apk-name         Output APK file name
+  --keep-apks        Keep intermediate .apks file
+  --no-overwrite     Fail if output already exists (default is overwrite)
+  --verbose          Print detailed logs
+  --help, -h         Show help
+`);
+}
+
+export function parseAabCliArgv(argv: string[]): ParsedAabCli {
+  const rest = argv.slice(2);
+  if (!rest.length || rest[0] === "--help" || rest[0] === "-h") {
+    return {
+      help: true,
+      command: "",
+      aabPath: "",
+      outDir: "",
+      keyStorePath: "",
+      keyAlias: "",
+      keepApks: false,
+      overwrite: true,
+      verbose: false,
+    };
+  }
+  const parsed: ParsedAabCli = {
+    help: false,
+    command: rest[0] ?? "",
+    aabPath: "",
+    outDir: "",
+    keyStorePath: "",
+    keyAlias: "",
+    keepApks: false,
+    overwrite: true,
+    verbose: false,
+  };
+  if (parsed.command !== "convert") {
+    throw new UserFacingError("INVALID_COMMAND", `Unknown command: ${parsed.command}`);
+  }
+  for (let i = 1; i < rest.length; i += 1) {
+    const flag = rest[i];
+    if (flag === "--help" || flag === "-h") {
+      parsed.help = true;
+      return parsed;
+    }
+    if (flag === "--keep-apks") {
+      parsed.keepApks = true;
+      continue;
+    }
+    if (flag === "--verbose") {
+      parsed.verbose = true;
+      continue;
+    }
+    if (flag === "--no-overwrite") {
+      parsed.overwrite = false;
+      continue;
+    }
+    if (flag === "--overwrite") {
+      parsed.overwrite = true;
+      continue;
+    }
+    if (flag === "--aab") {
+      parsed.aabPath = valueAfter(rest, i, flag);
+      i += 1;
+      continue;
+    }
+    if (flag === "--out-dir") {
+      parsed.outDir = valueAfter(rest, i, flag);
+      i += 1;
+      continue;
+    }
+    if (flag === "--ks") {
+      parsed.keyStorePath = valueAfter(rest, i, flag);
+      i += 1;
+      continue;
+    }
+    if (flag === "--ks-key-alias") {
+      parsed.keyAlias = valueAfter(rest, i, flag);
+      i += 1;
+      continue;
+    }
+    if (flag === "--ks-pass-env") {
+      parsed.keyStorePassword = passwordFromEnv(valueAfter(rest, i, flag), flag);
+      i += 1;
+      continue;
+    }
+    if (flag === "--key-pass-env") {
+      parsed.keyPassword = passwordFromEnv(valueAfter(rest, i, flag), flag);
+      i += 1;
+      continue;
+    }
+    if (flag === "--ks-pass") {
+      parsed.keyStorePassword = valueAfter(rest, i, flag);
+      i += 1;
+      continue;
+    }
+    if (flag === "--key-pass") {
+      parsed.keyPassword = valueAfter(rest, i, flag);
+      i += 1;
+      continue;
+    }
+    if (flag === "--apk-name") {
+      parsed.apkName = valueAfter(rest, i, flag);
+      i += 1;
+      continue;
+    }
+    throw new UserFacingError("INVALID_ARGS", `Unsupported argument: ${flag}`);
+  }
+  return parsed;
+}
+
+export function validateConvertArgs(parsed: ParsedAabCli): {
+  aabPath: string;
+  outDir: string;
+  signing: SigningOptions;
+  apkName?: string;
+  keepApks: boolean;
+  overwrite: boolean;
+  verbose: boolean;
+} {
+  if (!parsed.aabPath) throw new UserFacingError("INVALID_ARGS", "Missing --aab");
+  if (!parsed.outDir) throw new UserFacingError("INVALID_ARGS", "Missing --out-dir");
+  if (!parsed.keyStorePath) throw new UserFacingError("INVALID_ARGS", "Missing --ks");
+  if (!parsed.keyAlias) throw new UserFacingError("INVALID_ARGS", "Missing --ks-key-alias");
+  return {
+    aabPath: toAbsolutePath(parsed.aabPath),
+    outDir: path.resolve(parsed.outDir),
+    signing: resolveSigningOptions({
+      keyStorePath: parsed.keyStorePath,
+      keyAlias: parsed.keyAlias,
+      keyStorePassword: parsed.keyStorePassword,
+      keyPassword: parsed.keyPassword,
+    }),
+    apkName: parsed.apkName,
+    keepApks: parsed.keepApks,
+    overwrite: parsed.overwrite,
+    verbose: parsed.verbose,
+  };
+}

package/src/aab-converter/convertAabToApk.ts

@@ -0,0 +1,81 @@
+import fs from "node:fs";
+import path from "node:path";
+import { UserFacingError } from "../shared/errors.js";
+import { assertCanWriteFile, assertFileExists, assertWritableDirectory } from "../shared/fileUtils.js";
+import { baseNameWithoutExt, toAbsolutePath, validateOutputFileName } from "../shared/pathUtils.js";
+import { buildUniversalApks } from "./bundletoolRunner.js";
+import { extractUniversalApk } from "./apksExtractor.js";
+import type { ConvertAabToApkOptions, ConvertAabToApkResult } from "./types.js";
+
+export function resolveOutputPaths(options: Pick<ConvertAabToApkOptions, "aabPath" | "outDir" | "apkName">): {
+  apksPath: string;
+  apkPath: string;
+} {
+  const aabBase = baseNameWithoutExt(options.aabPath, ".aab");
+  const apkName = options.apkName ? validateOutputFileName(options.apkName) : `${aabBase}_universal.apk`;
+  return {
+    apksPath: path.join(options.outDir, `${aabBase}.apks`),
+    apkPath: path.join(options.outDir, apkName),
+  };
+}
+
+export async function convertAabToApk(options: ConvertAabToApkOptions): Promise<ConvertAabToApkResult> {
+  const aabPath = toAbsolutePath(options.aabPath);
+  const outDir = toAbsolutePath(options.outDir);
+  const javaPath = options.javaPath;
+  const bundletoolPath = toAbsolutePath(options.bundletoolPath);
+  const signing = {
+    ...options.signing,
+    keyStorePath: toAbsolutePath(options.signing.keyStorePath),
+  };
+
+  assertFileExists(aabPath, "AAB_NOT_FOUND", "AAB file");
+  baseNameWithoutExt(aabPath, ".aab");
+  assertFileExists(signing.keyStorePath, "KEYSTORE_NOT_FOUND", "Keystore file");
+  assertFileExists(bundletoolPath, "BUNDLETOOL_NOT_FOUND", "bundletool.jar");
+  if (javaPath.includes("/") || javaPath.includes("\\")) {
+    assertFileExists(javaPath, "JAVA_NOT_FOUND", "Java executable");
+  }
+  assertWritableDirectory(outDir);
+
+  const { apksPath, apkPath } = resolveOutputPaths({ aabPath, outDir, apkName: options.apkName });
+  assertCanWriteFile(apksPath, options.overwrite, "APK set");
+  assertCanWriteFile(apkPath, options.overwrite, "Output APK");
+
+  options.logger?.info(`AAB: ${aabPath}`);
+  options.logger?.info(`Output directory: ${outDir}`);
+  options.logger?.info(`APK set: ${apksPath}`);
+  options.logger?.info(`Output APK: ${apkPath}`);
+
+  await buildUniversalApks({
+    javaPath,
+    bundletoolPath,
+    aabPath,
+    apksPath,
+    signing,
+    overwrite: options.overwrite,
+    logger: options.logger,
+  });
+
+  await extractUniversalApk(apksPath, apkPath, options.overwrite);
+  options.logger?.info(`Extracted universal APK: ${apkPath}`);
+
+  if (!options.keepApks) {
+    try {
+      fs.unlinkSync(apksPath);
+      options.logger?.info(`Removed intermediate APK set: ${apksPath}`);
+    } catch (e) {
+      options.logger?.warn(`Failed to remove intermediate APK set: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+
+  if (!fs.existsSync(apkPath)) {
+    throw new UserFacingError("APK_OUTPUT_MISSING", `Output APK was not created: ${apkPath}`);
+  }
+
+  return {
+    apkPath,
+    apksPath: options.keepApks ? apksPath : undefined,
+    logPath: options.logger?.logPath,
+  };
+}

package/src/aab-converter/resourcePaths.ts

@@ -0,0 +1,43 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { UserFacingError } from "../shared/errors.js";
+
+export function resolveToolRoot(metaUrl: string): string {
+  const here = path.dirname(fileURLToPath(metaUrl));
+  return path.resolve(here, "..", "..");
+}
+
+function firstExisting(candidates: string[]): string | null {
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+
+export function resolveBundletoolPath(toolRoot: string): string {
+  const envPath = process.env.AAB2APK_BUNDLETOOL_PATH?.trim();
+  if (envPath) return path.resolve(envPath);
+  const found = firstExisting([
+    path.join(toolRoot, "tools", "bundletool.jar"),
+    path.join(toolRoot, "bundled", "android", "bundletool.jar"),
+  ]);
+  if (found) return found;
+  throw new UserFacingError(
+    "BUNDLETOOL_NOT_FOUND",
+    `bundletool.jar not found. Expected ${path.join(toolRoot, "tools", "bundletool.jar")}`
+  );
+}
+
+export function resolveJavaPath(toolRoot: string): string {
+  const envPath = process.env.AAB2APK_JAVA_PATH?.trim();
+  if (envPath) return path.resolve(envPath);
+  const exe = process.platform === "win32" ? "java.exe" : "java";
+  const candidates = [path.join(toolRoot, "runtime", "jre", "bin", exe)];
+  if (process.platform === "win32") {
+    candidates.push(path.join(toolRoot, "runtime", "win-x64", "jre", "bin", "java.exe"));
+  }
+  const found = firstExisting(candidates);
+  if (found) return found;
+  return exe;
+}

package/src/aab-converter/signingOptions.ts

@@ -0,0 +1,29 @@
+import path from "node:path";
+import { UserFacingError } from "../shared/errors.js";
+import { assertFileExists } from "../shared/fileUtils.js";
+import { toAbsolutePath } from "../shared/pathUtils.js";
+import type { SigningOptions } from "./types.js";
+
+export interface SigningInput {
+  keyStorePath: string;
+  keyAlias: string;
+  keyStorePassword?: string;
+  keyPassword?: string;
+}
+
+export function resolveSigningOptions(input: SigningInput): SigningOptions {
+  const keyStorePath = toAbsolutePath(input.keyStorePath);
+  assertFileExists(keyStorePath, "KEYSTORE_NOT_FOUND", "Keystore file");
+  if (!input.keyAlias.trim()) {
+    throw new UserFacingError("SIGNING_ALIAS_MISSING", "Missing --ks-key-alias");
+  }
+  if (!input.keyStorePassword) {
+    throw new UserFacingError("SIGNING_PASSWORD_MISSING", "Missing keystore password");
+  }
+  return {
+    keyStorePath: path.resolve(keyStorePath),
+    keyAlias: input.keyAlias,
+    keyStorePassword: input.keyStorePassword,
+    keyPassword: input.keyPassword || undefined,
+  };
+}

package/src/aab-converter/types.ts

@@ -0,0 +1,26 @@
+import type { Logger } from "../shared/logger.js";
+
+export interface SigningOptions {
+  keyStorePath: string;
+  keyAlias: string;
+  keyStorePassword: string;
+  keyPassword?: string;
+}
+
+export interface ConvertAabToApkOptions {
+  aabPath: string;
+  outDir: string;
+  signing: SigningOptions;
+  javaPath: string;
+  bundletoolPath: string;
+  apkName?: string;
+  keepApks: boolean;
+  overwrite: boolean;
+  logger?: Logger;
+}
+
+export interface ConvertAabToApkResult {
+  apkPath: string;
+  apksPath?: string;
+  logPath?: string;
+}

package/src/android/adapter.ts

@@ -0,0 +1,9 @@
+import type { AndroidDetectOptions, AndroidDetectResult, AndroidPlatformAdapter } from "../contracts/types.js";
+import { detectAndroid } from "./detect.js";
+
+export const androidPlatformAdapter: AndroidPlatformAdapter = {
+  id: "android",
+  detect(projectRoot: string, options?: AndroidDetectOptions): AndroidDetectResult {
+    return detectAndroid(projectRoot, options);
+  },
+};

package/src/android/assembleIntegrationJson.ts

@@ -0,0 +1,33 @@
+import type { AndroidIntegrationDocument } from "../contracts/types.js";
+
+function isRecord(v: unknown): v is Record<string, unknown> {
+  return typeof v === "object" && v !== null;
+}
+
+/**
+ * Normalizes common API envelopes into the integration document shape.
+ * Supported roots: top-level `{ version, steps }`, `{ data: ... }`, `{ config: ... }`, `{ android: ... }` (when it contains steps).
+ */
+export function unwrapRemoteIntegrationPayload(body: unknown): unknown {
+  if (!isRecord(body)) return body;
+  if (Array.isArray(body.steps)) return body;
+  if (isRecord(body.data) && Array.isArray(body.data.steps)) return body.data;
+  if (isRecord(body.config) && Array.isArray(body.config.steps)) return body.config;
+  if (isRecord(body.android) && Array.isArray(body.android.steps)) return body.android;
+  return body;
+}
+
+export function attachIntegrationMeta(
+  doc: AndroidIntegrationDocument,
+  sourceUrl: string,
+  fetchedAt: string
+): AndroidIntegrationDocument {
+  return {
+    ...doc,
+    meta: {
+      ...(doc.meta ?? {}),
+      sourceUrl,
+      fetchedAt,
+    },
+  };
+}

package/src/android/detect.ts

@@ -0,0 +1,132 @@
+import fs from "node:fs";
+import path from "node:path";
+import type { AndroidDetectOptions, AndroidDetectResult } from "../contracts/types.js";
+
+function parseIncludes(settingsContent: string): string[] {
+  const includes: string[] = [];
+  const includeRegex = /include\s+([^\n]+)/g;
+  let match = includeRegex.exec(settingsContent);
+  while (match) {
+    const raw = match[1];
+    const parts = raw
+      .split(",")
+      .map((x) => x.trim())
+      .filter(Boolean)
+      .map((x) => x.replace(/^['"]|['"]$/g, ""));
+    includes.push(...parts);
+    match = includeRegex.exec(settingsContent);
+  }
+  return includes;
+}
+
+function isApplicationModule(buildGradleContent: string): boolean {
+  const applyPlugin = /apply\s+plugin:\s*['"]com\.android\.application['"]/m.test(buildGradleContent);
+  const pluginsBlock = /id\s*\(?\s*['"]com\.android\.application['"]\s*\)?/m.test(buildGradleContent);
+  const pluginAlias = /\balias\s*\(\s*libs\.plugins\.[A-Za-z0-9_.-]*application[A-Za-z0-9_.-]*\s*\)/m.test(buildGradleContent);
+  const hasAndroidBlock = /\bandroid\s*\{/m.test(buildGradleContent);
+  const hasApplicationId = /\bapplicationId\s+(?:=+\s*)?["'][^"']+["']/m.test(buildGradleContent);
+  return applyPlugin || pluginsBlock || pluginAlias || (hasAndroidBlock && hasApplicationId);
+}
+
+function moduleNameToDir(projectRoot: string, moduleName: string): string {
+  const normalized = moduleName.startsWith(":") ? moduleName.slice(1) : moduleName;
+  const relative = normalized.replace(/:/g, "/");
+  return path.join(projectRoot, relative);
+}
+
+function defaultManifestPath(moduleDir: string): string {
+  return path.join(moduleDir, "src", "main", "AndroidManifest.xml");
+}
+
+function normalizeModuleSelector(value: string): string {
+  const trimmed = value.trim().replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
+  if (!trimmed) return "";
+  const asGradlePath = trimmed.replace(/\//g, ":");
+  return asGradlePath.startsWith(":") ? asGradlePath : `:${asGradlePath}`;
+}
+
+function applicationModuleList(modules: { moduleName: string }[]): string {
+  return modules.map((x) => x.moduleName).join(", ");
+}
+
+function successResult(projectRoot: string, moduleName: string, moduleDir: string): AndroidDetectResult {
+  const manifestPath = defaultManifestPath(moduleDir);
+  if (!fs.existsSync(manifestPath)) {
+    return { ok: false, error: `AndroidManifest.xml not found at ${manifestPath}` };
+  }
+
+  return { ok: true, moduleName, moduleDir, manifestPath };
+}
+
+export function detectAndroid(projectRoot: string, options: AndroidDetectOptions = {}): AndroidDetectResult {
+  const settingsGradle = path.join(projectRoot, "settings.gradle");
+  const settingsGradleKts = path.join(projectRoot, "settings.gradle.kts");
+  let settingsContent = "";
+  if (fs.existsSync(settingsGradle)) {
+    settingsContent = fs.readFileSync(settingsGradle, "utf8");
+  } else if (fs.existsSync(settingsGradleKts)) {
+    settingsContent = fs.readFileSync(settingsGradleKts, "utf8");
+  } else {
+    return { ok: false, error: "settings.gradle / settings.gradle.kts not found in project root" };
+  }
+
+  const modules = parseIncludes(settingsContent);
+  if (!modules.length) {
+    return { ok: false, error: "no modules found in settings.gradle" };
+  }
+
+  const applicationModules: { moduleName: string; moduleDir: string }[] = [];
+  for (const moduleName of modules) {
+    const moduleDir = moduleNameToDir(projectRoot, moduleName);
+    const candidates = [path.join(moduleDir, "build.gradle"), path.join(moduleDir, "build.gradle.kts")];
+    const moduleGradle = candidates.find((p) => fs.existsSync(p));
+    if (!moduleGradle) continue;
+    const content = fs.readFileSync(moduleGradle, "utf8");
+    if (isApplicationModule(content)) {
+      applicationModules.push({ moduleName, moduleDir });
+    }
+  }
+
+  const requestedModule = options.appTarget ? normalizeModuleSelector(options.appTarget) : "";
+  if (applicationModules.length === 0) {
+    return { ok: false, error: "NO_APPLICATION_MODULE_FOUND" };
+  }
+  if (requestedModule) {
+    const selected = applicationModules.find((x) => normalizeModuleSelector(x.moduleName) === requestedModule);
+    if (!selected) {
+      const list = applicationModuleList(applicationModules);
+      return {
+        ok: false,
+        error: `ANDROID_APPLICATION_MODULE_NOT_FOUND: ${requestedModule}; available application modules: ${list}`,
+      };
+    }
+    return successResult(projectRoot, selected.moduleName, selected.moduleDir);
+  }
+  if (applicationModules.length > 1) {
+    const list = applicationModuleList(applicationModules);
+    return {
+      ok: false,
+      error: `MULTIPLE_APPLICATION_MODULES_FOUND: ${list}; pass --app-target <module> to select one`,
+    };
+  }
+
+  const { moduleName, moduleDir } = applicationModules[0];
+  return successResult(projectRoot, moduleName, moduleDir);
+}
+
+/** Relative path from project root to the detected application module directory (e.g. `app`, `launcher`). */
+export function applicationModuleRelPath(
+  projectRoot: string,
+  android: Extract<AndroidDetectResult, { ok: true }>
+): string {
+  return path.relative(projectRoot, android.moduleDir).split(path.sep).join("/");
+}
+
+/** Default `google-services.json` location: `{applicationModule}/google-services.json`. */
+export function defaultGoogleServicesJsonRelPath(
+  projectRoot: string,
+  android: Extract<AndroidDetectResult, { ok: true }>
+): string {
+  const moduleRel = applicationModuleRelPath(projectRoot, android);
+  return moduleRel ? `${moduleRel}/google-services.json` : "google-services.json";
+}

package/src/android/downloadGoogleServicesJson.ts

@@ -0,0 +1,56 @@
+import fs from "node:fs";
+import path from "node:path";
+import type { MeetSdkAnalyticsFirebaseCredentials } from "../config/meetSdkRemoteConfig.js";
+
+/**
+ * Resolve target file under the detected Android application module:
+ * `{projectRoot}/{applicationModuleRel}/{fileName}`.
+ * `fileName` comes from remote `firebase_file_name` (DB `firebase_name`, upload original name + suffix).
+ * Relative path is not configured in MG; meet-sdk-tool detects the app module from `projectRoot`.
+ */
+export function resolveGoogleServicesJsonTarget(
+  projectRoot: string,
+  firebase: MeetSdkAnalyticsFirebaseCredentials,
+  applicationModuleRelPath?: string
+): string {
+  const fileName = firebase.firebase_file_name?.trim() || "google-services.json";
+  const moduleRel = applicationModuleRelPath?.trim().replace(/\\/g, "/").replace(/\/+$/, "");
+  if (moduleRel) {
+    return path.join(projectRoot, moduleRel, fileName);
+  }
+  return path.join(projectRoot, fileName);
+}
+
+export async function downloadGoogleServicesJson(
+  projectRoot: string,
+  firebase: MeetSdkAnalyticsFirebaseCredentials,
+  options?: { applicationModuleRelPath?: string; dryRun?: boolean }
+): Promise<{ ok: true; relPath: string; absPath: string } | { ok: false; error: string }> {
+  const url = firebase.firebase_file_url?.trim();
+  if (!url) {
+    return { ok: false, error: "firebase_file_url is empty" };
+  }
+
+  const absPath = resolveGoogleServicesJsonTarget(projectRoot, firebase, options?.applicationModuleRelPath);
+  const relPath = path.relative(projectRoot, absPath).split(path.sep).join("/");
+
+  if (options?.dryRun) {
+    return { ok: true, relPath, absPath };
+  }
+
+  let res: Response;
+  try {
+    res = await fetch(url);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return { ok: false, error: `fetch failed: ${msg}` };
+  }
+  if (!res.ok) {
+    return { ok: false, error: `HTTP ${res.status} ${res.statusText}` };
+  }
+
+  const buf = Buffer.from(await res.arrayBuffer());
+  fs.mkdirSync(path.dirname(absPath), { recursive: true });
+  fs.writeFileSync(absPath, buf);
+  return { ok: true, relPath, absPath };
+}