npm - admob-mcp-server - Versions diffs - 0.1.0 - Mend

admob-mcp-server 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (22) hide show

package/LICENSE +21 -0
package/README.ko.md +410 -0
package/README.md +409 -0
package/dist/admob/client.js +21 -0
package/dist/admob/constants.js +86 -0
package/dist/admob/reports.js +81 -0
package/dist/auth/index.js +70 -0
package/dist/auth/oauth-flow.js +123 -0
package/dist/config.js +115 -0
package/dist/index.js +30 -0
package/dist/prompts.js +46 -0
package/dist/resources.js +60 -0
package/dist/server.js +33 -0
package/dist/toolsets/accounts.js +33 -0
package/dist/toolsets/adunits.js +62 -0
package/dist/toolsets/apps.js +52 -0
package/dist/toolsets/common.js +49 -0
package/dist/toolsets/index.js +17 -0
package/dist/toolsets/mediation.js +259 -0
package/dist/toolsets/reports.js +108 -0
package/dist/version.js +4 -0
package/package.json +66 -0

package/dist/auth/oauth-flow.js ADDED Viewed

@@ -0,0 +1,123 @@
+import { spawn } from 'node:child_process';
+import { promises as fs } from 'node:fs';
+import { createServer } from 'node:http';
+import { join } from 'node:path';
+import { OAuth2Client } from 'googleapis-common';
+import { requiredScopes, tokenPath } from './index.js';
+async function readClientKeysFile(path) {
+    let raw;
+    try {
+        raw = await fs.readFile(path, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        const keys = parsed.installed ?? parsed.web;
+        if (keys?.client_id && keys?.client_secret) {
+            return { clientId: keys.client_id, clientSecret: keys.client_secret };
+        }
+    }
+    catch {
+        // fall through to the error below
+    }
+    throw new Error(`${path} is not a valid OAuth client JSON. Download it from https://console.cloud.google.com/apis/credentials (application type: Desktop app).`);
+}
+async function loadClientKeys(config) {
+    if (config.googleClientId && config.googleClientSecret) {
+        return { clientId: config.googleClientId, clientSecret: config.googleClientSecret };
+    }
+    const defaultPath = join(config.credentialsDir, 'oauth_client.json');
+    const path = config.oauthClientFile ?? defaultPath;
+    const keys = await readClientKeysFile(path);
+    if (keys)
+        return keys;
+    throw new Error(`No OAuth client found. Either:
+- save your OAuth client JSON as ${defaultPath} (or pass --client-file <path>), or
+- set GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRET.
+Create one at https://console.cloud.google.com/apis/credentials (application type: Desktop app).`);
+}
+function openBrowser(url) {
+    const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'cmd' : 'xdg-open';
+    const args = process.platform === 'win32' ? ['/c', 'start', '""', url.replace(/&/g, '^&')] : [url];
+    const child = spawn(cmd, args, { stdio: 'ignore', detached: true });
+    // The URL is also printed to the terminal, so a failed launch is not fatal.
+    child.on('error', () => { });
+    child.unref();
+}
+function resultHtml(message) {
+    return `<html><body style="font-family: system-ui, sans-serif; text-align: center; padding-top: 4rem;">
+<h2>admob-mcp-server</h2><p>${message}</p></body></html>`;
+}
+async function waitForAuthorizationCode(server) {
+    try {
+        return await new Promise((resolve, reject) => {
+            server.on('request', (req, res) => {
+                const url = new URL(req.url ?? '/', 'http://127.0.0.1');
+                if (url.pathname !== '/oauth2callback') {
+                    res.writeHead(404);
+                    res.end();
+                    return;
+                }
+                const error = url.searchParams.get('error');
+                const code = url.searchParams.get('code');
+                res.writeHead(200, { 'Content-Type': 'text/html' });
+                if (error) {
+                    res.end(resultHtml(`Authorization failed: ${error}. You can close this tab.`));
+                    reject(new Error(`Authorization failed: ${error}`));
+                }
+                else if (code) {
+                    res.end(resultHtml('Authentication complete. You can close this tab and return to the terminal.'));
+                    resolve(code);
+                }
+                else {
+                    res.end(resultHtml('Missing authorization code. You can close this tab.'));
+                    reject(new Error('Authorization callback did not include a code'));
+                }
+            });
+        });
+    }
+    finally {
+        server.closeAllConnections();
+        server.close();
+    }
+}
+export async function runAuthFlow(config) {
+    const keys = await loadClientKeys(config);
+    const scopes = requiredScopes(config.readOnly);
+    const server = createServer();
+    await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+    const { port } = server.address();
+    const client = new OAuth2Client({
+        clientId: keys.clientId,
+        clientSecret: keys.clientSecret,
+        redirectUri: `http://127.0.0.1:${port}/oauth2callback`,
+    });
+    // select_account forces the account chooser so the browser's default
+    // Google account is not silently reused.
+    const authUrl = client.generateAuthUrl({
+        access_type: 'offline',
+        prompt: 'consent select_account',
+        scope: scopes,
+    });
+    console.error(`Requesting scopes:\n  ${scopes.join('\n  ')}\n`);
+    console.error(`Opening your browser to sign in. If it does not open, visit:\n\n${authUrl}\n`);
+    openBrowser(authUrl);
+    const code = await waitForAuthorizationCode(server);
+    const { tokens } = await client.getToken(code);
+    if (!tokens.refresh_token) {
+        throw new Error('Google did not return a refresh token. Remove this app\'s previous access at https://myaccount.google.com/permissions and run "auth" again.');
+    }
+    await fs.mkdir(config.credentialsDir, { recursive: true });
+    const file = tokenPath(config);
+    const saved = {
+        type: 'authorized_user',
+        client_id: keys.clientId,
+        client_secret: keys.clientSecret,
+        refresh_token: tokens.refresh_token,
+    };
+    await fs.writeFile(file, `${JSON.stringify(saved, null, 2)}\n`, { mode: 0o600 });
+    console.error(`\nSaved credentials to ${file}`);
+    console.error('Setup complete. Add admob-mcp-server to your MCP client — see the README for examples.');
+}

package/dist/config.js ADDED Viewed

@@ -0,0 +1,115 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+export const TOOLSET_NAMES = ['accounts', 'apps', 'adunits', 'reports', 'mediation'];
+export const USAGE = `admob-mcp-server — MCP server for the Google AdMob API
+Usage:
+  admob-mcp-server [flags]        Start the MCP server on stdio
+  admob-mcp-server auth [flags]   Sign in with Google in your browser and save credentials
+Flags:
+  --toolsets <names>    Comma-separated toolsets to enable (default: all)
+                        Available: ${TOOLSET_NAMES.join(', ')}
+  --read-only           Skip write tools (create/update) and, for "auth",
+                        request only the read scopes. Default: all tools
+  --account <pub-id>    AdMob publisher ID (e.g. pub-1234567890123456).
+                        Default: auto-discovered from the authenticated account
+  --client-file <path>  OAuth client JSON file for the "auth" flow
+  -h, --help            Show this help
+  -v, --version         Show version
+Environment variables:
+  ADMOB_ACCOUNT           Same as --account
+  ADMOB_TOOLSETS          Same as --toolsets
+  ADMOB_READ_ONLY         Set to "true" to skip write tools
+  ADMOB_CREDENTIALS_DIR   Where token.json is stored (default: ~/.admob-mcp)
+  ADMOB_OAUTH_CLIENT_FILE Same as --client-file
+  GOOGLE_CLIENT_ID        OAuth client ID (with GOOGLE_CLIENT_SECRET + GOOGLE_REFRESH_TOKEN,
+  GOOGLE_CLIENT_SECRET    used directly without token.json)
+  GOOGLE_REFRESH_TOKEN
+`;
+function parseToolsets(raw) {
+    const names = raw
+        .split(',')
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+    if (names.length === 0) {
+        throw new Error('--toolsets requires at least one toolset name');
+    }
+    for (const name of names) {
+        if (!TOOLSET_NAMES.includes(name)) {
+            throw new Error(`Unknown toolset "${name}". Available toolsets: ${TOOLSET_NAMES.join(', ')}`);
+        }
+    }
+    return names;
+}
+function normalizeAccountId(raw) {
+    return raw.startsWith('accounts/') ? raw.slice('accounts/'.length) : raw;
+}
+export function parseCli(argv, env = process.env) {
+    let command = 'serve';
+    let toolsets;
+    let readOnly = env.ADMOB_READ_ONLY === 'true' || env.ADMOB_READ_ONLY === '1';
+    let accountId = env.ADMOB_ACCOUNT;
+    let oauthClientFile = env.ADMOB_OAUTH_CLIENT_FILE;
+    let i = 0;
+    while (i < argv.length) {
+        const arg = argv[i];
+        i++;
+        if (arg === undefined)
+            continue;
+        const eq = arg.indexOf('=');
+        const flag = eq === -1 ? arg : arg.slice(0, eq);
+        const inline = eq === -1 ? undefined : arg.slice(eq + 1);
+        const takeValue = () => {
+            if (inline !== undefined)
+                return inline;
+            const next = argv[i];
+            if (next === undefined)
+                throw new Error(`Missing value for ${flag}`);
+            i++;
+            return next;
+        };
+        switch (flag) {
+            case 'auth':
+                command = 'auth';
+                break;
+            case '--help':
+            case '-h':
+                command = 'help';
+                break;
+            case '--version':
+            case '-v':
+                command = 'version';
+                break;
+            case '--toolsets':
+                toolsets = parseToolsets(takeValue());
+                break;
+            case '--read-only':
+                readOnly = true;
+                break;
+            case '--account':
+                accountId = takeValue();
+                break;
+            case '--client-file':
+                oauthClientFile = takeValue();
+                break;
+            default:
+                throw new Error(`Unknown argument "${flag}". Run with --help for usage.`);
+        }
+    }
+    if (toolsets === undefined && env.ADMOB_TOOLSETS) {
+        toolsets = parseToolsets(env.ADMOB_TOOLSETS);
+    }
+    const config = {
+        accountId: accountId ? normalizeAccountId(accountId) : undefined,
+        readOnly,
+        toolsets: toolsets ?? TOOLSET_NAMES,
+        credentialsDir: env.ADMOB_CREDENTIALS_DIR ?? join(homedir(), '.admob-mcp'),
+        oauthClientFile,
+        googleClientId: env.GOOGLE_CLIENT_ID,
+        googleClientSecret: env.GOOGLE_CLIENT_SECRET,
+        googleRefreshToken: env.GOOGLE_REFRESH_TOKEN,
+    };
+    return { command, config };
+}

package/dist/index.js ADDED Viewed

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { runAuthFlow } from './auth/oauth-flow.js';
+import { parseCli, USAGE } from './config.js';
+import { createServer } from './server.js';
+import { VERSION } from './version.js';
+async function main() {
+    const { command, config } = parseCli(process.argv.slice(2));
+    switch (command) {
+        case 'help':
+            console.log(USAGE);
+            return;
+        case 'version':
+            console.log(VERSION);
+            return;
+        case 'auth':
+            await runAuthFlow(config);
+            return;
+        case 'serve': {
+            const server = createServer(config);
+            await server.connect(new StdioServerTransport());
+            console.error(`admob-mcp-server v${VERSION} ready (toolsets: ${config.toolsets.join(', ')}; mode: ${config.readOnly ? 'read-only' : 'read-write'})`);
+            return;
+        }
+    }
+}
+main().catch((err) => {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+});

package/dist/prompts.js ADDED Viewed

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+const daysArg = z.string().optional().describe('Number of days to look back (default: 7)');
+function userMessage(text) {
+    return { messages: [{ role: 'user', content: { type: 'text', text } }] };
+}
+export function registerPrompts(server) {
+    server.registerPrompt('top_performing_apps', {
+        title: 'Top performing apps',
+        description: 'Rank your apps by AdMob revenue over a recent period',
+        argsSchema: { days: daysArg },
+    }, ({ days }) => {
+        const d = days ?? '7';
+        return userMessage(`Analyze my AdMob app performance for the last ${d} days.
+1. Compute the date range: endDate = today, startDate = ${d} days before today (YYYY-MM-DD).
+2. Call generate_network_report with dimensions ["APP"] and metrics ["ESTIMATED_EARNINGS", "IMPRESSIONS", "IMPRESSION_RPM", "MATCH_RATE"], sorted by ESTIMATED_EARNINGS descending.
+3. Present a ranked table of apps: earnings (with currency), impressions, RPM, and each app's share of total revenue.
+4. Call out any app with an unusually low match rate or RPM compared to the others.`);
+    });
+    server.registerPrompt('revenue_summary', {
+        title: 'Revenue summary',
+        description: 'Summarize AdMob revenue trends over a recent period',
+        argsSchema: { days: daysArg },
+    }, ({ days }) => {
+        const d = days ?? '7';
+        return userMessage(`Summarize my AdMob revenue for the last ${d} days.
+1. Compute the date range: endDate = today, startDate = ${d} days before today (YYYY-MM-DD).
+2. Call generate_network_report with dimensions ["DATE"] and metrics ["ESTIMATED_EARNINGS", "IMPRESSIONS", "IMPRESSION_RPM", "AD_REQUESTS", "MATCH_RATE"], sorted by DATE ascending.
+3. Report: total earnings (with currency), average daily earnings, and the day-over-day trend.
+4. Flag any anomalies (sudden drops or spikes in earnings, match rate, or RPM) with the dates they happened.`);
+    });
+    server.registerPrompt('compare_ad_formats', {
+        title: 'Compare ad formats',
+        description: 'Compare how each ad format (banner, interstitial, rewarded...) monetizes',
+        argsSchema: { days: daysArg },
+    }, ({ days }) => {
+        const d = days ?? '30';
+        return userMessage(`Compare the performance of my AdMob ad formats over the last ${d} days.
+1. Compute the date range: endDate = today, startDate = ${d} days before today (YYYY-MM-DD).
+2. Call generate_network_report with dimensions ["FORMAT"] and metrics ["ESTIMATED_EARNINGS", "IMPRESSIONS", "IMPRESSION_RPM", "IMPRESSION_CTR", "SHOW_RATE"].
+3. Present a comparison table and explain which formats earn the most in total and which are most efficient (highest RPM).
+4. Suggest one concrete change worth testing based on the numbers (e.g. formats with high RPM but low volume).`);
+    });
+}

package/dist/resources.js ADDED Viewed

@@ -0,0 +1,60 @@
+import { CAMPAIGN_REPORT_DIMENSIONS, CAMPAIGN_REPORT_METRICS, MEDIATION_REPORT_DIMENSIONS, MEDIATION_REPORT_METRICS, NETWORK_REPORT_DIMENSIONS, NETWORK_REPORT_METRICS, } from './admob/constants.js';
+const REFERENCES = [
+    {
+        name: 'network-report-spec',
+        title: 'Network report dimensions & metrics',
+        description: 'Valid dimensions and metrics for generate_network_report',
+        body: {
+            dimensions: NETWORK_REPORT_DIMENSIONS,
+            metrics: NETWORK_REPORT_METRICS,
+            notes: [
+                'ESTIMATED_EARNINGS and IMPRESSION_RPM are monetary; the server converts micros to currency units.',
+                'DATE, MONTH, and WEEK values are formatted YYYYMMDD.',
+                'Not every dimension/metric combination is valid — the API rejects invalid combinations.',
+            ],
+        },
+    },
+    {
+        name: 'mediation-report-spec',
+        title: 'Mediation report dimensions & metrics',
+        description: 'Valid dimensions and metrics for generate_mediation_report',
+        body: {
+            dimensions: MEDIATION_REPORT_DIMENSIONS,
+            metrics: MEDIATION_REPORT_METRICS,
+            notes: [
+                "OBSERVED_ECPM is the third-party network's estimated average eCPM, converted from micros.",
+                'AD_SOURCE, AD_SOURCE_INSTANCE, and MEDIATION_GROUP dimensions also return display labels.',
+            ],
+        },
+    },
+    {
+        name: 'campaign-report-spec',
+        title: 'Campaign report dimensions & metrics',
+        description: 'Valid dimensions and metrics for generate_campaign_report',
+        body: {
+            dimensions: CAMPAIGN_REPORT_DIMENSIONS,
+            metrics: CAMPAIGN_REPORT_METRICS,
+            notes: [
+                'The date range must be within the last 30 days.',
+                'ESTIMATED_COST and AVERAGE_CPI are monetary; the server converts micros to currency units.',
+            ],
+        },
+    },
+];
+export function registerResources(server) {
+    for (const ref of REFERENCES) {
+        server.registerResource(ref.name, `admob://reference/${ref.name}`, {
+            title: ref.title,
+            description: ref.description,
+            mimeType: 'application/json',
+        }, async (uri) => ({
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: 'application/json',
+                    text: JSON.stringify(ref.body, null, 2),
+                },
+            ],
+        }));
+    }
+}

