@leonxin/meetgames 0.1.18 → 0.1.19

package/tests/gradle.test.ts

@@ -1,33 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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";
-import { MEET_SDK_TOOL_CACHE_ROOT } from "../src/cache.js";
-
-const pkgRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-
-describe("resolveIosSdkRoot", () => {
-  it("uses only the iOS SDK cache", () => {
-    try {
-      const root = resolveIosSdkRoot(pkgRoot);
-      expect(root).toContain(`${path.sep}.cache${path.sep}meet-sdk-tool${path.sep}sdk${path.sep}ios`);
-      expect(fs.existsSync(path.join(root, "sdk", "topsdkConfig.t.json"))).toBe(true);
-      expect(fs.existsSync(path.join(root, "plugins"))).toBe(true);
-    } catch (e) {
-      expect(e instanceof Error ? e.message : String(e)).toContain(path.join(MEET_SDK_TOOL_CACHE_ROOT, "sdk", "ios"));
-    }
-  });
-});

package/tests/loadManifest.test.ts

@@ -1,15 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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"');
-  });
-});

package/tests/mcp.e2e.ts

@@ -1,214 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-
-const here = path.dirname(fileURLToPath(import.meta.url));
-const pkgRoot = path.resolve(here, "..");
-const androidFixtureRoot = path.join(pkgRoot, "fixtures", "android-test-project", "android-latest-project");
-const remoteConfigFixture = path.join(pkgRoot, "fixtures", "meetsdk-remote-config.mock.json");
-const mcpEntry = path.join(pkgRoot, "dist", "mcp-entry.js");
-
-function copyAndroidProjectToTemp(): string {
-  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "meet-mcp-e2e-"));
-  const projectRoot = path.join(tmpRoot, "android-project");
-  fs.cpSync(androidFixtureRoot, projectRoot, { recursive: true });
-  return projectRoot;
-}
-
-function createMockFetchPreload(): { path: string; cleanup: () => void } {
-  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "meet-mcp-fetch-"));
-  const preloadPath = path.join(tmpRoot, "mock-fetch.mjs");
-  const remoteConfigText = fs.readFileSync(remoteConfigFixture, "utf8");
-  const preload = `
-const remoteConfigText = ${JSON.stringify(remoteConfigText)};
-const sdkHomeVersionResponse = {
-  code: 200,
-  data: {
-    result: {
-      android: { ver: "1.6.1.3", date: "2026-05-25" },
-      ios: { ver: "1.6.0.5", date: "2026-06-09" }
-    }
-  }
-};
-
-function jsonResponse(body) {
-  return new Response(JSON.stringify(body, null, 2), {
-    status: 200,
-    headers: { "content-type": "application/json; charset=utf-8" }
-  });
-}
-
-globalThis.fetch = async (input) => {
-  const url = new URL(typeof input === "string" ? input : input.url);
-  if (url.pathname === "/sdk/home/version") {
-    return jsonResponse(sdkHomeVersionResponse);
-  }
-  if (url.pathname === "/console/openSDK/downloadSDKConfig") {
-    return new Response(remoteConfigText, {
-      status: 200,
-      headers: { "content-type": "application/json; charset=utf-8" }
-    });
-  }
-  if (url.pathname === "/firebase/google-services.json" || url.pathname.endsWith(".json")) {
-    return jsonResponse({ project_info: { project_id: "mock-project" }, client: [] });
-  }
-  return new Response("Unhandled mock route: " + url.pathname, { status: 404 });
-};
-`;
-  fs.writeFileSync(preloadPath, preload);
-  return {
-    path: preloadPath,
-    cleanup: () => fs.rmSync(tmpRoot, { recursive: true, force: true }),
-  };
-}
-
-function childEnv(baseUrl: string, preloadPath: string): Record<string, string> {
-  const env = Object.fromEntries(
-    Object.entries(process.env).filter((entry): entry is [string, string] => typeof entry[1] === "string")
-  );
-  const preloadOption = `--import=${pathToFileURL(preloadPath).href}`;
-  return {
-    ...env,
-    NODE_OPTIONS: [env.NODE_OPTIONS, preloadOption].filter(Boolean).join(" "),
-    TOPSDK_API_BASE_URL: baseUrl,
-    MEETGAMES_SDK_HOME_API_BASE_URL: baseUrl,
-  };
-}
-
-async function connectMcpClient(baseUrl: string, preloadPath: string): Promise<Client> {
-  const client = new Client({ name: "meet-sdk-tool-mcp-e2e", version: "1.0.0" });
-  const transport = new StdioClientTransport({
-    command: process.execPath,
-    args: [mcpEntry],
-    cwd: pkgRoot,
-    env: childEnv(baseUrl, preloadPath),
-    stderr: "pipe",
-  });
-  await client.connect(transport);
-  return client;
-}
-
-function structured(result: Awaited<ReturnType<Client["callTool"]>>): Record<string, unknown> {
-  expect("structuredContent" in result).toBe(true);
-  const data = "structuredContent" in result ? result.structuredContent : undefined;
-  expect(data).toBeTruthy();
-  return data as Record<string, unknown>;
-}
-
-describe("meetgames MCP stdio server", () => {
-  const mockBaseUrl = "https://meet-sdk-tool-mcp-e2e.invalid";
-  let mockFetchPreload: ReturnType<typeof createMockFetchPreload>;
-  let client: Client;
-  const tmpRoots: string[] = [];
-
-  beforeEach(async () => {
-    expect(fs.existsSync(mcpEntry)).toBe(true);
-    mockFetchPreload = createMockFetchPreload();
-    client = await connectMcpClient(mockBaseUrl, mockFetchPreload.path);
-  });
-
-  afterEach(async () => {
-    await client?.close().catch(() => undefined);
-    mockFetchPreload?.cleanup();
-    for (const root of tmpRoots.splice(0)) {
-      fs.rmSync(root, { recursive: true, force: true });
-    }
-  });
-
-  it("lists all public meetgames tools", async () => {
-    const { tools } = await client.listTools();
-    expect(tools.map((tool) => tool.name).sort()).toEqual([
-      "meetgames_doctor",
-      "meetgames_fetch_config",
-      "meetgames_integrate_apply",
-      "meetgames_integrate_dry_run",
-      "meetgames_setup",
-    ]);
-  });
-
-  it("runs doctor and integrate dry-run through stdio", async () => {
-    const projectRoot = copyAndroidProjectToTemp();
-    tmpRoots.push(path.dirname(projectRoot));
-
-    const doctor = structured(
-      await client.callTool({
-        name: "meetgames_doctor",
-        arguments: { projectRoot, appTarget: "app" },
-      })
-    );
-    expect(doctor.projectRoot).toBe(projectRoot);
-    expect(doctor.platform).toBe("android");
-    expect((doctor.android as { moduleName?: string }).moduleName).toBe(":app");
-
-    const dryRun = structured(
-      await client.callTool({
-        name: "meetgames_integrate_dry_run",
-        arguments: { projectRoot, appTarget: "app" },
-      })
-    );
-    expect(dryRun.dryRun).toBe(true);
-    expect(dryRun.hasErrors).toBe(false);
-    expect(String(dryRun.patch)).toContain("TOPSDK AUTO");
-  });
-
-  it("runs fetch-config and setup dry-run through stdio", async () => {
-    const projectRoot = copyAndroidProjectToTemp();
-    tmpRoots.push(path.dirname(projectRoot));
-    fs.rmSync(path.join(projectRoot, "meetsdk-remote-config.json"), { force: true });
-
-    const fetched = structured(
-      await client.callTool({
-        name: "meetgames_fetch_config",
-        arguments: {
-          projectRoot,
-          env: "test",
-          appId: "mock-topsdk-app-id",
-          appSecret: "mock-secret",
-          channelType: "GOOGLE",
-        },
-      })
-    );
-    expect(fetched.env).toBe("test");
-    expect(String(fetched.requestUrl)).toContain("/console/openSDK/downloadSDKConfig");
-    expect(fs.existsSync(path.join(projectRoot, "meetsdk-remote-config.json"))).toBe(false);
-    expect(fs.readFileSync(String(fetched.outputPath), "utf8")).toBe(fs.readFileSync(remoteConfigFixture, "utf8"));
-
-    const setup = structured(
-      await client.callTool({
-        name: "meetgames_setup",
-        arguments: {
-          projectRoot,
-          env: "test",
-          appId: "mock-topsdk-app-id",
-          appSecret: "mock-secret",
-          channelType: "GOOGLE",
-          appTarget: "app",
-          dryRun: true,
-        },
-      })
-    );
-    expect((setup.fetch as { env?: string }).env).toBe("test");
-    expect((setup.integrate as { dryRun?: boolean; hasErrors?: boolean }).dryRun).toBe(true);
-    expect((setup.integrate as { dryRun?: boolean; hasErrors?: boolean }).hasErrors).toBe(false);
-  });
-
-  it("runs integrate apply through stdio against a temporary fixture", async () => {
-    const projectRoot = copyAndroidProjectToTemp();
-    tmpRoots.push(path.dirname(projectRoot));
-
-    const applied = structured(
-      await client.callTool({
-        name: "meetgames_integrate_apply",
-        arguments: { projectRoot, appTarget: "app" },
-      })
-    );
-    expect(applied.dryRun).toBe(false);
-    expect((applied.report as { errors?: string[] }).errors).toEqual([]);
-    expect(applied.hasErrors).toBe(false);
-    expect(fs.readFileSync(path.join(projectRoot, "app", "build.gradle"), "utf8")).toContain("TOPSDK AUTO");
-  });
-});

