@leonxin/meetgames 0.1.8 → 0.1.12

package/docs/{ → archive/product/}/346/212/200/346/234/257/346/226/271/346/241/210/350/260/203/347/240/224.md

@@ -86,7 +86,7 @@ PRD「AST 替代正则」指 **后续 Groovy Gradle 编辑** 与 **游戏源码
 | 接口 | 路径 | 鉴权 | 返回 | 工具 |
 |------|------|------|------|------|
 | 老接口 | `GET /openSDK/getSDKConfig` | sign + timestamp | `channelAuthConfig` 片段 | 库内保留映射，CLI 不用 |
-| **新接口（采用）** | `GET /console/openSDK/downloadSDKConfig` | 仅 `appId` + `channelType` | 完整 `meetsdk-remote-config.json` | **`fetch-config`** |
+| **新接口（采用）** | `GET /console/openSDK/downloadSDKConfig` | sign + timestamp | 完整 `meetsdk-remote-config.json` | **`fetch-config`** |
 | 老接口 | `GET /openSDK/getSDKConfig` | sign | `channelAuthConfig` 片段 | 不用于 CLI 拉参 |
 
 JSON 内渠道字段：**根级 `channel` only**（无 `channelType`、无 `topsdk.channel`）。
@@ -182,7 +182,7 @@ flowchart LR
 
 ### 5.3 Firebase
 
-- `firebase_file_url` 在 analytics.firebase 对象中；  
+- `firebaseUrl` 在 analytics.firebase 对象中；  
 - 集成时拉取或引用 URL（具体拷贝逻辑见 recipe / firebase 相关 op）。
 
 ---
@@ -251,14 +251,14 @@ meetgames fetch-config --project-root <原生工程根> \
   --app-id <APP_ID> --channel-type GOOGLE --env test
 
 meetgames setup --project-root <原生工程根> \