package/dist/server.js ADDED Viewed

@@ -0,0 +1,33 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { createAdmobClient, discoverAccountName } from './admob/client.js';
+import { registerPrompts } from './prompts.js';
+import { registerResources } from './resources.js';
+import { registerToolsets } from './toolsets/index.js';
+import { VERSION } from './version.js';
+export function createServer(config) {
+    const server = new McpServer({ name: 'admob-mcp-server', version: VERSION });
+    // Auth and account discovery are lazy so the server starts (and lists tools)
+    // even before credentials exist; failures surface per tool call. Rejected
+    // promises are not cached so transient failures can recover.
+    let clientPromise;
+    let accountPromise;
+    const ctx = {
+        server,
+        client: () => (clientPromise ??= createAdmobClient(config).catch((err) => {
+            clientPromise = undefined;
+            throw err;
+        })),
+        accountName: () => (accountPromise ??= ctx
+            .client()
+            .then((client) => discoverAccountName(client, config.accountId))
+            .catch((err) => {
+            accountPromise = undefined;
+            throw err;
+        })),
+        readOnly: config.readOnly,
+    };
+    registerToolsets(ctx, config.toolsets);
+    registerPrompts(server);
+    registerResources(server);
+    return server;
+}

package/dist/toolsets/accounts.js ADDED Viewed

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { accountNameFromId, paginationShape, runTool } from './common.js';
+export function registerAccountsToolset(ctx) {
+    ctx.server.registerTool('list_accounts', {
+        title: 'List AdMob accounts',
+        description: 'Lists the AdMob publisher accounts accessible with the current credentials. Use this to find your publisher ID (pub-XXXXXXXXXXXXXXXX).',
+        inputSchema: { ...paginationShape },
+        annotations: { readOnlyHint: true },
+    }, async (args) => runTool(async () => {
+        const client = await ctx.client();
+        const res = await client.accounts.list({
+            pageSize: args.pageSize,
+            pageToken: args.pageToken,
+        });
+        return res.data;
+    }));
+    ctx.server.registerTool('get_account', {
+        title: 'Get AdMob account',
+        description: 'Gets an AdMob publisher account: publisher ID, reporting currency, and reporting time zone. Defaults to the configured or auto-discovered account.',
+        inputSchema: {
+            accountId: z
+                .string()
+                .optional()
+                .describe('Publisher ID (e.g. pub-1234567890123456). Defaults to the active account.'),
+        },
+        annotations: { readOnlyHint: true },
+    }, async (args) => runTool(async () => {
+        const client = await ctx.client();
+        const name = args.accountId ? accountNameFromId(args.accountId) : await ctx.accountName();
+        const res = await client.accounts.get({ name });
+        return res.data;
+    }));
+}

