@gscdump/cli 1.4.0 → 1.4.2

package/dist/_chunks/mcp.mjs

@@ -1,867 +0,0 @@
-import { loadConfig } from "./config.mjs";
-import { VERSION } from "./utils.mjs";
-import { loadTokens, resolveAuth, resolveBYOK, resolveServiceAccount } from "./auth.mjs";
-import process from "node:process";
-import { defineCommand } from "citty";
-import { isQueryError } from "gscdump/query";
-import { defaultAnalyzerRegistry } from "@gscdump/analysis/registry";
-import { createGscApiQuerySource } from "@gscdump/engine-gsc-api";
-import { err, ok, unwrapResult } from "gscdump/result";
-import { addSite, batchInspectUrls, batchRequestIndexing, deleteSite, discoverSitemap, fetchSitemap, fetchSitesWithSitemaps, getIndexingMetadata, getVerificationToken, getVerifiedSite, googleSearchConsole, hasGscWriteScope, hasIndexingScope, listVerifiedSites, requestIndexing, runSequentialBatch, unverifySite, verifySite } from "gscdump";
-import { ofetch } from "ofetch";
-import { isAnalysisError } from "@gscdump/analysis/errors";
-import { isEngineError } from "@gscdump/engine/errors";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z } from "zod";
-import { defaultReportRegistry, runReport } from "@gscdump/analysis/report";
-import { resolveWindow } from "@gscdump/engine/period";
-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);
-}
-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
-	};
-}
-const PERIODS = [
-	"7d",
-	"28d",
-	"30d",
-	"90d",
-	"180d",
-	"365d",
-	"mtd",
-	"ytd",
-	"custom"
-];
-const COMPARISONS = [
-	"none",
-	"prev-period",
-	"yoy"
-];
-const mcpHandlerErrors = {
-	unknownReport(id, available) {
-		return {
-			kind: "unknown-report",
-			id,
-			available,
-			message: `Unknown report id "${id}". Available: ${available.join(", ")}`
-		};
-	},
-	unknownPeriod(value) {
-		return {
-			kind: "unknown-period",
-			value,
-			supported: PERIODS,
-			message: `Unknown period "${value}". Supported: ${PERIODS.join(", ")}.`
-		};
-	},
-	unknownComparison(value) {
-		return {
-			kind: "unknown-comparison",
-			value,
-			supported: COMPARISONS,
-			message: `Unknown comparison "${value}". Supported: ${COMPARISONS.join(", ")}.`
-		};
-	},
-	noValidDimension() {
-		return {
-			kind: "no-valid-dimension",
-			message: "At least one valid dimension required"
-		};
-	}
-};
-function mcpHandlerErrorToException(error) {
-	const exception = new Error(error.message);
-	exception.mcpHandlerError = error;
-	return exception;
-}
-function enrichToolError(error) {
-	const query = asQueryError(error);
-	if (query) return /* @__PURE__ */ new Error(`[query:${query.kind}] ${query.message}`);
-	const analysis = asAnalysisError(error);
-	if (analysis) {
-		const cause = analysis.kind === "required-step-failed" ? asEngineError(analysis.cause) : null;
-		const tail = cause ? ` (engine:${cause.kind})` : "";
-		return /* @__PURE__ */ new Error(`[analysis:${analysis.kind}]${tail} ${analysis.message}`);
-	}
-	const engine = asEngineError(error);
-	if (engine) return /* @__PURE__ */ new Error(`[engine:${engine.kind}] ${engine.message}`);
-	return null;
-}
-function asQueryError(error) {
-	if (isQueryError(error)) return error;
-	const tagged = error?.queryError;
-	return isQueryError(tagged) ? tagged : null;
-}
-function asEngineError(error) {
-	if (isEngineError(error)) return error;
-	const tagged = error?.engineError;
-	return isEngineError(tagged) ? tagged : null;
-}
-function asAnalysisError(error) {
-	if (isAnalysisError(error)) return error;
-	const tagged = error?.analysisError;
-	return isAnalysisError(tagged) ? tagged : null;
-}
-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);
-}
-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).")
-});
-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;
-}
-async function checkAuth() {
-	if (await resolveServiceAccount().then(Boolean).catch(() => false)) return { ok: true };
-	if (resolveBYOK()) return { ok: true };
-	const config = await loadConfig();
-	if (!config.clientId && !config.clientSecret) return {
-		ok: false,
-		error: `GSCDump not configured.
-
-Run this command to set up authentication:
-
-  npx @gscdump/cli init
-
-Or set BYOK env vars: GSC_ACCESS_TOKEN, or GSC_CLIENT_ID + GSC_CLIENT_SECRET + GSC_REFRESH_TOKEN
-(GOOGLE_* aliases also accepted).
-
-Then restart your MCP client.`
-	};
-	if (!await loadTokens()) return {
-		ok: false,
-		error: `Authentication missing.
-
-Run this command to authenticate:
-
-  npx @gscdump/cli auth login
-
-Then restart your MCP client.`
-	};
-	return { ok: true };
-}
-const mcpCommand = defineCommand({
-	meta: {
-		name: "mcp",
-		description: "Start MCP server for AI assistants"
-	},
-	async run() {
-		const authCheck = await checkAuth();
-		if (!authCheck.ok) {
-			process.stderr.write(`\n${authCheck.error}\n\n`);
-			process.exit(1);
-		}
-		const server = createGscMcpServer({
-			name: "gscdump",
-			version: VERSION,
-			getAuth: () => resolveAuth({ interactive: false })
-		});
-		const transport = new StdioServerTransport();
-		await server.connect(transport);
-	}
-});
-export { mcpCommand };