@gscdump/cli 1.4.0 → 1.4.2

package/dist/mcp/handlers/diagnostics.mjs

@@ -0,0 +1,134 @@
+import { hasGscWriteScope, hasIndexingScope } from "gscdump";
+import { ofetch } from "ofetch";
+const REQUIRED_SCOPES = [
+	"https://www.googleapis.com/auth/webmasters",
+	"https://www.googleapis.com/auth/indexing",
+	"https://www.googleapis.com/auth/siteverification"
+];
+const FETCH_TIMEOUT_MS = 5e3;
+const TIME_SKEW_WARN_MS = 5 * 6e4;
+function hasGoogleScope(scopes, scope) {
+	const suffix = scope.replace("https://www.googleapis.com/auth/", "");
+	return scopes.includes(scope) || scopes.includes(suffix);
+}
+function missingRequiredScopes(scopes) {
+	return REQUIRED_SCOPES.filter((scope) => {
+		if (scope.endsWith("/webmasters")) return !hasGscWriteScope(scopes);
+		if (scope.endsWith("/indexing")) return !hasIndexingScope(scopes);
+		return !hasGoogleScope(scopes, scope);
+	});
+}
+async function diagnostics(_input, ctx) {
+	const checks = [];
+	const token = await resolveAccessToken(ctx.auth);
+	if (!token) {
+		checks.push({
+			name: "auth",
+			status: "fail",
+			detail: "no usable access token (refresh failed or no credentials)"
+		});
+		return {
+			ok: false,
+			checks
+		};
+	}
+	const [tokenInfo, timeCheck, gscReachable, indexingReachable, sites] = await Promise.all([
+		ofetch("https://oauth2.googleapis.com/tokeninfo", { query: { access_token: token } }).catch((e) => ({ error: e.message })),
+		probeTimeSkew(),
+		probeReachable("https://searchconsole.googleapis.com/$discovery/rest?version=v1"),
+		probeReachable("https://indexing.googleapis.com/$discovery/rest?version=v3"),
+		ctx.client.sites().catch((e) => e)
+	]);
+	if ("error" in tokenInfo) checks.push({
+		name: "auth",
+		status: "fail",
+		detail: `tokeninfo failed: ${tokenInfo.error}`
+	});
+	else {
+		checks.push({
+			name: "auth",
+			status: "pass",
+			detail: tokenInfo.email ?? "token valid"
+		});
+		const scopes = tokenInfo.scope ? tokenInfo.scope.split(/\s+/) : [];
+		const missing = missingRequiredScopes(scopes);
+		checks.push(missing.length > 0 ? {
+			name: "auth.scopes",
+			status: "warn",
+			detail: `missing: ${missing.join(", ")}`
+		} : {
+			name: "auth.scopes",
+			status: "pass",
+			detail: `${scopes.length} granted`
+		});
+	}
+	checks.push(timeCheck);
+	checks.push({
+		name: "gsc.api",
+		status: gscReachable ? "pass" : "warn",
+		detail: gscReachable ? "reachable" : "searchconsole.googleapis.com unreachable"
+	});
+	checks.push({
+		name: "indexing.api",
+		status: indexingReachable ? "pass" : "warn",
+		detail: indexingReachable ? "reachable" : "indexing.googleapis.com unreachable"
+	});
+	if (sites instanceof Error) checks.push({
+		name: "gsc.sites",
+		status: "fail",
+		detail: `sites() failed: ${sites.message}`
+	});
+	else {
+		const verified = sites.filter((s) => s.permissionLevel !== "siteUnverifiedUser").length;
+		checks.push({
+			name: "gsc.sites",
+			status: "pass",
+			detail: `${sites.length} site(s) accessible (${verified} verified)`
+		});
+	}
+	return {
+		ok: !checks.some((c) => c.status === "fail"),
+		checks
+	};
+}
+async function resolveAccessToken(auth) {
+	if (typeof auth === "string") return auth;
+	if (auth && typeof auth === "object" && "getAccessToken" in auth) return (await auth.getAccessToken().catch(() => null))?.token ?? null;
+	return null;
+}
+async function probeTimeSkew() {
+	const dateHeader = await ofetch.raw("https://oauth2.googleapis.com/tokeninfo", {
+		method: "GET",
+		timeout: FETCH_TIMEOUT_MS
+	}).then((r) => r.headers.get("date")).catch((e) => e?.response?.headers?.get("date") ?? null);
+	if (!dateHeader) return {
+		name: "time",
+		status: "warn",
+		detail: "no Date header"
+	};
+	const remoteMs = Date.parse(dateHeader);
+	if (!Number.isFinite(remoteMs)) return {
+		name: "time",
+		status: "warn",
+		detail: `unparseable Date header: ${dateHeader}`
+	};
+	const skewMs = Date.now() - remoteMs;
+	const human = `${skewMs >= 0 ? "+" : ""}${(skewMs / 1e3).toFixed(1)}s`;
+	if (Math.abs(skewMs) > TIME_SKEW_WARN_MS) return {
+		name: "time",
+		status: "warn",
+		detail: `local clock ${human} off Google`
+	};
+	return {
+		name: "time",
+		status: "pass",
+		detail: `in sync (${human})`
+	};
+}
+async function probeReachable(url) {
+	return ofetch.raw(url, {
+		method: "GET",
+		timeout: FETCH_TIMEOUT_MS
+	}).then(() => true).catch(() => false);
+}
+export { diagnostics };