-  --app-id <APP_ID> --channel-type GOOGLE
+  --app-id <APP_ID> --app-secret <APP_SECRET> --channel-type GOOGLE
 ```
 
 | 说明 | |
 |------|--|
 | `channel-type` | 商店渠道枚举，对应 HTTP 参数 `channelType` |
-| `app-secret` | **不必**在 fetch-config 传入；由 `downloadSDKConfig` 响应写入 JSON |
-| CI | 设置 `TOPSDK_APP_ID`、`TOPSDK_CHANNEL_TYPE` 或依赖已提交的 JSON 缓存 |
+| `app-secret` | **必须**在 fetch-config/setup 传入，或通过 `TOPSDK_APP_SECRET` 设置；仅用于计算 `sign` |
+| CI | 设置 `TOPSDK_APP_ID`、`TOPSDK_APP_SECRET`、`TOPSDK_CHANNEL_TYPE` 或依赖已提交的 JSON 缓存 |
 
 ### 7.2 MCP（MVP）
 
@@ -276,7 +276,7 @@ meetgames setup --project-root <原生工程根> \
 | 项 | 技术要点 |
 |----|----------|
 | 渠道配置下载 | 与 `downloadSDKConfig` 字节流一致，避免前端再拼 JSON |
-| 三方文件 | 对象存储原文件 + 下载 URL 写入 JSON（如 `firebase_file_url`） |
+| 三方文件 | 对象存储原文件 + 下载 URL 写入 JSON（如 `firebaseUrl`） |
 | SDK 版本 | 后台配置 → 下发或随工具 `meetsdk-android.json` 同步策略 **【待与发版流程对齐】** |
 | 后台改 JSON 字段 | 与工具约定根级 `channel`，避免回退 `topsdk.channel` |
 
@@ -300,7 +300,7 @@ meetgames setup --project-root <原生工程根> \
 | 层级 | 内容 |
 |------|------|
 | 单元 | Gradle upsert、JSON 解析、Manifest |
-| 集成 | `test-projects/android-latest-project`、`test-projects/power-raid`、`pipeline.*.test.ts` |
+| 集成 | `fixtures/android-test-project/android-latest-project`、`fixtures/android-test-project/power-raid`、`pipeline.*.test.ts` |
 | CI 建议 | `npm ci && npm test && meetgames setup --dry-run`（需 secrets 与 API 可用） |
 
 **宿主限制**：流水线仅针对标准 Android **Groovy** Gradle / Xcode 原生工程；**不支持** `build.gradle.kts`；Unity / Unreal 不在支持矩阵内。

package/docs/{ → archive/product/}/351/234/200/346/261/202/346/226/207/346/241/243.md

@@ -77,7 +77,7 @@ addManifestPlaceholders([
 #### 新方式
 
 - 远程 JSON 决定**接入哪些可选模块**（guest、email、facebook、google-iap、appsflyer 等）。  
-- 工具内置 [`meetsdk-android.json`](../meetsdk-android.json) 提供**固定** SDK 版本、仓库 URL、`classpath`、Firebase plugin、各模块 `dependencies`。  
+- 工具内置 [`config/meetsdk-android.json`](../../config/meetsdk-android.json) 提供**固定** SDK 版本、仓库 URL、`classpath`、Firebase plugin、各模块 `dependencies`。  
 - `integrate` 合并后写入根工程与 App Module 的 Gradle（标记块 upsert，避免重复插入）。
 
 **示例（由工具生成，非人工维护）**
@@ -143,19 +143,20 @@ dependencies {
 |------|------|
 | `--project-root` | 游戏工程根路径 |
 | `--app-id` | MG / TOPSDK 应用 ID |
+| `--app-secret` | 应用密钥，仅用于本地计算 `downloadSDKConfig` 的 `sign`，不会从本地缓存读取 |
 | `--channel-type` | 商店渠道：`GOOGLE` / `APPLE` 等（HTTP 查询参数，非 android/ios） |
 | `--env` | `prod` / `pre` / `test` |
 
-说明：`downloadSDKConfig` **无需** CLI 传 `appSecret`，密钥由接口写入 JSON 的 `topsdk.appSecret`。旧文档中的 `--app-secret` 仅适用于已废弃的 `getSDKConfig` 签名流程。
+说明：`downloadSDKConfig` **必须**带 `sign` / `timestamp`。`sign = base64(md5(appId + appSecret + timestamp))`，`appSecret` 通过 `--app-secret` 或 `TOPSDK_APP_SECRET` 传入，仅用于签名；工具不会从本地 `meetsdk-remote-config.json` 读取密钥再签名。
 
 ```bash
 # 仅拉配置
 meetgames fetch-config --project-root . \
-  --app-id "$SDK_APP_ID" --channel-type GOOGLE --env test
+  --app-id "$SDK_APP_ID" --app-secret "$SDK_APP_SECRET" --channel-type GOOGLE --env test
 
 # 拉配置 + 集成（推荐流水线）
 meetgames setup --project-root . \
-  --app-id "$SDK_APP_ID" --channel-type GOOGLE --env test
+  --app-id "$SDK_APP_ID" --app-secret "$SDK_APP_SECRET" --channel-type GOOGLE --env test
 
 # 仅集成（已有 meetsdk-remote-config.json）
 meetgames integrate --project-root . --dry-run
@@ -199,18 +200,18 @@ meetgames integrate --project-root . --dry-run
       "guest": {},
       "email": {},
       "facebook": {
-        "facebookAppId": "0000000000000000",
-        "fbLoginProtocolScheme": "fb0000000000000000",
-        "facebookClientToken": "mockfacebookclienttoken00000000"
+        "clientId": "0000000000000000",
+        "scheme": "fb0000000000000000",
+        "secret": "mockfacebookclienttoken00000000"
       },
-      "google": { "googleClientId": "mock-client-id.apps.googleusercontent.com" }
+      "google": { "clientId": "mock-client-id.apps.googleusercontent.com" }
     },
     "payment": { "googleIap": {} },
     "analytics": {
-      "appsflyer": { "enableDebugLog": true, "devKey": "MOCK_APPSFLYER_DEV_KEY" },
+      "appsflyer": { "devKey": "MOCK_APPSFLYER_DEV_KEY" },
       "facebookdata": {},
-      "firebase": { "firebase_file_url": "https://example.invalid/firebase/google-services.json" },
-      "adjust": { "appId": "MOCK_ADJUST_APP_ID" }
+      "firebase": { "firebaseUrl": "https://example.invalid/firebase/google-services.json" },
+      "adjust": { "appCode": "MOCK_ADJUST_APP_ID" }
     }
   }
 }
