@gscdump/cli 0.24.0 → 0.25.0

package/dist/index.mjs

@@ -6,10 +6,9 @@ import fs, { readFile, readdir, rm } from "node:fs/promises";
 import path, { join } from "node:path";
 import { AnalyzerCapabilityError, createEngineQuerySource, runAnalyzerFromSource } from "@gscdump/analysis";
 import { createGscApiQuerySource } from "@gscdump/engine-gsc-api";
-import { decodeSiteId, normalizeSiteUrl } from "gscdump/tenant";
+import { addSite, batchInspectUrls, batchRequestIndexing, createAuth, daysAgo, decodeSiteId, deleteSite, discoverSitemap, fetchSitemap, fetchSitemapUrls, fetchSitesWithSitemaps, formatErrorForCli, getDateRange, getIndexingMetadata, getVerificationToken, getVerifiedSite, googleSearchConsole, listVerifiedSites, normalizeSiteUrl, progressBar, requestIndexing, runSequentialBatch, siteUrlToVerificationSite, unverifySite, verificationMethodsFor, verifySite } from "gscdump";
 import os from "node:os";
 import { cancel, confirm, isCancel, multiselect, select, text } from "@clack/prompts";
-import { addSite, batchInspectUrls, batchRequestIndexing, createAuth, daysAgo, deleteSite, discoverSitemap, fetchSitemap, fetchSitemapUrls, fetchSitesWithSitemaps, formatErrorForCli, getDateRange, getIndexingMetadata, getVerificationToken, getVerifiedSite, googleSearchConsole, listVerifiedSites, progressBar, requestIndexing, runSequentialBatch, siteUrlToVerificationSite, unverifySite, verificationMethodsFor, verifySite } from "gscdump";
 import { createServer } from "node:http";
 import { JWT, OAuth2Client } from "google-auth-library";
 import { ofetch } from "ofetch";
@@ -23,8 +22,9 @@ import { allTables, inferTable } from "@gscdump/engine/schema";
 import { DuckDBInstance } from "@duckdb/node-api";
 import { sqlEscape } from "@gscdump/engine/sql";
 import { createEmptyTypesStore, createIndexingMetadataStore, createInspectionStore, createSitemapStore } from "@gscdump/engine/entities";
-import { createGscMcpServer } from "@gscdump/mcp/server";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
 import { defaultReportRegistry, dryRunReport, formatReport, runReport } from "@gscdump/analysis/report";
 import { resolveWindow } from "@gscdump/engine/period";
 import { inferLegacyTier } from "@gscdump/engine";
@@ -122,7 +122,7 @@ function loadEnvFromCwd() {
 	}
 	return applied;
 }