package/dist/mcp/handlers/index.mjs

@@ -0,0 +1,7 @@
+import "./analytics.mjs";
+import { diagnostics } from "./diagnostics.mjs";
+import { batchInspectUrls, batchRequestIndexing, getIndexingStatus, requestIndexing } from "./indexing.mjs";
+import "./query.mjs";
+import { listReports, runReportHandler, runReportHandlerResult } from "./reports.mjs";
+import { getSitemap, listSitesWithSitemaps } from "./sites.mjs";
+export { batchInspectUrls, batchRequestIndexing, diagnostics, getIndexingStatus, getSitemap, listReports, listSitesWithSitemaps, requestIndexing, runReportHandler, runReportHandlerResult };

package/dist/mcp/handlers/indexing.mjs

@@ -0,0 +1,27 @@
+import { batchInspectUrls, batchRequestIndexing, getIndexingMetadata, requestIndexing } from "gscdump";
+async function requestIndexing$1(input, ctx) {
+	return requestIndexing(ctx.client, input.url, { type: input.type || "URL_UPDATED" });
+}
+async function getIndexingStatus(input, ctx) {
+	return getIndexingMetadata(ctx.client, input.url);
+}
+async function batchRequestIndexing$1(input, ctx) {
+	const results = await batchRequestIndexing(ctx.client, input.urls, {
+		type: input.type || "URL_UPDATED",
+		delayMs: input.delayMs || 100
+	});
+	return {
+		results,
+		success: results.length,
+		failed: 0
+	};
+}
+async function batchInspectUrls$1(input, ctx) {
+	const results = await batchInspectUrls(ctx.client, input.siteUrl, input.urls, { delayMs: input.delayMs || 200 });
+	return {
+		results,
+		indexed: results.filter((r) => r.isIndexed).length,
+		notIndexed: results.filter((r) => !r.isIndexed).length
+	};
+}
+export { batchInspectUrls$1 as batchInspectUrls, batchRequestIndexing$1 as batchRequestIndexing, getIndexingStatus, requestIndexing$1 as requestIndexing };

package/dist/mcp/handlers/query.mjs

@@ -0,0 +1,5 @@
+import "./analytics.mjs";
+import "../errors.mjs";
+import "gscdump/query";
+import "gscdump/result";
+export {};

package/dist/mcp/handlers/reports.mjs