@@ -241,15 +242,15 @@ meetgames integrate --project-root . --dry-run
 | 项 | 内容 |
 |----|------|
 | **新接口** | `GET {baseUrl}console/openSDK/downloadSDKConfig` |
-| **Query** | `appId`、`channelType`（商店渠道，如 `GOOGLE` / `APPLE`） |
-| **鉴权** | 无需 sign |
+| **Query** | `appId`、`channelType`（商店渠道，如 `GOOGLE` / `APPLE`）、`sign`、`timestamp` |
+| **鉴权** | 必须带 `sign + timestamp`，签名算法与 `getSDKConfig` 一致 |
 | **响应** | 响应体即为 `meetsdk-remote-config.json` 全文（附件下载） |
 | **CLI** | `meetgames fetch-config` / `meetgames setup` |
 
 示例：
 
 ```http
-GET https://{api-sdk-gameplus-host}/console/openSDK/downloadSDKConfig?appId=791251136341225472&channelType=GOOGLE
+GET https://{api-sdk-gameplus-host}/console/openSDK/downloadSDKConfig?appId=791251136341225472&channelType=GOOGLE&sign=...&timestamp=...
 ```
 
 响应 JSON **必须**含根级 `channel`（与 `channelType` 查询值一致）、`devicePlatform`，且 **`topsdk` 内不含 `channel`**。
@@ -304,7 +305,7 @@ GET https://{api-sdk-gameplus-host}/console/openSDK/downloadSDKConfig?appId=7912
 |------|------|
 | 接口调用诊断 | 对约定 API 列表输出静态检查报告 |
 | Snapchat Manifest placeholders | 与 PRD 示例一致的 `addManifestPlaceholders` |
-| 三方配置文件原文件下载 | OSS 直链写入 JSON（如 `firebase_file_url`） |
+| 三方配置文件原文件下载 | OSS 直链写入 JSON（如 `firebaseUrl`） |
 | 接入客服 | 可回答 FAQ 范围内接入问题 |
 
 ---

package/package.json

@@ -1,51 +1,22 @@
 {
   "name": "@leonxin/meetgames",
-  "version": "0.1.8",
-  "description": "Meet SDK integration CLI: fetch remote config, patch Android Gradle/Manifest and iOS Xcode projects (dry-run, patch output, MCP)",
-  "type": "module",
+  "version": "0.1.12",
   "license": "MIT",
-  "author": "MeetSocial",
-  "keywords": [
-    "meetgames",
-    "meet-sdk",
-    "topsdk",
-    "android",
-    "ios",
-    "gradle",
-    "xcode",
-    "sdk-integration"
-  ],
-  "publishConfig": {
-    "access": "public"
-  },
+  "type": "module",
   "bin": {
-    "meetgames": "./dist/entry.js",
-    "meetgames-mcp": "./dist/mcp-entry.js"
+    "meetgames": "dist/entry.js",
+    "meetgames-mcp": "dist/mcp-entry.js"
   },
-  "files": [
-    "dist",
-    "schema",
-    "bundled/android",
-    "docs",
-    "recipes",
-    "fixtures",
-    "meetsdk-android.json"
-  ],
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "test": "vitest run",
-    "test:watch": "vitest",
-    "prepack": "npm run build",
-    "preview:integrate:android-latest": "npm run build -s && node dist/entry.js integrate --project-root test-projects/android-latest-project --dry-run --verbose --patch-file test-projects/_preview/cli-preview.patch",
-    "preview:integrate:power-raid": "npm run build -s && node dist/entry.js integrate --project-root test-projects/power-raid --dry-run --verbose --patch-file test-projects/_preview/power-raid-preview.patch",
-    "mcp:stdio": "npm run build -s && node dist/mcp-entry.js"
+    "test:mcp": "npm run build && npm run test:mcp:run",
+    "test:mcp:run": "vitest run --config vitest.mcp.config.ts",
+    "test:regression": "npm run build && npm test && npm run test:mcp:run"
   },
   "engines": {
     "node": ">=18"
   },