package/tests/mcp.service.test.ts

@@ -1,53 +0,0 @@
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { meetgamesDoctor, meetgamesIntegrate } from "../src/mcp/service.js";
-
-const here = path.dirname(fileURLToPath(import.meta.url));
-const pkgRoot = path.resolve(here, "..");
-const androidLatestRoot = path.join(pkgRoot, "fixtures", "android-test-project", "android-latest-project");
-
-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("mcp service", () => {
-  beforeEach(() => {
-    stubSdkHomeVersion();
-  });
-
-  afterEach(() => {
-    vi.unstubAllGlobals();
-  });
-
-  it("doctor returns android detection summary", () => {
-    const summary = meetgamesDoctor({ projectRoot: androidLatestRoot, appTarget: "app" });
-    expect(summary.projectRoot).toBe(androidLatestRoot);
-    expect((summary.android as { ok: boolean }).ok).toBe(true);
-    expect((summary.android as { moduleName: string }).moduleName).toBe(":app");
-  });
-
-  it("integrate dry-run returns patch and no errors", async () => {
-    const result = await meetgamesIntegrate({ projectRoot: androidLatestRoot, dryRun: true });
-    expect(result.dryRun).toBe(true);
-    expect(result.patch.length).toBeGreaterThan(0);
-    const report = result.report as { errors: string[] };
-    expect(report.errors).toEqual([]);
-  });
-});