-var version = "0.24.0";
+var version = "0.25.0";
 const ALL_SEARCH_TYPES$1 = Object.values(SearchTypes);
 const VERSION = version;
 function noSubcommandSelected(parent, subNames) {
@@ -1659,7 +1659,7 @@ const AUTH_SUBCOMMANDS = [
 	"refresh",
 	"scopes"
 ];
-const REQUIRED_SCOPES$1 = [
+const REQUIRED_SCOPES$2 = [
 	"https://www.googleapis.com/auth/webmasters",
 	"https://www.googleapis.com/auth/indexing",
 	"https://www.googleapis.com/auth/siteverification"
@@ -1677,7 +1677,7 @@ async function resolveLiveAuthState() {
 	const tokenInfo = liveToken ? await fetchTokenInfo(liveToken) : null;
 	const scopes = tokenInfo?.scope ? tokenInfo.scope.split(/\s+/).filter(Boolean) : [];
 	const has = (s) => scopes.includes(s) || scopes.includes(s.replace(".readonly", ""));
-	const missing = REQUIRED_SCOPES$1.filter((s) => !has(s));
+	const missing = REQUIRED_SCOPES$2.filter((s) => !has(s));
 	return {
 		byok,
 		tokens,
@@ -2147,13 +2147,13 @@ const configCommand = defineCommand({
 		});
 	}
 });
-const REQUIRED_SCOPES = [
+const REQUIRED_SCOPES$1 = [
 	"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;
+const FETCH_TIMEOUT_MS$1 = 5e3;
+const TIME_SKEW_WARN_MS$1 = 5 * 6e4;
 const WATERMARK_STALE_DAYS_WARN = 7;
 const RELEVANT_ENV_KEYS = [
 	"GSC_ACCESS_TOKEN",
@@ -2279,7 +2279,7 @@ async function checkAuth$1(envKeys) {
 		detail: info.email
 	});
 	const scopes = info.scope ? info.scope.split(/\s+/) : [];
-	const missing = REQUIRED_SCOPES.filter((s) => !scopes.includes(s) && !scopes.includes(s.replace(".readonly", "")));
+	const missing = REQUIRED_SCOPES$1.filter((s) => !scopes.includes(s) && !scopes.includes(s.replace(".readonly", "")));
 	if (missing.length > 0) checks.push({
 		name: "auth.scopes",
 		status: "warn",
@@ -2311,7 +2311,7 @@ async function checkAuth$1(envKeys) {
 async function checkTimeSkew() {
 	const dateHeader = await ofetch.raw("https://oauth2.googleapis.com/tokeninfo", {
 		method: "GET",
-		timeout: FETCH_TIMEOUT_MS
+		timeout: FETCH_TIMEOUT_MS$1
 	}).then((r) => r.headers.get("date")).catch((e) => e?.response?.headers?.get("date") ?? null);
 	if (!dateHeader) return [{
 		name: "time",
@@ -2326,7 +2326,7 @@ async function checkTimeSkew() {
 	}];
 	const skewMs = Date.now() - remoteMs;
 	const human = `${skewMs >= 0 ? "+" : ""}${(skewMs / 1e3).toFixed(1)}s`;
-	if (Math.abs(skewMs) > TIME_SKEW_WARN_MS) return [{
+	if (Math.abs(skewMs) > TIME_SKEW_WARN_MS$1) return [{
 		name: "time",
 		status: "warn",
 		detail: `local clock ${human} off Google — OAuth refresh may reject; sync your clock`
@@ -2415,7 +2415,7 @@ async function checkStoreWatermarks() {
 async function checkApiReachable(name, url) {
 	const reachable = await ofetch.raw(url, {
 		method: "GET",
-		timeout: FETCH_TIMEOUT_MS
+		timeout: FETCH_TIMEOUT_MS$1
 	}).then(() => true).catch(() => false);
 	return [{
 		name,
@@ -3627,6 +3627,698 @@ const inspectCommand = defineCommand({
 		printInspection(args.url, inspection);
 	}
 });
+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;
+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 = REQUIRED_SCOPES.filter((s) => !scopes.includes(s));
+		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);
+}
+async function requestIndexing$1(input, ctx) {
+	return requestIndexing(ctx.client, input.url, { type: input.type || "URL_UPDATED" }).catch((e) => ({
+		url: input.url,
+		type: input.type || "URL_UPDATED",
+		error: e.message
+	}));
+}
+async function getIndexingStatus(input, ctx) {
+	return getIndexingMetadata(ctx.client, input.url).catch((e) => ({
+		url: input.url,
+		error: e.message
+	}));
+}
+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
+	};
+}
+const PERIOD_ALIASES$1 = {
+	"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$1 = {
+	"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 runReportHandler(input, ctx) {
+	const report = defaultReportRegistry.getReport(input.id);
+	if (!report) throw new Error(`Unknown report id "${input.id}". Available: ${defaultReportRegistry.listReportIds().join(", ")}`);
+	const preset = input.period ? PERIOD_ALIASES$1[input.period.toLowerCase()] ?? null : report.defaultPeriod;
+	if (!preset) throw new Error(`Unknown period "${input.period}". Supported: 7d, 28d, 30d, 90d, 180d, 365d, mtd, ytd, custom.`);
+	const comparison = input.comparison ? COMPARISON_ALIASES$1[input.comparison.toLowerCase()] ?? null : report.defaultComparison;
+	if (!comparison) throw new Error(`Unknown comparison "${input.comparison}". Supported: none, prev-period, yoy.`);
+	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 runReport(report, {
+		source: createGscApiQuerySource({
+			client: ctx.client,
+			siteUrl: input.siteUrl
+		}),
+		analyzers: defaultAnalyzerRegistry,
+		ctx: {
+			site: input.siteUrl,
+			window,
+			params,
+			registryVersion: defaultReportRegistry.version
+		}
+	});
+}
+async function listSitesWithSitemaps(_input, ctx) {
+	return fetchSitesWithSitemaps(ctx.client);
+}
+async function getSitemap(input, ctx) {
+	return fetchSitemap(ctx.client, input.siteUrl, input.feedpath);
+}
+const periodSchema = z.object({
+	start: z.string().describe("Start date (YYYY-MM-DD)"),
+	end: z.string().describe("End date (YYYY-MM-DD)")
+}).describe("Date range for the query");
+const siteUrlSchema = z.string().describe("GSC property URL (e.g., sc-domain:example.com or https://example.com/)");
+const queryOptionsSchema = z.object({
+	type: z.enum([
+		"web",
+		"image",
+		"video",
+		"news",
+		"discover",
+		"googleNews"
+	]).optional().describe("Data type"),
+	dataState: z.enum(["final", "all"]).optional().describe("Data state: final (settled) or all (includes fresh)"),
+	aggregationType: z.enum(["byPage", "byProperty"]).optional().describe("Aggregation: byPage or byProperty")
+}).optional();
+const listSitesInput = z.object({});
+const listSitemapsInput = z.object({ siteUrl: siteUrlSchema });
+z.object({
+	siteUrl: siteUrlSchema,
+	period: periodSchema,
+	comparePrevious: z.boolean().optional().describe("Include previous period comparison"),
+	options: queryOptionsSchema
+});
+z.object({
+	siteUrl: siteUrlSchema,
+	period: periodSchema,
+	url: z.string().describe("Page URL to fetch details for")
+});
+z.object({
+	siteUrl: siteUrlSchema,
+	period: periodSchema,
+	keyword: z.string().describe("Keyword to fetch details for")
+});
+const inspectUrlInput = z.object({
+	siteUrl: siteUrlSchema,
+	inspectionUrl: z.string().describe("URL to inspect")
+});
+const requestIndexingInput = z.object({
+	url: z.string().describe("URL to request indexing for"),
+	type: z.enum(["URL_UPDATED", "URL_DELETED"]).optional().describe("Notification type")
+});
+const getIndexingStatusInput = z.object({ url: z.string().describe("URL to get indexing status for") });
+z.object({
+	siteUrl: siteUrlSchema,
+	period: periodSchema,
+	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)"),
+	options: queryOptionsSchema
+});
+const sitemapInput = z.object({
+	siteUrl: siteUrlSchema,
+	feedpath: z.string().describe("Sitemap URL (e.g., https://example.com/sitemap.xml)")
+});
+const batchRequestIndexingInput = z.object({
+	urls: z.array(z.string()).describe("URLs to request indexing for"),
+	type: z.enum(["URL_UPDATED", "URL_DELETED"]).optional().describe("Notification type"),
+	delayMs: z.number().optional().describe("Delay between requests in ms (default 100)")
+});
+const batchInspectUrlsInput = z.object({
+	siteUrl: siteUrlSchema,
+	urls: z.array(z.string()).describe("URLs to inspect"),
+	delayMs: z.number().optional().describe("Delay between requests in ms (default 200)")
+});
+const listReportsInput = z.object({});
+const runReportInput = z.object({
+	siteUrl: siteUrlSchema,
+	id: z.string().describe("Report id (e.g. health, movers, opportunities, risks). See list-reports."),
+	period: z.string().optional().describe("Window: 7d|28d|30d|90d|180d|365d|mtd|ytd|custom (default per report)."),
+	comparison: z.string().optional().describe("Comparison: none|prev-period|yoy (default per report)."),
+	start: z.string().optional().describe("Custom window start (YYYY-MM-DD); requires period=custom."),
+	end: z.string().optional().describe("Custom window end (YYYY-MM-DD); requires period=custom."),
+	prevStart: z.string().optional().describe("Override comparison-window start."),
+	prevEnd: z.string().optional().describe("Override comparison-window end."),
+	maxFindings: z.number().optional().describe("Cap findings per section (per-report default ~5).")
+});
+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 client = await getClient();
+		const limit = rowLimit ?? 25e3;
+		const allRows = [];
+		let startRow = 0;
+		while (true) {
+			const rows = ((await client._rawQuery(siteUrl, {
+				startDate,
+				endDate,
+				dimensions,
+				rowLimit: limit,
+				startRow,
+				...type ? { type } : {},
+				...dataState ? { dataState } : {},
+				...aggregationType ? { aggregationType } : {},
+				...dimensionFilterGroups ? { dimensionFilterGroups: 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
+				};
+				dimensions.forEach((dim, i) => {
+					result[dim] = row.keys?.[i];
+				});
+				return result;
+			});
+			allRows.push(...rows);
+			if (rows.length < limit) break;
+			startRow += rows.length;
+		}
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				siteUrl,
+				rowCount: allRows.length,
+				rows: allRows
+			}, 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;
+}
 async function checkAuth() {
 	if (resolveBYOK()) return { ok: true };
 	const config = await loadConfig();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gscdump/cli",
   "type": "module",
-  "version": "0.24.0",
+  "version": "0.25.0",
   "description": "CLI for Google Search Console - dump, query, and run MCP server",
   "author": {
     "name": "Harlan Wilton",
@@ -42,11 +42,11 @@
     "google-auth-library": "^10.6.2",
     "ofetch": "^1.5.1",
     "open": "^11.0.0",
-    "@gscdump/analysis": "0.24.0",
-    "@gscdump/engine": "0.24.0",
-    "@gscdump/engine-gsc-api": "0.24.0",
-    "@gscdump/mcp": "0.24.0",
-    "gscdump": "0.24.0"
+    "zod": "^4.4.3",
+    "@gscdump/analysis": "0.25.0",
+    "@gscdump/engine": "0.25.0",
+    "@gscdump/engine-gsc-api": "0.25.0",
+    "gscdump": "0.25.0"
   },
   "devDependencies": {
     "@duckdb/node-api": "1.5.1-r.2",