-  "overrides": {
-    "uuid": "^14.0.0"
-  },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
     "ajv": "^8.17.1",

package/recipes/android-default.yaml

@@ -8,8 +8,3 @@ steps:
     args:
       permissions:
         - android.permission.ACCESS_NETWORK_STATE
-  - op: files.copyBundled
-    platform: android
-    args:
-      from: android/sample.txt
-      to: vendor/meet-integrate/sample.txt

package/recipes/integrate-default.yaml

@@ -6,11 +6,6 @@ steps:
   - op: files.downloadGoogleServicesJson
     platform: android
     args: {}
-  - op: files.copyBundled
-    platform: android
-    args:
-      from: android/sample.txt
-      to: vendor/meet-integrate/sample.txt
   - op: ios.integrateTopSdk
     platform: ios
     args: {}

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 };
+}

package/src/android/gradle.ts

@@ -0,0 +1,116 @@
+export const START_REPO_MARKER = "// >>> MEET_INTEGRATE REPOS START";
+export const END_REPO_MARKER = "// >>> MEET_INTEGRATE REPOS END";
+export const START_BLOCK_MARKER = "// >>> MEET_INTEGRATE BLOCK START";
+export const END_BLOCK_MARKER = "// >>> MEET_INTEGRATE BLOCK END";
+
+export interface BlockRange {
+  start: number;
+  openBrace: number;
+  end: number;
+}
+
+export function findBlockRange(content: string, keyword: string, searchFrom = 0): BlockRange | null {
+  // Require `keyword {` so `com.android.application` / `androidx` are not matched.
+  const re = new RegExp(`\\b${keyword}\\s*\\{`);
+  const slice = content.slice(searchFrom);
+  const match = re.exec(slice);
+  if (!match || match.index === undefined) return null;
+  const keywordIndex = searchFrom + match.index;
+  const openBrace = content.indexOf("{", keywordIndex + match[0].length - 1);
+  if (openBrace < 0) return null;
+  let depth = 0;
+  for (let i = openBrace; i < content.length; i += 1) {
+    const ch = content[i];
+    if (ch === "{") depth += 1;
+    if (ch === "}") {
+      depth -= 1;
+      if (depth === 0) return { start: keywordIndex, openBrace, end: i };
+    }
+  }
+  return null;
+}
+
+export function replaceOrInsertManaged(
+  content: string,
+  blockRange: BlockRange,
+  startMarker: string,
+  endMarker: string,
+  snippet: string
+): string {
+  const blockText = content.slice(blockRange.openBrace + 1, blockRange.end);
+  const startInBlock = blockText.indexOf(startMarker);
+  const endInBlock = blockText.indexOf(endMarker);
+  const insertion = `${snippet}\n`;
+
+  if (startInBlock >= 0 && endInBlock > startInBlock) {
+    const before = blockText.slice(0, startInBlock).replace(/\s*$/, "\n");
+    const after = blockText.slice(endInBlock + endMarker.length).replace(/^\s*/, "\n");
+    const replaced = `${before}${snippet}${after}`;
+    return content.slice(0, blockRange.openBrace + 1) + replaced + content.slice(blockRange.end);
+  }
+
+  const prefix = content.slice(0, blockRange.end);
+  return prefix + insertion.trimEnd() + "\n" + content.slice(blockRange.end);
+}
+
+function buildRepoSnippet(urls: string[]): string {
+  const lines = [START_REPO_MARKER];
+  for (const url of urls) {
+    if (url === "google") lines.push("        google()");
+    else if (url === "mavenCentral") lines.push("        mavenCentral()");
+    else lines.push(`        maven { url '${url}' }`);
+  }
+  lines.push(END_REPO_MARKER);
+  return lines.join("\n");
+}
+
+export function updateRootBuildGradleRepositories(
+  content: string,
+  urls: string[]
+): { ok: true; content: string; changed: boolean; warnings: string[] } | { ok: false; error: string } {
+  const warnings: string[] = [];
+  const allprojects = findBlockRange(content, "allprojects");
+  if (!allprojects) {
+    return { ok: false, error: "allprojects block not found in root build.gradle" };
+  }
+  const repositoriesBlock = findBlockRange(content, "repositories", allprojects.start);
+  if (!repositoriesBlock || repositoriesBlock.end > allprojects.end) {
+    return { ok: false, error: "repositories block under allprojects not found" };
+  }
+
+  const snippet = buildRepoSnippet(urls || []);
+  const updated = replaceOrInsertManaged(
+    content,
+    repositoriesBlock,
+    START_REPO_MARKER,
+    END_REPO_MARKER,
+    snippet
+  );
+  if (updated === content) warnings.push("root build.gradle repositories unchanged");
+  return { ok: true, content: updated, changed: updated !== content, warnings };
+}
+
+function buildDependenciesSnippet(lines: string[]): string {
+  return [START_BLOCK_MARKER, ...lines, END_BLOCK_MARKER].join("\n");
+}
+
+export function updateModuleBuildGradleDependencies(
+  content: string,
+  dependencyLines: string[]
+): { ok: true; content: string; changed: boolean; warnings: string[] } | { ok: false; error: string } {
+  const warnings: string[] = [];
+  const dependenciesBlock = findBlockRange(content, "dependencies");
+  if (!dependenciesBlock) {
+    return { ok: false, error: "dependencies block not found in module build.gradle" };
+  }
+  const snippet = buildDependenciesSnippet(dependencyLines);
+  const updated = replaceOrInsertManaged(
+    content,
+    dependenciesBlock,
+    START_BLOCK_MARKER,
+    END_BLOCK_MARKER,
+    snippet
+  );
+  if (updated === content) warnings.push("module build.gradle dependencies unchanged");
+  return { ok: true, content: updated, changed: updated !== content, warnings };
+}