package/dist/toolsets/adunits.js ADDED Viewed

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+import { AD_FORMATS } from '../admob/constants.js';
+import { paginationShape, runTool } from './common.js';
+export function registerAdUnitsToolset(ctx) {
+    ctx.server.registerTool('list_ad_units', {
+        title: 'List AdMob ad units',
+        description: 'Lists the ad units in the AdMob account, including ad unit ID (ca-app-pub-.../...), format, and the app they belong to.',
+        inputSchema: { ...paginationShape },
+        annotations: { readOnlyHint: true },
+    }, async (args) => runTool(async () => {
+        const client = await ctx.client();
+        const res = await client.accounts.adUnits.list({
+            parent: await ctx.accountName(),
+            pageSize: args.pageSize,
+            pageToken: args.pageToken,
+        });
+        return res.data;
+    }));
+    if (ctx.readOnly)
+        return;
+    ctx.server.registerTool('create_ad_unit', {
+        title: 'Create AdMob ad unit',
+        description: 'Creates an ad unit under an app in the AdMob account. Requires the admob.monetization scope.',
+        inputSchema: {
+            appId: z
+                .string()
+                .describe('AdMob app ID the ad unit belongs to, e.g. ca-app-pub-XXXXXXXXXXXXXXXX~0123456789'),
+            displayName: z.string().describe('Display name of the ad unit (shown in the AdMob UI)'),
+            adFormat: z.enum(AD_FORMATS).describe('Ad format of the ad unit'),
+            adTypes: z
+                .array(z.enum(['RICH_MEDIA', 'VIDEO']))
+                .optional()
+                .describe('Ad media types supported by this ad unit'),
+            rewardSettings: z
+                .object({
+                unitAmount: z.number().int().positive().describe('Reward amount'),
+                unitType: z.string().describe('Reward item, e.g. "coins"'),
+            })
+                .optional()
+                .describe('Reward settings — only for REWARDED / REWARDED_INTERSTITIAL formats'),
+        },
+        annotations: { readOnlyHint: false },
+    }, async (args) => runTool(async () => {
+        const client = await ctx.client();
+        const res = await client.accounts.adUnits.create({
+            parent: await ctx.accountName(),
+            requestBody: {
+                appId: args.appId,
+                displayName: args.displayName,
+                adFormat: args.adFormat,
+                adTypes: args.adTypes,
+                rewardSettings: args.rewardSettings
+                    ? {
+                        unitAmount: String(args.rewardSettings.unitAmount),
+                        unitType: args.rewardSettings.unitType,
+                    }
+                    : undefined,
+            },
+        });
+        return res.data;
+    }));
+}

