@leonxin/meetgames 0.1.8 → 0.1.11

package/src/mcp/server.ts

@@ -0,0 +1,170 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import * as z from "zod";
+import { meetgamesDoctor, meetgamesFetchConfig, meetgamesIntegrate, meetgamesSetup } from "./service.js";
+
+function toErrorResult(error: unknown) {
+  const message = error instanceof Error ? error.message : String(error);
+  return {
+    content: [{ type: "text" as const, text: `Error: ${message}` }],
+    isError: true,
+  };
+}
+
+function toSuccessResult<T extends Record<string, unknown>>(data: T) {
+  return {
+    content: [{ type: "text" as const, text: JSON.stringify(data, null, 2) }],
+    structuredContent: data,
+  };
+}
+
+export function createMeetgamesMcpServer(): McpServer {
+  const server = new McpServer({
+    name: "meetgames-mcp",
+    version: "0.1.0",
+  });
+
+  server.registerTool(
+    "meetgames_doctor",
+    {
+      description: "Inspect project workspace and return Android/iOS detection summary.",
+      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."),
+      },
+    },
+    async ({ projectRoot, appTarget }) => {
+      try {
+        return toSuccessResult(meetgamesDoctor({ projectRoot, appTarget }));
+      } catch (error) {
+        return toErrorResult(error);
+      }
+    }
+  );
+
+  server.registerTool(
+    "meetgames_fetch_config",
+    {
+      description:
+        "Download TOPSDK meetsdk-remote-config.json via downloadSDKConfig and write it into project root.",
+      inputSchema: {
+        projectRoot: z.string().optional().describe("Absolute or relative project root; default is current working directory."),
+        env: z.enum(["prod", "pre", "test"]).optional().describe("TOPSDK API environment."),
+        appId: z.string().optional().describe("Application id; required if not in local config."),
+        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."),
+      },
+    },
+    async ({ projectRoot, env, appId, appSecret, channelType }) => {
+      try {
+        const result = await meetgamesFetchConfig({
+          projectRoot,
+          env,
+          appId,
+          appSecret,
+          channelType,
+        });
+        return toSuccessResult(result);
+      } catch (error) {
+        return toErrorResult(error);
+      }
+    }
+  );
+
+  server.registerTool(
+    "meetgames_integrate_dry_run",
+    {
+      description: "Run integrate with built-in recipe in dry-run mode and return report + patch.",
+      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."),
+      },
+    },
+    async ({ projectRoot, appTarget }) => {
+      try {
+        const result = await meetgamesIntegrate({ projectRoot, appTarget, dryRun: true });
+        if (result.hasErrors) {
+          return {
+            ...toSuccessResult(result),
+            isError: true,
+          };
+        }
+        return toSuccessResult(result);
+      } catch (error) {
+        return toErrorResult(error);
+      }
+    }
+  );
+
+  server.registerTool(
+    "meetgames_integrate_apply",
+    {
+      description: "Run integrate with built-in recipe and write changes to disk.",
+      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."),
+      },
+    },
+    async ({ projectRoot, appTarget }) => {
+      try {
+        const result = await meetgamesIntegrate({ projectRoot, appTarget, dryRun: false });
+        if (result.hasErrors) {
+          return {
+            ...toSuccessResult(result),
+            isError: true,
+          };
+        }
+        return toSuccessResult(result);
+      } catch (error) {
+        return toErrorResult(error);
+      }
+    }
+  );
+
+  server.registerTool(
+    "meetgames_setup",
+    {
+      description:
+        "Download meetsdk-remote-config.json then run default integrate recipe (fetch-config + integrate).",
+      inputSchema: {
+        projectRoot: z.string().optional().describe("Absolute or relative project root; default is current working directory."),
+        env: z.enum(["prod", "pre", "test"]).optional().describe("TOPSDK API environment."),
+        appId: z.string().optional().describe("Application id; required if not in local config."),
+        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."),
+        dryRun: z.boolean().optional().describe("If true, integrate step previews only; fetch always writes config."),
+      },
+    },
+    async ({ projectRoot, env, appId, appSecret, channelType, appTarget, dryRun }) => {
+      try {
+        const result = await meetgamesSetup({
+          projectRoot,
+          appTarget,
+          env,
+          appId,
+          appSecret,
+          channelType,
+          dryRun: dryRun ?? false,
+        });
+        if (result.integrate.hasErrors) {
+          return {
+            ...toSuccessResult(result),
+            isError: true,
+          };
+        }
+        return toSuccessResult(result);
+      } catch (error) {
+        return toErrorResult(error);
+      }
+    }
+  );
+
+  return server;
+}
+
+export async function startMeetgamesMcpServer(): Promise<void> {
+  const server = createMeetgamesMcpServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}