@@ -0,0 +1,72 @@
+import { enrichToolError, mcpHandlerErrorToException, mcpHandlerErrors } from "../errors.mjs";
+import { defaultAnalyzerRegistry } from "@gscdump/analysis/registry";
+import { createGscApiQuerySource } from "@gscdump/engine-gsc-api";
+import { err, ok, unwrapResult } from "gscdump/result";
+import { defaultReportRegistry, runReport } from "@gscdump/analysis/report";
+import { resolveWindow } from "@gscdump/engine/period";
+const PERIOD_ALIASES = {
+	"7d": "last-7d",
+	"28d": "last-28d",
+	"30d": "last-30d",
+	"90d": "last-90d",
+	"180d": "last-180d",
+	"365d": "last-365d",
+	"mtd": "mtd",
+	"ytd": "ytd",
+	"custom": "custom"
+};
+const COMPARISON_ALIASES = {
+	"none": "none",
+	"prev": "prev-period",
+	"prev-period": "prev-period",
+	"prior": "prev-period",
+	"yoy": "yoy"
+};
+function listReports() {
+	return defaultReportRegistry.listReports().map((r) => ({
+		id: r.id,
+		description: r.description,
+		defaultPeriod: r.defaultPeriod,
+		defaultComparison: r.defaultComparison,
+		argsSpec: r.argsSpec
+	}));
+}
+async function runReportHandlerResult(input, ctx) {
+	const report = defaultReportRegistry.getReport(input.id);
+	if (!report) return err(mcpHandlerErrors.unknownReport(input.id, defaultReportRegistry.listReportIds()));
+	const preset = input.period ? PERIOD_ALIASES[input.period.toLowerCase()] ?? null : report.defaultPeriod;
+	if (!preset) return err(mcpHandlerErrors.unknownPeriod(input.period ?? ""));
+	const comparison = input.comparison ? COMPARISON_ALIASES[input.comparison.toLowerCase()] ?? null : report.defaultComparison;
+	if (!comparison) return err(mcpHandlerErrors.unknownComparison(input.comparison ?? ""));
+	const window = resolveWindow({
+		preset,
+		comparison,
+		start: input.start,
+		end: input.end
+	});
+	if (input.prevStart && input.prevEnd) window.comparison = {
+		start: input.prevStart,
+		end: input.prevEnd
+	};
+	const params = {};
+	if (input.maxFindings != null) params.maxFindings = input.maxFindings;
+	return ok(await runReport(report, {
+		source: createGscApiQuerySource({
+			client: ctx.client,
+			siteUrl: input.siteUrl
+		}),
+		analyzers: defaultAnalyzerRegistry,
+		ctx: {
+			site: input.siteUrl,
+			window,
+			params,
+			registryVersion: defaultReportRegistry.version
+		}
+	}));
+}
+async function runReportHandler(input, ctx) {
+	return unwrapResult(await runReportHandlerResult(input, ctx).catch((thrown) => {
+		throw enrichToolError(thrown) ?? thrown;
+	}), mcpHandlerErrorToException);
+}
+export { listReports, runReportHandler, runReportHandlerResult };

package/dist/mcp/handlers/sites.mjs

@@ -0,0 +1,8 @@
+import { fetchSitemap, fetchSitesWithSitemaps } from "gscdump";
+async function listSitesWithSitemaps(_input, ctx) {
+	return fetchSitesWithSitemaps(ctx.client);
+}
+async function getSitemap(input, ctx) {
+	return fetchSitemap(ctx.client, input.siteUrl, input.feedpath);
+}
+export { getSitemap, listSitesWithSitemaps };

package/dist/mcp/server/index.mjs