package/dist/toolsets/apps.js ADDED Viewed

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import { PLATFORMS } from '../admob/constants.js';
+import { paginationShape, runTool } from './common.js';
+export function registerAppsToolset(ctx) {
+    ctx.server.registerTool('list_apps', {
+        title: 'List AdMob apps',
+        description: 'Lists the apps registered in the AdMob account, including app ID (ca-app-pub-...~...), platform, store link state, and approval state.',
+        inputSchema: { ...paginationShape },
+        annotations: { readOnlyHint: true },
+    }, async (args) => runTool(async () => {
+        const client = await ctx.client();
+        const res = await client.accounts.apps.list({
+            parent: await ctx.accountName(),
+            pageSize: args.pageSize,
+            pageToken: args.pageToken,
+        });
+        return res.data;
+    }));
+    if (ctx.readOnly)
+        return;
+    ctx.server.registerTool('create_app', {
+        title: 'Create AdMob app',
+        description: 'Creates an app in the AdMob account. Provide appStoreId to link a published store listing, or displayName to register an unpublished app manually. Requires the admob.monetization scope.',
+        inputSchema: {
+            platform: z.enum(PLATFORMS).describe('App platform'),
+            displayName: z
+                .string()
+                .optional()
+                .describe('Display name for an app that is not published on a store yet'),
+            appStoreId: z
+                .string()
+                .optional()
+                .describe('Store ID to link — Android package name (com.example.app) or iOS numeric App Store ID'),
+        },
+        annotations: { readOnlyHint: false },
+    }, async (args) => runTool(async () => {
+        if (!args.displayName && !args.appStoreId) {
+            throw new Error('Provide appStoreId (to link a store listing) or displayName (to register the app manually).');
+        }
+        const client = await ctx.client();
+        const res = await client.accounts.apps.create({
+            parent: await ctx.accountName(),
+            requestBody: {
+                platform: args.platform,
+                ...(args.appStoreId
+                    ? { linkedAppInfo: { appStoreId: args.appStoreId } }
+                    : { manualAppInfo: { displayName: args.displayName } }),
+            },
+        });
+        return res.data;
+    }));
+}