package/src/mcp/service.ts

@@ -0,0 +1,222 @@
+import fs from "node:fs";
+import path from "node:path";
+import { loadManifestFile } from "../config/loadManifest.js";
+import {
+  MEETSDK_REMOTE_CONFIG_FILENAME,
+  readMeetSdkRemoteChannel,
+  tryParseAsMeetSdkRemoteConfig,
+  type MeetSdkRemoteConfig,
+} from "../config/meetSdkRemoteConfig.js";
+import {
+  validateDownloadSdkConfigForWrite,
+  writeDownloadSdkConfigRaw,
+} from "../config/fetchConfigWrite.js";
+import type { PipelineReport } from "../contracts/types.js";
+import type { BinaryCopy } from "../ops/handlers.js";
+import { runPipeline } from "../core/pipeline.js";
+import {
+  detectSinglePlatform,
+  manifestForPlatform,
+  platformContext,
+  type DetectedPlatform,
+} from "../core/platform.js";
+import { buildWorkspaceContext, resolvePackageRoot } from "../core/workspace.js";
+import { defaultTopSdkBaseUrl, fetchTopSdkDownloadSdkConfig, type TopSdkApiEnv } from "../remote/topsdkDownloadSdkConfig.js";
+
+const DEFAULT_MANIFEST_REL = "recipes/integrate-default.yaml";
+
+function ensureProjectRoot(projectRoot?: string): string {
+  const root = path.resolve(projectRoot?.trim() || process.cwd());
+  if (!fs.existsSync(root) || !fs.statSync(root).isDirectory()) {
+    throw new Error(`project root does not exist or is not a directory: ${root}`);
+  }
+  return root;
+}
+
+function readLocalMeetSdkRemoteConfig(projectRoot: string): MeetSdkRemoteConfig | null {
+  const configPath = path.join(projectRoot, MEETSDK_REMOTE_CONFIG_FILENAME);
+  if (!fs.existsSync(configPath)) return null;
+  try {
+    return tryParseAsMeetSdkRemoteConfig(JSON.parse(fs.readFileSync(configPath, "utf8")) as unknown);
+  } catch {
+    return null;
+  }
+}
+
+function ensureDefaultManifestPath(packageRoot: string): string {
+  const manifestPath = path.join(packageRoot, DEFAULT_MANIFEST_REL);
+  if (!fs.existsSync(manifestPath)) {
+    throw new Error(`default manifest not found: ${manifestPath}`);
+  }
+  return manifestPath;
+}
+
+function ensureSinglePlatformContext(
+  projectRoot: string,
+  packageRoot: string,
+  appTarget?: string
+): {
+  platform: DetectedPlatform;
+  ctx: ReturnType<typeof buildWorkspaceContext>;
+} {
+  const detectedCtx = buildWorkspaceContext(projectRoot, packageRoot, { appTarget });
+  const detected = detectSinglePlatform(detectedCtx);
+  if (!detected.ok) throw new Error(detected.error);
+  const platformCtx = platformContext(detectedCtx, detected.platform);
+  return {
+    platform: detected.platform,
+    ctx: platformCtx,
+  };
+}
+
+function resolveAppTarget(params: { appTarget?: string }): string | undefined {
+  return params.appTarget?.trim() || undefined;
+}
+
+export function meetgamesDoctor(params: { projectRoot?: string; appTarget?: string }): {
+  projectRoot: string;
+  packageRoot: string;
+  platform: DetectedPlatform;
+  android?: object;
+  ios?: object;
+  iosReserved?: object;
+} {
+  const projectRoot = ensureProjectRoot(params.projectRoot);
+  const packageRoot = resolvePackageRoot();
+  const { platform, ctx } = ensureSinglePlatformContext(
+    projectRoot,
+    packageRoot,
+    resolveAppTarget(params)
+  );
+  const out: {
+    projectRoot: string;
+    packageRoot: string;
+    platform: DetectedPlatform;
+    android?: object;
+    ios?: object;
+    iosReserved?: object;
+  } = {
+    projectRoot: ctx.projectRoot,
+    packageRoot: ctx.packageRoot,
+    platform,
+  };
+  if (platform === "android") out.android = ctx.android;
+  if (platform === "ios") {
+    out.ios = ctx.ios;
+    out.iosReserved = ctx.iosReserved;
+  }
+  return out;
+}
+
+export async function meetgamesFetchConfig(params: {
+  projectRoot?: string;
+  env?: TopSdkApiEnv;
+  appId?: string;
+  appSecret?: string;
+  channelType?: string;
+}): Promise<{
+  outputPath: string;
+  requestUrl: string;
+  env: TopSdkApiEnv;
+  warnings: string[];
+}> {
+  const projectRoot = ensureProjectRoot(params.projectRoot);
+  const out = path.join(projectRoot, MEETSDK_REMOTE_CONFIG_FILENAME);
+  const localConfig = readLocalMeetSdkRemoteConfig(projectRoot);
+
+  const appId = params.appId || localConfig?.topsdk.appId || process.env.TOPSDK_APP_ID || "";
+  const appSecret = params.appSecret || process.env.TOPSDK_APP_SECRET || "";
+  const channelType =
+    params.channelType ||
+    (localConfig ? readMeetSdkRemoteChannel(localConfig) : "") ||
+    process.env.TOPSDK_CHANNEL_TYPE ||
+    "";
+  const env = params.env ?? "prod";
+  const warnings: string[] = [];
+
+  if (!appId || !channelType || !appSecret) {
+    throw new Error(
+      `fetch-config requires appId, appSecret, and channelType (appSecret via appSecret param or TOPSDK_APP_SECRET only; not from ${MEETSDK_REMOTE_CONFIG_FILENAME}).`
+    );
+  }
+
+  const baseUrl = process.env.TOPSDK_API_BASE_URL?.trim() || defaultTopSdkBaseUrl(env);
+  const res = await fetchTopSdkDownloadSdkConfig({
+    baseUrl,
+    appId,
+    appSecret,
+    channelType,
+  });
+  const validation = validateDownloadSdkConfigForWrite(res.body);
+  if (!validation) {
+    throw new Error(`downloadSDKConfig response is not a valid ${MEETSDK_REMOTE_CONFIG_FILENAME} document`);
+  }
+  warnings.push(...validation.warnings);
+
+  writeDownloadSdkConfigRaw(out, res.text);
+  return { outputPath: out, requestUrl: res.url, env, warnings };
+}
+
+export async function meetgamesIntegrate(params: {
+  projectRoot?: string;
+  appTarget?: string;
+  dryRun: boolean;
+}): Promise<{
+  dryRun: boolean;
+  manifestPath: string;
+  report: PipelineReport;
+  patch: string;
+  binaryCopies: BinaryCopy[];
+  hasErrors: boolean;
+}> {
+  const projectRoot = ensureProjectRoot(params.projectRoot);
+  const packageRoot = resolvePackageRoot();
+  const manifestPath = ensureDefaultManifestPath(packageRoot);
+  const manifest = loadManifestFile(manifestPath);
+  const { platform, ctx } = ensureSinglePlatformContext(
+    projectRoot,
+    packageRoot,
+    resolveAppTarget(params)
+  );
+  const { report, patch, binaryCopies } = await runPipeline(ctx, manifestForPlatform(manifest, platform), { dryRun: params.dryRun });
+  return {
+    dryRun: params.dryRun,
+    manifestPath,
+    report,
+    patch,
+    binaryCopies,
+    hasErrors: report.errors.length > 0,
+  };
+}
+
+/** 先 downloadSDKConfig 落盘，再跑默认 integrate 配方（与 CLI `setup` 一致）。 */
+export async function meetgamesSetup(params: {
+  projectRoot?: string;
+  appTarget?: string;
+  env?: TopSdkApiEnv;
+  appId?: string;
+  appSecret?: string;
+  channelType?: string;
+  dryRun: boolean;
+}): Promise<{
+  fetch: Awaited<ReturnType<typeof meetgamesFetchConfig>>;
+  integrate: Awaited<ReturnType<typeof meetgamesIntegrate>>;
+}> {
+  const projectRoot = ensureProjectRoot(params.projectRoot);
+  const packageRoot = resolvePackageRoot();
+  const appTarget = resolveAppTarget(params);
+  ensureSinglePlatformContext(projectRoot, packageRoot, appTarget);
+  const fetch = await meetgamesFetchConfig({
+    projectRoot,
+    env: params.env,
+    appId: params.appId,
+    appSecret: params.appSecret,
+    channelType: params.channelType,
+  });
+  const integrate = await meetgamesIntegrate({
+    projectRoot,
+    appTarget,
+    dryRun: params.dryRun,
+  });
+  return { fetch, integrate };
+}