@@ -0,0 +1,417 @@
+import { diagnostics } from "../handlers/diagnostics.mjs";
+import { batchInspectUrls as batchInspectUrls$1, batchRequestIndexing as batchRequestIndexing$1, getIndexingStatus, requestIndexing as requestIndexing$1 } from "../handlers/indexing.mjs";
+import { listReports, runReportHandler } from "../handlers/reports.mjs";
+import { getSitemap, listSitesWithSitemaps } from "../handlers/sites.mjs";
+import "../handlers/index.mjs";
+import { batchInspectUrlsInput, batchRequestIndexingInput, getIndexingStatusInput, inspectUrlInput, listReportsInput, listSitemapsInput, listSitesInput, requestIndexingInput, runReportInput, sitemapInput } from "../types.mjs";
+import { addSite, deleteSite, discoverSitemap, getIndexingMetadata, getVerificationToken, getVerifiedSite, googleSearchConsole, listVerifiedSites, runSequentialBatch, unverifySite, verifySite } from "gscdump";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+async function runMcpSearchAnalyticsQuery(client, args) {
+	const totalLimit = Math.max(0, args.rowLimit ?? 25e3);
+	const pageSize = Math.min(totalLimit, 25e3);
+	const allRows = [];
+	let startRow = 0;
+	while (allRows.length < totalLimit) {
+		const remaining = totalLimit - allRows.length;
+		const currentLimit = Math.min(pageSize, remaining);
+		if (currentLimit <= 0) break;
+		const rows = ((await client.searchAnalytics.query(args.siteUrl, {
+			startDate: args.startDate,
+			endDate: args.endDate,
+			dimensions: args.dimensions,
+			rowLimit: currentLimit,
+			startRow,
+			...args.type ? { type: args.type } : {},
+			...args.dataState ? { dataState: args.dataState } : {},
+			...args.aggregationType ? { aggregationType: args.aggregationType } : {},
+			...args.dimensionFilterGroups ? { dimensionFilterGroups: args.dimensionFilterGroups.map((g) => ({
+				groupType: g.groupType ?? "and",
+				filters: g.filters
+			})) } : {}
+		})).rows || []).map((row) => {
+			const result = {
+				clicks: row.clicks ?? 0,
+				impressions: row.impressions ?? 0,
+				ctr: row.ctr ?? 0,
+				position: row.position ?? 0
+			};
+			args.dimensions.forEach((dim, i) => {
+				result[dim] = row.keys?.[i];
+			});
+			return result;
+		});
+		if (rows.length === 0) break;
+		allRows.push(...rows);
+		startRow += rows.length;
+	}
+	return {
+		siteUrl: args.siteUrl,
+		rowCount: allRows.length,
+		rows: allRows
+	};
+}
+function createGscMcpServer(options) {
+	const { name = "gscdump", version = "1.0.0", getAuth } = options;
+	const server = new McpServer({
+		name,
+		version
+	});
+	const auth = async () => Promise.resolve(getAuth());
+	const getContext = async () => {
+		const a = await auth();
+		return {
+			auth: a,
+			client: googleSearchConsole(a)
+		};
+	};
+	const getClient = async () => googleSearchConsole(await auth());
+	server.registerTool("list-sites", {
+		description: "List all Google Search Console sites visible to the authenticated user.",
+		inputSchema: listSitesInput.shape
+	}, async () => {
+		const sites = (await (await getClient()).sites()).filter((s) => s.siteUrl && s.permissionLevel !== "siteUnverifiedUser").map((s) => ({
+			siteUrl: s.siteUrl,
+			permissionLevel: s.permissionLevel || "unknown"
+		}));
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(sites, null, 2)
+		}] };
+	});
+	server.registerTool("list-sites-with-sitemaps", {
+		description: "List all GSC sites with their sitemaps",
+		inputSchema: listSitesInput.shape
+	}, async (args) => {
+		const result = await listSitesWithSitemaps(args, await getContext());
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(result, null, 2)
+		}] };
+	});
+	server.registerTool("list-sitemaps", {
+		description: "List sitemaps for a specific site",
+		inputSchema: listSitemapsInput.shape
+	}, async (args) => {
+		const sitemaps = await (await getClient()).sitemaps.list(args.siteUrl);
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(sitemaps, null, 2)
+		}] };
+	});
+	server.registerTool("get-sitemap", {
+		description: "Get details for a specific sitemap",
+		inputSchema: sitemapInput.shape
+	}, async (args) => {
+		const result = await getSitemap(args, await getContext());
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(result, null, 2)
+		}] };
+	});
+	server.registerTool("submit-sitemap", {
+		description: "Submit a sitemap to Google Search Console",
+		inputSchema: sitemapInput.shape
+	}, async (args) => {
+		await (await getClient()).sitemaps.submit(args.siteUrl, args.feedpath);
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({ success: true }, null, 2)
+		}] };
+	});
+	server.registerTool("delete-sitemap", {
+		description: "Delete a sitemap from Google Search Console",
+		inputSchema: sitemapInput.shape
+	}, async (args) => {
+		await (await getClient()).sitemaps.delete(args.siteUrl, args.feedpath);
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({ success: true }, null, 2)
+		}] };
+	});
+	server.registerTool("list-reports", {
+		description: "List available reports (intent-keyed analyzer compositions). Returns id, description, default period/comparison, and per-report argsSpec.",
+		inputSchema: listReportsInput.shape
+	}, async () => {
+		const result = listReports();
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(result, null, 2)
+		}] };
+	});
+	server.registerTool("run-report", {
+		description: "Run a report against the GSC API. Returns a structured ReportResult with bounded findings per section. See list-reports for ids.",
+		inputSchema: runReportInput.shape
+	}, async (args) => {
+		const result = await runReportHandler(args, await getContext());
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(result, null, 2)
+		}] };
+	});
+	const filterOperatorSchema = z.enum([
+		"equals",
+		"notEquals",
+		"contains",
+		"notContains",
+		"includingRegex",
+		"excludingRegex"
+	]);
+	const dimensionFilterSchema = z.object({
+		dimension: z.enum([
+			"date",
+			"query",
+			"page",
+			"country",
+			"device",
+			"searchAppearance"
+		]),
+		operator: filterOperatorSchema,
+		expression: z.string()
+	});
+	const filterGroupSchema = z.object({
+		groupType: z.enum(["and"]).optional().describe("Always \"and\"; multiple groups are OR-ed together"),
+		filters: z.array(dimensionFilterSchema)
+	});
+	server.registerTool("query", {
+		description: "Run a custom search analytics query. Supports dimension filters (regex/contains/equals) via dimensionFilterGroups; multiple groups are OR-ed.",
+		inputSchema: z.object({
+			siteUrl: z.string().describe("GSC property URL (e.g., sc-domain:example.com)"),
+			startDate: z.string().describe("Start date (YYYY-MM-DD)"),
+			endDate: z.string().describe("End date (YYYY-MM-DD)"),
+			dimensions: z.array(z.enum([
+				"date",
+				"query",
+				"page",
+				"country",
+				"device",
+				"searchAppearance"
+			])).describe("Dimensions to group by"),
+			rowLimit: z.number().optional().describe("Max rows (default 25000)"),
+			type: z.enum([
+				"web",
+				"image",
+				"video",
+				"news",
+				"discover",
+				"googleNews"
+			]).optional().describe("Search type"),
+			dataState: z.enum(["final", "all"]).optional().describe("Data state: final (settled) or all (includes fresh)"),
+			aggregationType: z.enum(["byPage", "byProperty"]).optional().describe("Aggregation type"),
+			dimensionFilterGroups: z.array(filterGroupSchema).optional().describe("Filter groups (each \"and\"-ed internally; multiple groups are OR-ed)")
+		}).shape
+	}, async ({ siteUrl, startDate, endDate, dimensions, rowLimit, type, dataState, aggregationType, dimensionFilterGroups }) => {
+		const result = await runMcpSearchAnalyticsQuery(await getClient(), {
+			siteUrl,
+			startDate,
+			endDate,
+			dimensions,
+			rowLimit,
+			type,
+			dataState,
+			aggregationType,
+			dimensionFilterGroups
+		});
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(result, null, 2)
+		}] };
+	});
+	server.registerTool("inspect-url", {
+		description: "Inspect a URL to check its indexing status in Google Search Console",
+		inputSchema: inspectUrlInput.shape
+	}, async (args) => {
+		const result = await (await getClient()).inspect(args.siteUrl, args.inspectionUrl);
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(result, null, 2)
+		}] };
+	});
+	server.registerTool("request-indexing", {
+		description: "Request Google to index or remove a URL via the Indexing API",
+		inputSchema: requestIndexingInput.shape
+	}, async (args) => {
+		const result = await requestIndexing$1(args, await getContext());
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(result, null, 2)
+		}] };
+	});
+	server.registerTool("get-indexing-status", {
+		description: "Get indexing status metadata for a URL",
+		inputSchema: getIndexingStatusInput.shape
+	}, async (args) => {
+		const result = await getIndexingStatus(args, await getContext());
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(result, null, 2)
+		}] };
+	});
+	server.registerTool("batch-request-indexing", {
+		description: "Batch request indexing for multiple URLs with rate limiting",
+		inputSchema: batchRequestIndexingInput.shape
+	}, async (args) => {
+		const result = await batchRequestIndexing$1(args, await getContext());
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(result, null, 2)
+		}] };
+	});
+	server.registerTool("batch-inspect-urls", {
+		description: "Batch inspect multiple URLs to check their indexing status",
+		inputSchema: batchInspectUrlsInput.shape
+	}, async (args) => {
+		const result = await batchInspectUrls$1(args, await getContext());
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(result, null, 2)
+		}] };
+	});
+	server.registerTool("diagnostics", {
+		description: "Run health checks on the active GSC connection: auth/scopes, time skew, API reachability, sites count.",
+		inputSchema: listSitesInput.shape
+	}, async (args) => {
+		const result = await diagnostics(args, await getContext());
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(result, null, 2)
+		}] };
+	});
+	server.registerTool("add-site", {
+		description: "Register a property in Search Console (unverified). Verify ownership separately.",
+		inputSchema: z.object({ siteUrl: z.string().describe("Property URL (https://example.com/ or sc-domain:example.com)") }).shape
+	}, async ({ siteUrl }) => {
+		await addSite(await getClient(), siteUrl);
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				siteUrl,
+				status: "added",
+				verified: false
+			}, null, 2)
+		}] };
+	});
+	server.registerTool("delete-site", {
+		description: "Remove a property from Search Console.",
+		inputSchema: z.object({ siteUrl: z.string().describe("Property URL") }).shape
+	}, async ({ siteUrl }) => {
+		await deleteSite(await getClient(), siteUrl);
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				siteUrl,
+				status: "deleted"
+			}, null, 2)
+		}] };
+	});
+	const verificationMethodSchema = z.enum([
+		"META",
+		"FILE",
+		"DNS_TXT",
+		"DNS_CNAME",
+		"ANALYTICS",
+		"TAG_MANAGER"
+	]);
+	server.registerTool("get-verification-token", {
+		description: "Get a verification token to place on the site or in DNS.",
+		inputSchema: z.object({
+			siteUrl: z.string(),
+			method: verificationMethodSchema
+		}).shape
+	}, async ({ siteUrl, method }) => {
+		const result = await getVerificationToken(await getClient(), siteUrl, method);
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				siteUrl,
+				method,
+				token: result.token,
+				site: result.site
+			}, null, 2)
+		}] };
+	});
+	server.registerTool("verify-site", {
+		description: "Trigger Google to validate a placed verification token.",
+		inputSchema: z.object({
+			siteUrl: z.string(),
+			method: verificationMethodSchema
+		}).shape
+	}, async ({ siteUrl, method }) => {
+		const resource = await verifySite(await getClient(), siteUrl, method);
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				siteUrl,
+				method,
+				resource
+			}, null, 2)
+		}] };
+	});
+	server.registerTool("list-verified-sites", {
+		description: "List verified WebResources from the Site Verification API.",
+		inputSchema: z.object({}).shape
+	}, async () => {
+		const resources = await listVerifiedSites(await getClient());
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(resources, null, 2)
+		}] };
+	});
+	server.registerTool("get-verified-site", {
+		description: "Fetch a single verified WebResource by id.",
+		inputSchema: z.object({ id: z.string().describe("WebResource id (from list-verified-sites)") }).shape
+	}, async ({ id }) => {
+		const resource = await getVerifiedSite(await getClient(), id);
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(resource, null, 2)
+		}] };
+	});
+	server.registerTool("unverify-site", {
+		description: "Drop the calling user's verified ownership of a WebResource. Remove the placed token first or Google may re-verify.",
+		inputSchema: z.object({ id: z.string().describe("WebResource id (from list-verified-sites)") }).shape
+	}, async ({ id }) => {
+		await unverifySite(await getClient(), id);
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				id,
+				status: "unverified"
+			}, null, 2)
+		}] };
+	});
+	server.registerTool("discover-sitemap", {
+		description: "Probe a domain's robots.txt + common paths for an advertised sitemap (no auth).",
+		inputSchema: z.object({ domain: z.string().describe("Domain (e.g., example.com)") }).shape
+	}, async ({ domain }) => {
+		const cleaned = String(domain).replace(/^https?:\/\//, "").replace(/\/.*$/, "");
+		const url = await discoverSitemap(cleaned).catch(() => null);
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				domain: cleaned,
+				sitemap: url
+			}, null, 2)
+		}] };
+	});
+	server.registerTool("batch-get-indexing-status", {
+		description: "Get indexing notification metadata for multiple URLs.",
+		inputSchema: z.object({
+			urls: z.array(z.string()).describe("URLs"),
+			delayMs: z.number().optional().describe("Delay between requests in ms (default 100)"),
+			concurrency: z.number().optional().describe("Concurrent in-flight requests (default 1)")
+		}).shape
+	}, async ({ urls, delayMs, concurrency }) => {
+		const client = await getClient();
+		const results = await runSequentialBatch(urls, (url) => getIndexingMetadata(client, url), {
+			delayMs: delayMs ?? 100,
+			concurrency: concurrency ?? 1
+		});
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(results, null, 2)
+		}] };
+	});
+	return server;
+}
+export { McpServer, createGscMcpServer, runMcpSearchAnalyticsQuery };