package/dist/toolsets/common.js ADDED Viewed

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import { AUTH_OPTIONS_HELP } from '../auth/index.js';
+export const paginationShape = {
+    pageSize: z.number().int().positive().optional().describe('Maximum number of items to return'),
+    pageToken: z.string().optional().describe('nextPageToken from a previous response'),
+};
+export function accountNameFromId(id) {
+    return `accounts/${id.replace(/^accounts\//, '')}`;
+}
+function describeError(err) {
+    const httpError = err;
+    const status = httpError.status ?? httpError.response?.status;
+    const message = httpError.response?.data?.error?.message ?? (err instanceof Error ? err.message : String(err));
+    if (message.includes('Could not load the default credentials')) {
+        return AUTH_OPTIONS_HELP;
+    }
+    if (status === 401 || message.includes('invalid_grant')) {
+        return `Authentication failed: ${message}
+The saved token may be expired or revoked. Re-run "npx admob-mcp-server auth".
+Note: if your OAuth consent screen is in Testing mode, refresh tokens expire after 7 days — publish the app on the consent screen to get long-lived tokens.`;
+    }
+    if (status === 403) {
+        return `Permission denied: ${message}
+Check that:
+1. The AdMob API is enabled for your project: https://console.cloud.google.com/apis/library/admob.googleapis.com
+2. You signed in with the Google account that has access to this AdMob account
+3. The granted scopes cover this tool — write tools need the admob.monetization scope. Tokens created with "auth --read-only" cannot write; re-run "npx admob-mcp-server auth"`;
+    }
+    if (status === 429) {
+        return `AdMob API quota exceeded: ${message}
+Retry later, or reduce the request cost (narrower date range, fewer dimensions). Quotas are per Google Cloud project: https://developers.google.com/admob/api/limits`;
+    }
+    return `AdMob API error${status ? ` (HTTP ${status})` : ''}: ${message}`;
+}
+export function jsonResult(data) {
+    return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+}
+export function errorResult(err) {
+    return { content: [{ type: 'text', text: describeError(err) }], isError: true };
+}
+/** Runs a tool body and converts thrown errors into isError results the model can act on. */
+export async function runTool(fn) {
+    try {
+        return jsonResult(await fn());
+    }
+    catch (err) {
+        return errorResult(err);
+    }
+}

package/dist/toolsets/index.js ADDED Viewed

@@ -0,0 +1,17 @@
+import { registerAccountsToolset } from './accounts.js';
+import { registerAdUnitsToolset } from './adunits.js';
+import { registerAppsToolset } from './apps.js';
+import { registerMediationToolset } from './mediation.js';
+import { registerReportsToolset } from './reports.js';
+const REGISTRY = {
+    accounts: registerAccountsToolset,
+    apps: registerAppsToolset,
+    adunits: registerAdUnitsToolset,
+    reports: registerReportsToolset,
+    mediation: registerMediationToolset,
+};
+export function registerToolsets(ctx, toolsets) {
+    for (const name of toolsets) {
+        REGISTRY[name](ctx);
+    }
+}