package/src/mcp-entry.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { startMeetgamesMcpServer } from "./mcp/server.js";
+
+startMeetgamesMcpServer().catch((err: unknown) => {
+  console.error(err);
+  process.exit(1);
+});

package/src/ops/fileStore.ts

@@ -0,0 +1,56 @@
+import fs from "node:fs";
+import path from "node:path";
+
+/** Tracks text file originals and pending content for dry-run / apply */
+export class TextFileStore {
+  private readonly projectRoot: string;
+  private readonly map = new Map<string, { original: string; current: string }>();
+
+  constructor(projectRoot: string) {
+    this.projectRoot = projectRoot;
+  }
+
+  rel(abs: string): string {
+    return path.relative(this.projectRoot, abs).split(path.sep).join("/");
+  }
+
+  read(rel: string): string {
+    const existing = this.map.get(rel);
+    if (existing) return existing.current;
+    const abs = path.join(this.projectRoot, rel);
+    if (!fs.existsSync(abs)) return "";
+    const content = fs.readFileSync(abs, "utf8");
+    this.map.set(rel, { original: content, current: content });
+    return content;
+  }
+
+  write(rel: string, content: string): void {
+    const abs = path.join(this.projectRoot, rel);
+    const existing = this.map.get(rel);
+    if (existing) {
+      existing.current = content;
+      return;
+    }
+    let original = "";
+    if (fs.existsSync(abs)) original = fs.readFileSync(abs, "utf8");
+    this.map.set(rel, { original, current: content });
+  }
+
+  /** Files where current !== original */
+  changedEntries(): Array<{ rel: string; original: string; current: string }> {
+    const out: Array<{ rel: string; original: string; current: string }> = [];
+    for (const [rel, v] of this.map) {
+      if (v.current !== v.original) out.push({ rel, original: v.original, current: v.current });
+    }
+    return out;
+  }
+
+  flushToDisk(): void {
+    for (const [rel, v] of this.map) {
+      if (v.current === v.original) continue;
+      const abs = path.join(this.projectRoot, rel);
+      fs.mkdirSync(path.dirname(abs), { recursive: true });
+      fs.writeFileSync(abs, v.current, "utf8");
+    }
+  }
+}