package/src/android/manifest.ts

@@ -0,0 +1,50 @@
+export const MANIFEST_PERM_START = "<!-- MEET_INTEGRATE PERMISSIONS START -->";
+export const MANIFEST_PERM_END = "<!-- MEET_INTEGRATE PERMISSIONS END -->";
+
+const PERMISSION_NAME_RE = /android:name="([^"]+)"/;
+
+export function extractPermissionName(line: string): string | null {
+  if (!line.includes("uses-permission")) return null;
+  const m = line.match(PERMISSION_NAME_RE);
+  return m?.[1] ?? null;
+}
+
+/** Remove <uses-permission> lines for the same android:name (inside or outside managed block). */
+export function removePermissionLinesByNames(content: string, names: ReadonlySet<string>): string {
+  return content
+    .split("\n")
+    .filter((line) => {
+      const name = extractPermissionName(line);
+      return !name || !names.has(name);
+    })
+    .join("\n");
+}
+
+function stripPermissionManagedBlock(content: string): string {
+  const start = content.indexOf(MANIFEST_PERM_START);
+  const end = content.indexOf(MANIFEST_PERM_END);
+  if (start >= 0 && end > start) {
+    return content.slice(0, start) + content.slice(end + MANIFEST_PERM_END.length);
+  }
+  return content;
+}
+
+export function insertPermissions(content: string, permissions: string[]): { content: string; changed: boolean } {
+  const names = new Set(permissions);
+  let cleaned = removePermissionLinesByNames(content, names);
+  cleaned = stripPermissionManagedBlock(cleaned);
+
+  const lines = [
+    MANIFEST_PERM_START,
+    ...permissions.map((p) => `    <uses-permission android:name="${p}" />`),
+    MANIFEST_PERM_END,
+  ].join("\n");
+
+  const closeManifest = cleaned.lastIndexOf("</manifest>");
+  if (closeManifest < 0) {
+    return { content, changed: false };
+  }
+  const insert = `\n${lines}\n`;
+  const updated = cleaned.slice(0, closeManifest) + insert + cleaned.slice(closeManifest);
+  return { content: updated, changed: updated !== content };
+}