@leonxin/meetgames 0.1.19 → 0.1.20

package/src/contracts/types.ts

@@ -12,6 +12,19 @@ export interface AndroidDetectionError {
 
 export type AndroidDetectResult = AndroidDetection | AndroidDetectionError;
 
+export interface AndroidSdkModule {
+  ok: true;
+  moduleName: string;
+  moduleDir: string;
+}
+
+export interface AndroidSdkModuleError {
+  ok: false;
+  error: string;
+}
+
+export type AndroidSdkModuleResult = AndroidSdkModule | AndroidSdkModuleError;
+
 export interface AndroidDetectOptions {
   /** Unified app target selector; for Android this is the application Gradle module, e.g. `:app` or `launcher`. */
   appTarget?: string;
@@ -60,6 +73,8 @@ export interface WorkspaceContext {
   /** Optional cache root override, primarily used by tests. */
   cacheRoot?: string;
   android?: AndroidDetectResult;
+  /** Android Gradle module where SDK resValue/dependencies are written. Defaults to `:unityLibrary`. */
+  androidSdkModule?: AndroidSdkModuleResult;
   /** Reserved: populated via placeholder until iOS tooling ships. */
   ios?: IOSDetectResult;
   iosReserved?: IosToolingReserved;
@@ -68,6 +83,8 @@ export interface WorkspaceContext {
 export interface WorkspaceContextOptions {
   /** Unified app target selector: Android application module or iOS application target. */
   appTarget?: string;
+  /** Android Gradle module where SDK resValue/dependencies are written. Defaults to `unityLibrary`. */
+  sdkModuleName?: string;
   /** sdk-home API root; defaults to the production MeetGames business API. */
   sdkHomeApiBaseUrl?: string;
   /** Override the cached remote config path. */

package/src/core/doctor.ts

@@ -84,6 +84,14 @@ function fileContainsRepository(text: string, repo: string): boolean {
 }
 
 function moduleBuildGradlePath(ctx: WorkspaceContext): string | null {
+  if (!ctx.androidSdkModule?.ok) return null;
+  const groovy = path.join(ctx.androidSdkModule.moduleDir, "build.gradle");
+  if (fs.existsSync(groovy)) return groovy;
+  const kts = path.join(ctx.androidSdkModule.moduleDir, "build.gradle.kts");
+  return fs.existsSync(kts) ? kts : null;
+}
+
+function applicationBuildGradlePath(ctx: WorkspaceContext): string | null {
   if (!ctx.android?.ok) return null;
   const groovy = path.join(ctx.android.moduleDir, "build.gradle");
   if (fs.existsSync(groovy)) return groovy;
@@ -193,6 +201,10 @@ async function checkAndroid(ctx: WorkspaceContext, report: DoctorReport, config:
     addCheck(report, "android.detect", false, "android application module not detected");
     return;
   }
+  if (!ctx.androidSdkModule?.ok) {
+    addCheck(report, "android.sdkModule", false, ctx.androidSdkModule?.error ?? "android SDK module not resolved");
+    return;
+  }
   const resolved = applyMeetSdkDefaultConfig(
     config,
     await loadMeetSdkDefaultConfigWithLatestAndroidVersion({
@@ -203,14 +215,16 @@ async function checkAndroid(ctx: WorkspaceContext, report: DoctorReport, config:
     })
   );
   const moduleGradleAbs = moduleBuildGradlePath(ctx);
+  const applicationGradleAbs = applicationBuildGradlePath(ctx);
   const rootGradleAbs = rootBuildGradlePath(ctx.projectRoot);
   const settingsGradleAbs = settingsGradlePath(ctx.projectRoot);
   const moduleGradle = moduleGradleAbs ? readFileIfExists(moduleGradleAbs) : "";
+  const applicationGradle = applicationGradleAbs ? readFileIfExists(applicationGradleAbs) : "";
   const rootGradle = rootGradleAbs ? readFileIfExists(rootGradleAbs) : "";
   const settingsGradle = settingsGradleAbs ? readFileIfExists(settingsGradleAbs) : "";
 
   addCheck(report, "android.moduleGradle.exists", Boolean(moduleGradleAbs), moduleGradleAbs ?? "module build.gradle not found");
-  addCheck(report, "android.applicationId", moduleGradle.includes(`applicationId "${resolved.packageName}"`) || moduleGradle.includes(`applicationId '${resolved.packageName}'`), resolved.packageName);
+  addCheck(report, "android.applicationId", applicationGradle.includes(`applicationId "${resolved.packageName}"`) || applicationGradle.includes(`applicationId '${resolved.packageName}'`), resolved.packageName);
 
   const repoText = `${settingsGradle}\n${rootGradle}`;
   const missingRepos = collectMeetSdkRemoteRepositories(resolved).filter((repo) => !fileContainsRepository(repoText, repo));

package/src/core/platform.ts

@@ -35,7 +35,7 @@ export function platformContext(ctx: WorkspaceContext, platform: DetectedPlatfor
   if (platform === "android") {
     return { ...ctx, ios: undefined, iosReserved: undefined };
   }
-  return { ...ctx, android: undefined };
+  return { ...ctx, android: undefined, androidSdkModule: undefined };
 }
 
 export function manifestForPlatform(manifest: Manifest, platform: DetectedPlatform): Manifest {

package/src/core/workspace.ts

@@ -1,7 +1,7 @@
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import type { WorkspaceContext, WorkspaceContextOptions } from "../contracts/types.js";
-import { detectAndroid } from "../android/detect.js";
+import { detectAndroid, resolveAndroidSdkModule } from "../android/detect.js";
 import { detectIOS } from "../ios/detect.js";
 import { iosToolingReserved } from "../ios/reserved.js";
 
@@ -26,6 +26,7 @@ export function buildWorkspaceContext(
     iosSdkRoot: options.iosSdkRoot,
     cacheRoot: options.cacheRoot,
     android: detectAndroid(root, { appTarget: options.appTarget }),
+    androidSdkModule: resolveAndroidSdkModule(root, options.sdkModuleName),
     ios: detectIOS(root, { appTarget: options.appTarget }),
     iosReserved: iosToolingReserved,
   };

package/src/mcp/server.ts

@@ -31,11 +31,12 @@ export function createMeetgamesMcpServer(): McpServer {
       inputSchema: {
         projectRoot: z.string().optional().describe("Absolute or relative project root; default is current working directory."),
         appTarget: z.string().optional().describe("App target to integrate/check: Android application Gradle module or iOS App target name."),
+        sdkModuleName: z.string().optional().describe("Android SDK integration Gradle module for resValue/dependencies; default is unityLibrary."),
       },
     },
-    async ({ projectRoot, appTarget }) => {
+    async ({ projectRoot, appTarget, sdkModuleName }) => {
       try {
-        return toSuccessResult(meetgamesDoctor({ projectRoot, appTarget }));
+        return toSuccessResult(meetgamesDoctor({ projectRoot, appTarget, sdkModuleName }));
       } catch (error) {
         return toErrorResult(error);
       }
@@ -78,14 +79,15 @@ export function createMeetgamesMcpServer(): McpServer {
       inputSchema: {
         projectRoot: z.string().optional().describe("Absolute or relative project root; default is current working directory."),
         appTarget: z.string().optional().describe("App target to integrate/check: Android application Gradle module or iOS App target name."),
+        sdkModuleName: z.string().optional().describe("Android SDK integration Gradle module for resValue/dependencies; default is unityLibrary."),
         env: z.enum(["prod", "pre", "test"]).optional().describe("TOPSDK API environment for selecting cached config."),
         appId: z.string().optional().describe("Application id for selecting cached config."),
         channelType: z.string().optional().describe("Channel type for selecting cached config."),
       },
     },
-    async ({ projectRoot, appTarget, env, appId, channelType }) => {
+    async ({ projectRoot, appTarget, sdkModuleName, env, appId, channelType }) => {
       try {
-        const result = await meetgamesIntegrate({ projectRoot, appTarget, env, appId, channelType, dryRun: true });
+        const result = await meetgamesIntegrate({ projectRoot, appTarget, sdkModuleName, env, appId, channelType, dryRun: true });
         if (result.hasErrors) {
           return {
             ...toSuccessResult(result),
@@ -106,14 +108,15 @@ export function createMeetgamesMcpServer(): McpServer {
       inputSchema: {
         projectRoot: z.string().optional().describe("Absolute or relative project root; default is current working directory."),
         appTarget: z.string().optional().describe("App target to integrate/check: Android application Gradle module or iOS App target name."),
+        sdkModuleName: z.string().optional().describe("Android SDK integration Gradle module for resValue/dependencies; default is unityLibrary."),
         env: z.enum(["prod", "pre", "test"]).optional().describe("TOPSDK API environment for selecting cached config."),
         appId: z.string().optional().describe("Application id for selecting cached config."),
         channelType: z.string().optional().describe("Channel type for selecting cached config."),
       },
     },
-    async ({ projectRoot, appTarget, env, appId, channelType }) => {
+    async ({ projectRoot, appTarget, sdkModuleName, env, appId, channelType }) => {
       try {
-        const result = await meetgamesIntegrate({ projectRoot, appTarget, env, appId, channelType, dryRun: false });
+        const result = await meetgamesIntegrate({ projectRoot, appTarget, sdkModuleName, env, appId, channelType, dryRun: false });
         if (result.hasErrors) {
           return {
             ...toSuccessResult(result),
@@ -139,14 +142,16 @@ export function createMeetgamesMcpServer(): McpServer {
         appSecret: z.string().optional().describe("Application secret for downloadSDKConfig sign (required unless TOPSDK_APP_SECRET is set)."),
         channelType: z.string().optional().describe("Channel type e.g. GOOGLE; required if not in local config."),
         appTarget: z.string().optional().describe("App target to integrate/check: Android application Gradle module or iOS App target name."),
+        sdkModuleName: z.string().optional().describe("Android SDK integration Gradle module for resValue/dependencies; default is unityLibrary."),
         dryRun: z.boolean().optional().describe("If true, integrate step previews only; fetch always writes config."),
       },
     },
-    async ({ projectRoot, env, appId, appSecret, channelType, appTarget, dryRun }) => {
+    async ({ projectRoot, env, appId, appSecret, channelType, appTarget, sdkModuleName, dryRun }) => {
       try {
         const result = await meetgamesSetup({
           projectRoot,
           appTarget,
+          sdkModuleName,
           env,
           appId,
           appSecret,

package/src/mcp/service.ts

@@ -70,13 +70,14 @@ function ensureSinglePlatformContext(
   projectRoot: string,
   packageRoot: string,
   appTarget?: string,
+  sdkModuleName?: string,
   remoteConfigPath?: string,
   cacheRoot?: string
 ): {
   platform: DetectedPlatform;
   ctx: ReturnType<typeof buildWorkspaceContext>;
 } {
-  const detectedCtx = buildWorkspaceContext(projectRoot, packageRoot, { appTarget, remoteConfigPath, cacheRoot });
+  const detectedCtx = buildWorkspaceContext(projectRoot, packageRoot, { appTarget, sdkModuleName, remoteConfigPath, cacheRoot });
   const detected = detectSinglePlatform(detectedCtx);
   if (!detected.ok) throw new Error(detected.error);
   const platformCtx = platformContext(detectedCtx, detected.platform);
@@ -90,11 +91,16 @@ function resolveAppTarget(params: { appTarget?: string }): string | undefined {
   return params.appTarget?.trim() || undefined;
 }
 
-export function meetgamesDoctor(params: { projectRoot?: string; appTarget?: string }): {
+function resolveSdkModuleName(params: { sdkModuleName?: string }): string | undefined {
+  return params.sdkModuleName?.trim() || undefined;
+}
+
+export function meetgamesDoctor(params: { projectRoot?: string; appTarget?: string; sdkModuleName?: string }): {
   projectRoot: string;
   packageRoot: string;
   platform: DetectedPlatform;
   android?: object;
+  androidSdkModule?: object;
   ios?: object;
   iosReserved?: object;
 } {
@@ -103,13 +109,15 @@ export function meetgamesDoctor(params: { projectRoot?: string; appTarget?: stri
   const { platform, ctx } = ensureSinglePlatformContext(
     projectRoot,
     packageRoot,
-    resolveAppTarget(params)
+    resolveAppTarget(params),
+    resolveSdkModuleName(params)
   );
   const out: {
     projectRoot: string;
     packageRoot: string;
     platform: DetectedPlatform;
     android?: object;
+    androidSdkModule?: object;
     ios?: object;
     iosReserved?: object;
   } = {
@@ -117,7 +125,10 @@ export function meetgamesDoctor(params: { projectRoot?: string; appTarget?: stri
     packageRoot: ctx.packageRoot,
     platform,
   };
-  if (platform === "android") out.android = ctx.android;
+  if (platform === "android") {
+    out.android = ctx.android;
+    out.androidSdkModule = ctx.androidSdkModule;
+  }
   if (platform === "ios") {
     out.ios = ctx.ios;
     out.iosReserved = ctx.iosReserved;
@@ -183,6 +194,7 @@ export async function meetgamesFetchConfig(params: {
 export async function meetgamesIntegrate(params: {
   projectRoot?: string;
   appTarget?: string;
+  sdkModuleName?: string;
   env?: TopSdkApiEnv;
   appId?: string;
   channelType?: string;
@@ -204,6 +216,7 @@ export async function meetgamesIntegrate(params: {
     projectRoot,
     packageRoot,
     resolveAppTarget(params),
+    resolveSdkModuleName(params),
     resolveCachedRemoteConfigPath(params),
     params.cacheRoot
   );
@@ -222,6 +235,7 @@ export async function meetgamesIntegrate(params: {
 export async function meetgamesSetup(params: {
   projectRoot?: string;
   appTarget?: string;
+  sdkModuleName?: string;
   env?: TopSdkApiEnv;
   appId?: string;
   appSecret?: string;
@@ -235,7 +249,8 @@ export async function meetgamesSetup(params: {
   const projectRoot = ensureProjectRoot(params.projectRoot);
   const packageRoot = resolvePackageRoot();
   const appTarget = resolveAppTarget(params);
-  const { platform } = ensureSinglePlatformContext(projectRoot, packageRoot, appTarget, undefined, params.cacheRoot);
+  const sdkModuleName = resolveSdkModuleName(params);
+  const { platform } = ensureSinglePlatformContext(projectRoot, packageRoot, appTarget, sdkModuleName, undefined, params.cacheRoot);
   const fetch = await meetgamesFetchConfig({
     projectRoot,
     env: params.env,
@@ -253,6 +268,7 @@ export async function meetgamesSetup(params: {
   const integrate = await meetgamesIntegrate({
     projectRoot,
     appTarget,
+    sdkModuleName,
     env: params.env,
     appId: params.appId,
     channelType: params.channelType,

package/src/ops/handlers.ts

@@ -85,8 +85,8 @@ function readSettingsGradle(projectRoot: string): { rel: string; abs: string } |
 }
 
 function moduleGradleRel(ctx: WorkspaceContext): string | null {
-  if (!ctx.android?.ok) return null;
-  const moduleDir = ctx.android.moduleDir;
+  if (!ctx.androidSdkModule?.ok) return null;
+  const moduleDir = ctx.androidSdkModule.moduleDir;
   const a = path.join(moduleDir, "build.gradle");
   if (fs.existsSync(a)) return path.relative(ctx.projectRoot, a).split(path.sep).join("/");
   const b = path.join(moduleDir, "build.gradle.kts");
@@ -94,6 +94,20 @@ function moduleGradleRel(ctx: WorkspaceContext): string | null {
   return null;
 }
 
+function sdkModuleError(ctx: WorkspaceContext): string {
+  return ctx.androidSdkModule?.ok === false
+    ? ctx.androidSdkModule.error
+    : "android SDK module not resolved";
+}
+
+function sdkModuleIsApplicationModule(ctx: WorkspaceContext): boolean {
+  return Boolean(
+    ctx.android?.ok &&
+      ctx.androidSdkModule?.ok &&
+      path.resolve(ctx.android.moduleDir) === path.resolve(ctx.androidSdkModule.moduleDir)
+  );
+}
+
 function resolveRemoteConfigInput(ctx: WorkspaceContext, configFile: unknown): { abs: string; label: string } {
   if (typeof configFile === "string" && configFile.trim()) {
     const normalized = configFile.trim().replace(/\\/g, "/");
@@ -127,6 +141,7 @@ export const opHandlers: Record<string, OpHandler> = {
    */
   "gradle.applyMeetSdkRemoteConfig": async (ctx, store, args, _dry, _bc) => {
     if (!ctx.android?.ok) return fail(["android application module not detected"]);
+    if (!ctx.androidSdkModule?.ok) return fail([sdkModuleError(ctx)]);
     const config = resolveRemoteConfigInput(ctx, args.configFile);
     if (!fs.existsSync(config.abs)) return fail([`meet sdk remote config not found: ${config.label}`]);
     let raw: unknown;
@@ -197,9 +212,12 @@ export const opHandlers: Record<string, OpHandler> = {
         return fail(["gradle.applyMeetSdkRemoteConfig: root build.gradle.kts not supported in MVP"]);
       }
       const rootBefore = store.read(root.rel);
+      const shouldMirrorRepositoriesToBuildscript = /\bbuildscript\s*\{/.test(rootBefore) || buildscriptClasspaths.length > 0;
       const rootU = updateRootBuildGradleMeetSdkRemote(rootBefore, {
         repositories: repositoriesWrittenInSettings ? [] : repositories,
-        buildscriptRepositories: usesPluginsDsl ? [] : buildscriptRepositories,
+        buildscriptRepositories: usesPluginsDsl
+          ? []
+          : [...buildscriptRepositories, ...(shouldMirrorRepositoriesToBuildscript ? repositories : [])],
         buildscriptClasspaths: usesPluginsDsl ? [] : buildscriptClasspaths,
         rootPluginsDsl: usesPluginsDsl ? collectMeetSdkRemotePluginsDslForRoot(resolved) : [],
         stripBuildscriptClasspaths: usesPluginsDsl ? buildscriptClasspaths : [],
@@ -215,6 +233,7 @@ export const opHandlers: Record<string, OpHandler> = {
       style: modulePluginStyle,
       applyPlugins: usesPluginsDsl ? [] : collectMeetSdkRemoteApplyPlugins(resolved),
       pluginsDsl: usesPluginsDsl ? collectMeetSdkRemotePluginsDslForModule(resolved) : [],
+      writeApplicationId: sdkModuleIsApplicationModule(ctx),
     });
     if (!modU.ok) return fail([modU.error]);
 
@@ -243,6 +262,7 @@ export const opHandlers: Record<string, OpHandler> = {
 
   "gradle.addDependency": (ctx, store, args, _dry, _bc) => {
     if (!ctx.android?.ok) return fail(["android application module not detected"]);
+    if (!ctx.androidSdkModule?.ok) return fail([sdkModuleError(ctx)]);
     const modRel = moduleGradleRel(ctx);
     if (!modRel) return fail(["module build.gradle not found"]);
     if (modRel.endsWith(".kts")) return fail(["gradle.addDependency: build.gradle.kts not supported in MVP"]);