@gscdump/cli 0.0.1

package/dist/index.mjs

@@ -0,0 +1,2431 @@
+#!/usr/bin/env node
+import { t as eq } from "./_chunks/libs/drizzle-orm.mjs";
+import "node:module";
+import process from "node:process";
+import { defineCommand, runMain } from "citty";
+import path from "node:path";
+import { batchInspectUrls, batchRequestIndexingForPaths, createGscDb, getIndexingStats, getLastSyncedDate, getSiteByProperty, setupSchema, sitePathDateAnalytics, syncCountries, syncDevices, syncKeywordPaths, syncKeywords, syncPages, syncSites, updateLastSynced } from "@gscdump/db";
+import { createProvider, fetchCannibalizationAnalysis, fetchDecayAnalysis, fetchMoversAnalysis, fetchOpportunityAnalysis, fetchStrikingDistanceAnalysis, fetchZeroClickAnalysis } from "@gscdump/query";
+import dayjs from "dayjs";
+import betterSqlite3 from "db0/connectors/better-sqlite3";
+import fs from "node:fs/promises";
+import { createServer } from "node:http";
+import { cancel, confirm, isCancel, multiselect, select, text } from "@clack/prompts";
+import { OAuth2Client } from "google-auth-library";
+import os from "node:os";
+import { consola } from "consola";
+import { deleteSitemap, fetchSitemap, fetchSitemaps, fetchSites, formatErrorForCli, googleSearchConsole, submitSitemap, userPeriodRange } from "gscdump";
+import { createGscMcpServer } from "@gscdump/mcp/server";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __exportAll = (all, symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
+//#region src/config.ts
+let configDir = path.join(os.homedir(), ".config", "gscdump");
+function getConfigDir() {
+	return configDir;
+}
+const DEFAULT_CLOUD_URL = "https://cloud.gscdump.com";
+async function loadConfig() {
+	return fs.readFile(path.join(configDir, "config.json"), "utf-8").then((data) => JSON.parse(data)).catch(() => ({}));
+}
+async function saveConfig(config) {
+	await fs.mkdir(configDir, {
+		recursive: true,
+		mode: 448
+	});
+	await fs.writeFile(path.join(configDir, "config.json"), JSON.stringify(config, null, 2), { mode: 384 });
+}
+function getConfigPath() {
+	return path.join(configDir, "config.json");
+}
+
+//#endregion
+//#region src/utils.ts
+const VERSION = "1.0.0";
+const logger = consola.withTag("gscdump");
+/**
+* Handles GSC API errors with helpful messages and suggestions.
+* Exits process with code 1.
+*/
+function handleGscError(error) {
+	console.error();
+	console.error(formatErrorForCli(error));
+	console.error();
+	process.exit(1);
+}
+/**
+* Creates a .catch() handler for GSC API errors.
+* Use: somePromise.catch(gscErrorHandler)
+*/
+function gscErrorHandler(error) {
+	return handleGscError(error);
+}
+const gradientColors = [
+	(s) => `\x1B[38;2;52;211;153m${s}\x1B[0m`,
+	(s) => `\x1B[38;2;45;212;191m${s}\x1B[0m`,
+	(s) => `\x1B[38;2;34;211;238m${s}\x1B[0m`,
+	(s) => `\x1B[38;2;56;189;248m${s}\x1B[0m`,
+	(s) => `\x1B[38;2;96;165;250m${s}\x1B[0m`
+];
+function applyGradient(text$1) {
+	return [...text$1].map((char, i) => {
+		const colorIndex = Math.floor(i / text$1.length * gradientColors.length);
+		return gradientColors[Math.min(colorIndex, gradientColors.length - 1)](char);
+	}).join("");
+}
+function showSplash() {
+	console.log();
+	console.log(`  ${applyGradient("GSC Dump")} v${VERSION}`);
+	console.log();
+}
+function progressBar(current, total, label, width = 30) {
+	const percent = Math.min(current / total, 1);
+	const filled = Math.round(width * percent);
+	const empty = width - filled;
+	return `  ${`\x1B[36m${"█".repeat(filled)}\x1B[0m\x1B[90m${"░".repeat(empty)}\x1B[0m`} \x1B[90m${current}/${total}\x1B[0m ${label}`;
+}
+function clearLine() {
+	process.stdout.write("\r\x1B[K");
+}
+function parsePeriod(periodStr) {
+	const match = periodStr.match(/^(\d+)([dmy])$/i);
+	if (!match) return null;
+	const amount = Number.parseInt(match[1], 10);
+	const unit = {
+		d: "days",
+		m: "months",
+		y: "years"
+	}[match[2].toLowerCase()];
+	if (!unit || amount <= 0) return null;
+	if (amount > 450 && unit === "days") return null;
+	return {
+		amount,
+		unit
+	};
+}
+function toCSV(data, columns) {
+	return [columns.join(","), ...data.map((row) => columns.map((col) => {
+		const val = row[col];
+		if (val === null || val === void 0) return "";
+		const str = String(val);
+		return str.includes(",") || str.includes("\"") || str.includes("\n") ? `"${str.replace(/"/g, "\"\"")}"` : str;
+	}).join(","))].join("\n");
+}
+function exportToCSV(output) {
+	const sections = [];
+	if (output.pages?.data) sections.push(`# Pages\n${toCSV(output.pages.data, [
+		"url",
+		"clicks",
+		"impressions",
+		"ctr",
+		"position"
+	])}`);
+	if (output.keywords?.current) sections.push(`# Keywords (Current Period)\n${toCSV(output.keywords.current, [
+		"query",
+		"clicks",
+		"impressions",
+		"ctr",
+		"position"
+	])}`);
+	if (output.countries?.current) sections.push(`# Countries (Current Period)\n${toCSV(output.countries.current, [
+		"country",
+		"clicks",
+		"impressions",
+		"ctr",
+		"position"
+	])}`);
+	if (output.devices?.current) sections.push(`# Devices (Current Period)\n${toCSV(output.devices.current, [
+		"device",
+		"clicks",
+		"impressions",
+		"ctr",
+		"position"
+	])}`);
+	return sections.join("\n\n");
+}
+
+//#endregion
+//#region src/auth.ts
+var auth_exports = /* @__PURE__ */ __exportAll({
+	authenticate: () => authenticate,
+	authenticateCloud: () => authenticateCloud,
+	clearCloudTokens: () => clearCloudTokens,
+	clearTokens: () => clearTokens,
+	getAuth: () => getAuth,
+	getAuthCredentials: () => getAuthCredentials,
+	loadCloudTokens: () => loadCloudTokens,
+	loadTokens: () => loadTokens,
+	saveCloudTokens: () => saveCloudTokens,
+	saveTokens: () => saveTokens
+});
+function getTokensPath() {
+	return path.join(getConfigDir(), "tokens.json");
+}
+async function loadTokens() {
+	return fs.readFile(getTokensPath(), "utf-8").then((data) => JSON.parse(data)).catch(() => null);
+}
+async function saveTokens(tokens) {
+	await fs.mkdir(getConfigDir(), {
+		recursive: true,
+		mode: 448
+	});
+	await fs.writeFile(getTokensPath(), JSON.stringify(tokens, null, 2), { mode: 384 });
+}
+async function clearTokens() {
+	await fs.rm(getTokensPath()).catch(() => {});
+	logger.success("Logged out, tokens cleared");
+}
+async function getAuthCredentials(interactive) {
+	const envClientId = process.env.GOOGLE_CLIENT_ID;
+	const envClientSecret = process.env.GOOGLE_CLIENT_SECRET;
+	if (envClientId && envClientSecret) {
+		logger.success("Using OAuth2 credentials from environment");
+		return {
+			clientId: envClientId,
+			clientSecret: envClientSecret
+		};
+	}
+	const config = await loadConfig();
+	if (config.clientId && config.clientSecret) return {
+		clientId: config.clientId,
+		clientSecret: config.clientSecret
+	};
+	if (!interactive) {
+		logger.error("GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRET required for non-interactive mode");
+		process.exit(1);
+	}
+	console.log();
+	console.log("  \x1B[1mOAuth 2.0 Setup Required\x1B[0m");
+	console.log("  \x1B[90mThe Google Search Console API requires OAuth 2.0 credentials.\x1B[0m");
+	console.log();
+	console.log("  \x1B[1mSteps:\x1B[0m");
+	console.log("  \x1B[90m1.\x1B[0m Go to \x1B[36mhttps://console.developers.google.com/apis/credentials\x1B[0m");
+	console.log("  \x1B[90m2.\x1B[0m Create credentials > OAuth client ID > Desktop application");
+	console.log("  \x1B[90m3.\x1B[0m Enable \"Search Console API\" and \"Web Search Indexing API\" for your project");
+	console.log("  \x1B[90m4.\x1B[0m Copy the Client ID and Client Secret");
+	console.log();
+	const clientIdResult = await text({
+		message: "Enter your Google OAuth Client ID:",
+		placeholder: "your-client-id.googleusercontent.com",
+		validate: (v) => v ? void 0 : "Required"
+	});
+	if (isCancel(clientIdResult)) process.exit(1);
+	const clientSecretResult = await text({
+		message: "Enter your Google OAuth Client Secret:",
+		validate: (v) => v ? void 0 : "Required"
+	});
+	if (isCancel(clientSecretResult)) process.exit(1);
+	console.log();
+	logger.info("Tip: Set GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRET env vars to skip prompts");
+	return {
+		clientId: clientIdResult,
+		clientSecret: clientSecretResult
+	};
+}
+async function getAuthCodeViaLoopback(authUrl) {
+	return new Promise((resolve, reject) => {
+		let resolvedRedirectUri = "";
+		const server = createServer((req, res) => {
+			const url = new URL(req.url || "", `http://127.0.0.1`);
+			const code = url.searchParams.get("code");
+			const error = url.searchParams.get("error");
+			if (error) {
+				res.writeHead(400, { "Content-Type": "text/html" });
+				res.end(`<html><body><h1>Authorization Failed</h1><p>${error}</p><p>You can close this window.</p></body></html>`);
+				server.close();
+				reject(/* @__PURE__ */ new Error(`OAuth error: ${error}`));
+				return;
+			}
+			if (code) {
+				res.writeHead(200, { "Content-Type": "text/html" });
+				res.end(`<html><body><h1>Authorization Successful</h1><p>You can close this window and return to the terminal.</p></body></html>`);
+				server.close();
+				resolve({
+					code,
+					redirectUri: resolvedRedirectUri
+				});
+				return;
+			}
+			res.writeHead(400, { "Content-Type": "text/html" });
+			res.end(`<html><body><h1>Missing authorization code</h1></body></html>`);
+		});
+		server.listen(0, "127.0.0.1", () => {
+			const addr = server.address();
+			if (!addr || typeof addr === "string") {
+				reject(/* @__PURE__ */ new Error("Failed to start local server"));
+				return;
+			}
+			resolvedRedirectUri = `http://127.0.0.1:${addr.port}`;
+			const fullAuthUrl = authUrl.replace(/redirect_uri=[^&]+/, `redirect_uri=${encodeURIComponent(resolvedRedirectUri)}`);
+			console.log();
+			console.log("  \x1B[1mOpening browser for authorization...\x1B[0m");
+			console.log(`  \x1B[90mIf browser doesn't open, visit:\x1B[0m`);
+			console.log(`  \x1B[36m${fullAuthUrl}\x1B[0m`);
+			console.log();
+			import("open").then(({ default: open }) => open(fullAuthUrl)).catch(() => {
+				logger.warn("Could not open browser automatically");
+			});
+		});
+		server.on("error", reject);
+		setTimeout(() => {
+			server.close();
+			reject(/* @__PURE__ */ new Error("Authorization timed out"));
+		}, 300 * 1e3);
+	});
+}
+async function authenticate(credentials, interactive) {
+	const oauth2Client = new OAuth2Client(credentials.clientId, credentials.clientSecret, "http://127.0.0.1");
+	const envAccessToken = process.env.GOOGLE_ACCESS_TOKEN;
+	const envRefreshToken = process.env.GOOGLE_REFRESH_TOKEN;
+	if (envAccessToken || envRefreshToken) {
+		oauth2Client.setCredentials({
+			access_token: envAccessToken,
+			refresh_token: envRefreshToken
+		});
+		if (envRefreshToken) {
+			const { credentials: newTokens } = await oauth2Client.refreshAccessToken().catch(() => ({ credentials: null }));
+			if (newTokens) oauth2Client.setCredentials(newTokens);
+		}
+		return oauth2Client;
+	}
+	const existingTokens = await loadTokens();
+	if (existingTokens) {
+		oauth2Client.setCredentials(existingTokens);
+		if (existingTokens.expiry_date && existingTokens.expiry_date < Date.now()) {
+			const { credentials: newTokens } = await oauth2Client.refreshAccessToken().catch(() => ({ credentials: null }));
+			if (newTokens) {
+				await saveTokens(newTokens);
+				oauth2Client.setCredentials(newTokens);
+				logger.success("Token refreshed");
+				return oauth2Client;
+			}
+		} else {
+			logger.success("Using saved credentials");
+			return oauth2Client;
+		}
+	}
+	if (!interactive) {
+		logger.error("No saved tokens. Run interactively first to authenticate.");
+		process.exit(1);
+	}
+	const authUrl = oauth2Client.generateAuthUrl({
+		access_type: "offline",
+		scope: ["https://www.googleapis.com/auth/webmasters.readonly", "https://www.googleapis.com/auth/indexing"],
+		prompt: "consent"
+	});
+	logger.info("Waiting for authorization...");
+	const { code, redirectUri } = await getAuthCodeViaLoopback(authUrl);
+	const { tokens } = await new OAuth2Client(credentials.clientId, credentials.clientSecret, redirectUri).getToken(code);
+	oauth2Client.setCredentials(tokens);
+	await saveTokens(tokens);
+	logger.success(`Tokens saved to ${getTokensPath()}`);
+	return oauth2Client;
+}
+function getCloudTokensPath() {
+	return path.join(getConfigDir(), "cloud-tokens.json");
+}
+async function loadCloudTokens() {
+	return fs.readFile(getCloudTokensPath(), "utf-8").then((data) => JSON.parse(data)).catch(() => null);
+}
+async function saveCloudTokens(tokens) {
+	await fs.mkdir(getConfigDir(), {
+		recursive: true,
+		mode: 448
+	});
+	await fs.writeFile(getCloudTokensPath(), JSON.stringify(tokens, null, 2), { mode: 384 });
+}
+async function clearCloudTokens() {
+	await fs.rm(getCloudTokensPath()).catch(() => {});
+	logger.success("Logged out from cloud");
+}
+async function authenticateCloud(cloudUrl, interactive) {
+	const existingTokens = await loadCloudTokens();
+	if (existingTokens) {
+		const oauth2Client = new OAuth2Client();
+		oauth2Client.setCredentials({
+			access_token: existingTokens.accessToken,
+			refresh_token: existingTokens.refreshToken,
+			expiry_date: existingTokens.expiresAt
+		});
+		logger.success("Using cloud credentials");
+		return oauth2Client;
+	}
+	if (!interactive) {
+		logger.error("No cloud tokens. Run gscdump init to authenticate.");
+		process.exit(1);
+	}
+	const initRes = await fetch(`${cloudUrl}/api/cli/auth/init`, { method: "POST" }).then((r) => r.json()).catch((e) => {
+		logger.error(`Failed to connect to ${cloudUrl}: ${e.message}`);
+		process.exit(1);
+	});
+	console.log();
+	console.log("  \x1B[1mOpen this URL in your browser:\x1B[0m");
+	console.log(`  \x1B[36m${initRes.authUrl}\x1B[0m`);
+	console.log();
+	console.log(`  \x1B[90mCode: ${initRes.code}\x1B[0m`);
+	console.log();
+	logger.info("Waiting for authorization...");
+	const pollInterval = 2e3;
+	const maxAttempts = Math.ceil(initRes.expiresIn * 1e3 / pollInterval);
+	for (let i = 0; i < maxAttempts; i++) {
+		await new Promise((r) => setTimeout(r, pollInterval));
+		const pollRes = await fetch(`${cloudUrl}/api/cli/auth/poll?code=${initRes.code}`).then((r) => r.json()).catch(() => ({ status: "error" }));
+		if (pollRes.status === "complete" && pollRes.tokens) {
+			await saveCloudTokens(pollRes.tokens);
+			logger.success("Authenticated via cloud.gscdump.com");
+			const oauth2Client = new OAuth2Client();
+			oauth2Client.setCredentials({
+				access_token: pollRes.tokens.accessToken,
+				refresh_token: pollRes.tokens.refreshToken,
+				expiry_date: pollRes.tokens.expiresAt
+			});
+			return oauth2Client;
+		}
+		if (pollRes.status === "error") {
+			logger.error("Authorization failed");
+			process.exit(1);
+		}
+	}
+	logger.error("Authorization timed out");
+	process.exit(1);
+}
+async function getAuth(opts = {}) {
+	const { interactive = true, config: providedConfig } = opts;
+	const config = providedConfig || await loadConfig();
+	if (!config.mode) {
+		if (!interactive) {
+			logger.error("Not configured. Run gscdump init first.");
+			process.exit(1);
+		}
+		logger.warn("GSCDump not configured");
+		logger.info("Run: gscdump init");
+		process.exit(1);
+	}
+	if (config.mode === "cloud") return authenticateCloud(config.cloudUrl || DEFAULT_CLOUD_URL, interactive);
+	return authenticate(await getAuthCredentials(interactive), interactive);
+}
+
+//#endregion
+//#region src/commands/analyze.ts
+const ANALYSIS_TYPES = [
+	"striking-distance",
+	"opportunity",
+	"movers",
+	"decay",
+	"cannibalization",
+	"zero-click"
+];
+const analyzeCommand = defineCommand({
+	meta: {
+		name: "analyze",
+		description: "Run SEO analysis on site data"
+	},
+	args: {
+		type: {
+			type: "positional",
+			required: true,
+			description: `Analysis type: ${ANALYSIS_TYPES.join(", ")}`
+		},
+		site: {
+			type: "string",
+			alias: "s",
+			description: "Site URL (e.g., sc-domain:example.com)"
+		},
+		period: {
+			type: "string",
+			alias: "p",
+			default: "28d",
+			description: "Period to analyze (e.g., 7d, 28d, 3m)"
+		},
+		limit: {
+			type: "string",
+			alias: "l",
+			default: "20",
+			description: "Number of results to show"
+		},
+		json: {
+			type: "boolean",
+			default: false,
+			description: "Output as JSON"
+		},
+		db: {
+			type: "string",
+			alias: "d",
+			description: "Path to SQLite database"
+		},
+		source: {
+			type: "string",
+			default: "auto",
+			description: "Data source: api, db, auto"
+		},
+		minPosition: {
+			type: "string",
+			description: "Minimum position (striking-distance)"
+		},
+		maxPosition: {
+			type: "string",
+			description: "Maximum position (striking-distance, zero-click)"
+		},
+		minImpressions: {
+			type: "string",
+			description: "Minimum impressions"
+		},
+		minClicks: {
+			type: "string",
+			description: "Minimum clicks (decay)"
+		},
+		threshold: {
+			type: "string",
+			description: "Threshold percentage 0-1 (decay, movers)"
+		}
+	},
+	async run({ args }) {
+		const analysisType = args.type;
+		if (!ANALYSIS_TYPES.includes(analysisType)) {
+			logger.error(`Unknown analysis type: ${analysisType}`);
+			logger.info(`Available: ${ANALYSIS_TYPES.join(", ")}`);
+			process.exit(1);
+		}
+		const config = await loadConfig();
+		const siteArg = args.site || config.defaultSite;
+		if (!siteArg) {
+			logger.error("Site required. Use --site or set defaultSite in config.");
+			process.exit(1);
+		}
+		const dbPath = args.db || config.defaultDb;
+		const auth = await getAuth({
+			interactive: false,
+			config
+		});
+		const period = parsePeriod(args.period);
+		if (!period) {
+			logger.error(`Invalid period: ${args.period}`);
+			process.exit(1);
+		}
+		const endDate = dayjs().subtract(3, "day");
+		const startDate = endDate.subtract(period.amount, period.unit);
+		const prevEndDate = startDate.subtract(1, "day");
+		const prevStartDate = prevEndDate.subtract(period.amount, period.unit);
+		const range = {
+			period: {
+				start: startDate.format("YYYY-MM-DD"),
+				end: endDate.format("YYYY-MM-DD")
+			},
+			prevPeriod: {
+				start: prevStartDate.format("YYYY-MM-DD"),
+				end: prevEndDate.format("YYYY-MM-DD")
+			}
+		};
+		const provider = await createProvider({
+			auth,
+			db: dbPath ? createGscDb(betterSqlite3({ name: path.resolve(dbPath) })).db : null,
+			source: args.source,
+			siteUrls: [siteArg],
+			range
+		});
+		const limit = Number.parseInt(args.limit, 10) || 20;
+		if (!args.json) {
+			console.log();
+			console.log(`  \x1B[1m${siteArg}\x1B[0m`);
+			console.log(`  \x1B[90mSource:   ${provider.source}\x1B[0m`);
+			console.log(`  \x1B[90mPeriod:   ${range.period.start} → ${range.period.end}\x1B[0m`);
+			console.log(`  \x1B[90mAnalysis: ${analysisType}\x1B[0m`);
+			console.log();
+		}
+		let results;
+		switch (analysisType) {
+			case "striking-distance":
+				results = await fetchStrikingDistanceAnalysis(provider, siteArg, range, {
+					minPosition: args.minPosition ? Number(args.minPosition) : void 0,
+					maxPosition: args.maxPosition ? Number(args.maxPosition) : void 0,
+					minImpressions: args.minImpressions ? Number(args.minImpressions) : void 0
+				}).catch(gscErrorHandler);
+				break;
+			case "opportunity":
+				results = await fetchOpportunityAnalysis(provider, siteArg, range, { minImpressions: args.minImpressions ? Number(args.minImpressions) : void 0 }).catch(gscErrorHandler);
+				break;
+			case "movers":
+				results = await fetchMoversAnalysis(provider, siteArg, range, {
+					changeThreshold: args.threshold ? Number(args.threshold) : void 0,
+					minImpressions: args.minImpressions ? Number(args.minImpressions) : void 0
+				}).catch(gscErrorHandler);
+				break;
+			case "decay":
+				results = await fetchDecayAnalysis(provider, siteArg, range, {
+					minPreviousClicks: args.minClicks ? Number(args.minClicks) : void 0,
+					threshold: args.threshold ? Number(args.threshold) : void 0
+				}).catch(gscErrorHandler);
+				break;
+			case "cannibalization":
+				results = await fetchCannibalizationAnalysis(provider, siteArg, range, { minImpressions: args.minImpressions ? Number(args.minImpressions) : void 0 }).catch(gscErrorHandler);
+				break;
+			case "zero-click":
+				results = await fetchZeroClickAnalysis(provider, siteArg, range, {
+					minImpressions: args.minImpressions ? Number(args.minImpressions) : void 0,
+					maxPosition: args.maxPosition ? Number(args.maxPosition) : void 0
+				}).catch(gscErrorHandler);
+				break;
+		}
+		if (args.json) {
+			console.log(JSON.stringify({
+				site: siteArg,
+				source: provider.source,
+				analysis: analysisType,
+				range,
+				results
+			}, null, 2));
+			return;
+		}
+		const arr = Array.isArray(results) ? results : [];
+		const display = arr.slice(0, limit);
+		if (display.length === 0) {
+			logger.warn("No results found");
+			return;
+		}
+		console.log(`  \x1B[1mResults\x1B[0m \x1B[90m(${arr.length} total, showing ${display.length})\x1B[0m`);
+		for (const item of display) formatResultItem(analysisType, item);
+		console.log();
+		logger.success("Analysis complete");
+	}
+});
+function formatResultItem(type, item) {
+	const keyword = item.keyword || item.query || "";
+	const page = item.page || "";
+	switch (type) {
+		case "striking-distance":
+			console.log(`    ${keyword.slice(0, 40).padEnd(40)} pos ${String(item.position || 0).padStart(5)} ${formatNumber$1(item.impressions)} impr ${formatNumber$1(item.potentialClicks)} potential`);
+			break;
+		case "opportunity":
+			console.log(`    ${keyword.slice(0, 40).padEnd(40)} score ${String((item.score || 0).toFixed(1)).padStart(6)} ${formatNumber$1(item.impressions)} impr`);
+			break;
+		case "movers":
+			console.log(`    ${keyword.slice(0, 40).padEnd(40)} ${formatChange(item.clicksChange)} clicks ${formatChange(item.positionChange)} pos`);
+			break;
+		case "decay":
+			console.log(`    ${page.replace(/^https?:\/\/[^/]+/, "").slice(0, 50).padEnd(50)} -${formatNumber$1(item.lostClicks)} clicks (${((item.declinePercent || 0) * 100).toFixed(0)}% decline)`);
+			break;
+		case "cannibalization":
+			console.log(`    ${keyword.slice(0, 40).padEnd(40)} ${item.pageCount} pages ${formatNumber$1(item.clicks)} clicks spread ${item.positionSpread}`);
+			break;
+		case "zero-click":
+			console.log(`    ${keyword.slice(0, 40).padEnd(40)} pos ${String(item.position || 0).padStart(5)} ${formatNumber$1(item.impressions)} impr ${((item.ctr || 0) * 100).toFixed(2)}% ctr`);
+			break;
+	}
+}
+function formatNumber$1(val) {
+	if (val === void 0 || val === null) return "-";
+	return val.toLocaleString();
+}
+function formatChange(val) {
+	if (val === void 0 || val === null || !Number.isFinite(val)) return "\x1B[90m-\x1B[0m";
+	return `${val > 0 ? "\x1B[32m" : val < 0 ? "\x1B[31m" : "\x1B[90m"}${val > 0 ? "+" : ""}${val.toFixed(1)}%\x1B[0m`;
+}
+
+//#endregion
+//#region src/commands/auth.ts
+const statusCommand = defineCommand({
+	meta: {
+		name: "status",
+		description: "Show current authentication status"
+	},
+	async run() {
+		const config = await loadConfig();
+		console.log();
+		console.log(`  Mode: ${config.mode ? `\x1B[36m${config.mode}\x1B[0m` : "\x1B[33mnot configured\x1B[0m"}`);
+		if (!config.mode) {
+			logger.info("Run gscdump init to configure");
+			return;
+		}
+		if (config.mode === "cloud") {
+			console.log(`  Cloud: \x1B[36m${config.cloudUrl}\x1B[0m`);
+			const tokens = await loadCloudTokens();
+			if (!tokens) {
+				logger.warn("Not authenticated");
+				logger.info("Run gscdump init --force to re-authenticate");
+				return;
+			}
+			const hasAccess = !!tokens.accessToken;
+			const hasRefresh = !!tokens.refreshToken;
+			const expiry = tokens.expiresAt ? new Date(tokens.expiresAt) : null;
+			const isExpired = expiry && expiry < /* @__PURE__ */ new Date();
+			logger.success("Authenticated");
+			console.log();
+			console.log(`  Access token:  ${hasAccess ? "\x1B[32mpresent\x1B[0m" : "\x1B[31mmissing\x1B[0m"}`);
+			console.log(`  Refresh token: ${hasRefresh ? "\x1B[32mpresent\x1B[0m" : "\x1B[31mmissing\x1B[0m"}`);
+			if (expiry) {
+				const status = isExpired ? "\x1B[33mexpired\x1B[0m" : "\x1B[32mvalid\x1B[0m";
+				console.log(`  Expires:       ${expiry.toISOString()} (${status})`);
+			}
+		} else {
+			const tokens = await loadTokens();
+			if (!tokens) {
+				logger.warn("Not authenticated");
+				logger.info("Run gscdump init --force to re-authenticate");
+				return;
+			}
+			const hasAccess = !!tokens.access_token;
+			const hasRefresh = !!tokens.refresh_token;
+			const expiry = tokens.expiry_date ? new Date(tokens.expiry_date) : null;
+			const isExpired = expiry && expiry < /* @__PURE__ */ new Date();
+			logger.success("Authenticated");
+			console.log();
+			console.log(`  Access token:  ${hasAccess ? "\x1B[32mpresent\x1B[0m" : "\x1B[31mmissing\x1B[0m"}`);
+			console.log(`  Refresh token: ${hasRefresh ? "\x1B[32mpresent\x1B[0m" : "\x1B[31mmissing\x1B[0m"}`);
+			if (expiry) {
+				const status = isExpired ? "\x1B[33mexpired\x1B[0m" : "\x1B[32mvalid\x1B[0m";
+				console.log(`  Expires:       ${expiry.toISOString()} (${status})`);
+			}
+		}
+	}
+});
+const logoutCommand = defineCommand({
+	meta: {
+		name: "logout",
+		description: "Clear stored OAuth tokens"
+	},
+	async run() {
+		if ((await loadConfig()).mode === "cloud") await clearCloudTokens();
+		else await clearTokens();
+	}
+});
+const authCommand = defineCommand({
+	meta: {
+		name: "auth",
+		description: "Manage authentication"
+	},
+	subCommands: {
+		status: statusCommand,
+		logout: logoutCommand
+	}
+});
+
+//#endregion
+//#region src/commands/compare.ts
+const SEARCH_TYPES = [
+	"web",
+	"image",
+	"video",
+	"news",
+	"discover",
+	"googleNews"
+];
+function formatPercent(val) {
+	if (val === void 0 || val === null || !Number.isFinite(val)) return "\x1B[90m-\x1B[0m";
+	return `${val > 0 ? "\x1B[32m" : val < 0 ? "\x1B[31m" : "\x1B[90m"}${val > 0 ? "+" : ""}${val.toFixed(1)}%\x1B[0m`;
+}
+function formatNumber(val) {
+	if (val === void 0 || val === null) return "-";
+	return val.toLocaleString();
+}
+const compareCommand = defineCommand({
+	meta: {
+		name: "compare",
+		description: "Compare site performance across periods"
+	},
+	args: {
+		site: {
+			type: "string",
+			alias: "s",
+			description: "Site URL (e.g., sc-domain:example.com)"
+		},
+		period: {
+			type: "string",
+			alias: "p",
+			default: "7d",
+			description: "Period to compare (e.g., 7d, 30d, 3m)"
+		},
+		from: {
+			type: "string",
+			description: "Custom start date (YYYY-MM-DD)"
+		},
+		to: {
+			type: "string",
+			description: "Custom end date (YYYY-MM-DD)"
+		},
+		vs: {
+			type: "string",
+			description: "Comparison period start date (YYYY-MM-DD)"
+		},
+		json: {
+			type: "boolean",
+			default: false,
+			description: "Output as JSON"
+		},
+		type: {
+			type: "string",
+			alias: "t",
+			default: "summary",
+			description: "Output type: summary, pages, keywords"
+		},
+		limit: {
+			type: "string",
+			alias: "l",
+			default: "10",
+			description: "Number of items to show (for pages/keywords)"
+		},
+		fresh: {
+			type: "boolean",
+			default: false,
+			description: "Include fresh/unfinalized data (last 3 days)"
+		},
+		searchType: {
+			type: "string",
+			default: "web",
+			description: "Search type: web, image, video, news, discover, googleNews"
+		},
+		db: {
+			type: "string",
+			alias: "d",
+			description: "Path to SQLite database for local queries"
+		},
+		source: {
+			type: "string",
+			default: "auto",
+			description: "Data source: api, db, auto"
+		},
+		quiet: {
+			type: "boolean",
+			alias: "q",
+			default: false,
+			description: "Suppress output"
+		}
+	},
+	async run({ args }) {
+		const config = await loadConfig();
+		const siteArg = args.site || config.defaultSite;
+		if (!siteArg) {
+			logger.error("Site required. Use --site or set defaultSite in config.");
+			process.exit(1);
+		}
+		const dbPath = args.db || config.defaultDb;
+		const periodArg = args.period === "7d" && config.defaultPeriod ? config.defaultPeriod : args.period;
+		const auth = await getAuth({
+			interactive: false,
+			config
+		});
+		let range;
+		if (args.from && args.to) {
+			const start = dayjs(args.from);
+			const end = dayjs(args.to);
+			if (!start.isValid() || !end.isValid()) {
+				logger.error("Invalid date format. Use YYYY-MM-DD");
+				process.exit(1);
+			}
+			const periodDays = end.diff(start, "day");
+			let prevStart;
+			let prevEnd;
+			if (args.vs) {
+				prevStart = dayjs(args.vs);
+				if (!prevStart.isValid()) {
+					logger.error("Invalid --vs date format. Use YYYY-MM-DD");
+					process.exit(1);
+				}
+				prevEnd = prevStart.add(periodDays, "day");
+			} else {
+				prevEnd = start.subtract(1, "day");
+				prevStart = prevEnd.subtract(periodDays, "day");
+			}
+			range = {
+				period: {
+					start: start.format("YYYY-MM-DD"),
+					end: end.format("YYYY-MM-DD")
+				},
+				prevPeriod: {
+					start: prevStart.format("YYYY-MM-DD"),
+					end: prevEnd.format("YYYY-MM-DD")
+				}
+			};
+		} else {
+			const period = parsePeriod(periodArg);
+			if (!period) {
+				logger.error(`Invalid period: ${periodArg}`);
+				process.exit(1);
+			}
+			const daysOffset = args.fresh ? 1 : 3;
+			const endDate = dayjs().subtract(daysOffset, "day");
+			const startDate = endDate.subtract(period.amount, period.unit);
+			const prevEndDate = startDate.subtract(1, "day");
+			const prevStartDate = prevEndDate.subtract(period.amount, period.unit);
+			range = {
+				period: {
+					start: startDate.format("YYYY-MM-DD"),
+					end: endDate.format("YYYY-MM-DD")
+				},
+				prevPeriod: {
+					start: prevStartDate.format("YYYY-MM-DD"),
+					end: prevEndDate.format("YYYY-MM-DD")
+				}
+			};
+		}
+		const searchType = SEARCH_TYPES.includes(args.searchType) ? args.searchType : "web";
+		const effectiveSource = searchType !== "web" ? "api" : args.source || "auto";
+		if (searchType !== "web" && args.source === "db") logger.warn(`Search type '${searchType}' requires API. Ignoring --source db.`);
+		const provider = await createProvider({
+			auth,
+			db: dbPath ? createGscDb(betterSqlite3({ name: path.resolve(dbPath) })).db : null,
+			source: effectiveSource,
+			siteUrls: [siteArg],
+			range
+		});
+		if (args.json) {
+			const [dates, pages, keywords] = await Promise.all([
+				provider.getDatesWithComparison(siteArg, range),
+				provider.getPagesWithComparison(siteArg, range),
+				provider.getKeywordsWithComparison(siteArg, range)
+			]).catch(gscErrorHandler);
+			console.log(JSON.stringify({
+				site: siteArg,
+				source: provider.source,
+				range,
+				dates,
+				pages,
+				keywords
+			}, null, 2));
+			return;
+		}
+		if (args.quiet) return;
+		console.log();
+		console.log(`  \x1B[1m${siteArg}\x1B[0m`);
+		console.log(`  \x1B[90mSource:   ${provider.source}\x1B[0m`);
+		console.log(`  \x1B[90mCurrent:  ${range.period.start} → ${range.period.end}\x1B[0m`);
+		console.log(`  \x1B[90mPrevious: ${range.prevPeriod?.start} → ${range.prevPeriod?.end}\x1B[0m`);
+		console.log();
+		if (args.type === "summary" || args.type === "all") {
+			const dates = await provider.getDatesWithComparison(siteArg, range).catch(gscErrorHandler);
+			console.log("  \x1B[1mSummary\x1B[0m");
+			console.log(`  ┌─────────────┬──────────────┬──────────────┬─────────────┐`);
+			console.log(`  │             │ \x1B[1mCurrent\x1B[0m      │ \x1B[1mPrevious\x1B[0m     │ \x1B[1mChange\x1B[0m      │`);
+			console.log(`  ├─────────────┼──────────────┼──────────────┼─────────────┤`);
+			console.log(`  │ Clicks      │ ${formatNumber(dates.metadata.totals.current.clicks).padStart(12)} │ ${formatNumber(dates.metadata.totals.previous.clicks).padStart(12)} │ ${formatPercent(dates.metadata.totals.clicksPercent).padStart(19)} │`);
+			console.log(`  │ Impressions │ ${formatNumber(dates.metadata.totals.current.impressions).padStart(12)} │ ${formatNumber(dates.metadata.totals.previous.impressions).padStart(12)} │ ${formatPercent(dates.metadata.totals.impressionsPercent).padStart(19)} │`);
+			console.log(`  │ CTR         │ ${(dates.metadata.totals.current.ctr * 100).toFixed(2).padStart(10)}% │ ${(dates.metadata.totals.previous.ctr * 100).toFixed(2).padStart(10)}% │ ${formatPercent(dates.metadata.totals.ctrPercent).padStart(19)} │`);
+			console.log(`  │ Position    │ ${dates.metadata.totals.current.position.toFixed(1).padStart(12)} │ ${dates.metadata.totals.previous.position.toFixed(1).padStart(12)} │ ${formatPercent(dates.metadata.totals.positionPercent).padStart(19)} │`);
+			console.log(`  └─────────────┴──────────────┴──────────────┴─────────────┘`);
+			console.log();
+		}
+		const limit = Number.parseInt(args.limit, 10) || 10;
+		if (args.type === "pages" || args.type === "all") {
+			const pages = await provider.getPagesWithComparison(siteArg, range).catch(gscErrorHandler);
+			const topPages = pages.current.slice(0, limit);
+			const lostPages = pages.previous.filter((p) => p.lost).slice(0, 5);
+			console.log(`  \x1B[1mTop Pages\x1B[0m \x1B[90m(${pages.current.length} total)\x1B[0m`);
+			for (const p of topPages) {
+				const pagePath = p.page.replace(/^https?:\/\/[^/]+/, "") || "/";
+				console.log(`    ${pagePath.slice(0, 50).padEnd(50)} ${formatNumber(p.clicks).padStart(8)} clicks ${formatPercent(p.clicksPercent)}`);
+			}
+			if (lostPages.length > 0) {
+				console.log();
+				console.log(`  \x1B[1mLost Pages\x1B[0m \x1B[90m(had traffic in previous period)\x1B[0m`);
+				for (const p of lostPages) {
+					const pagePath = p.page.replace(/^https?:\/\/[^/]+/, "") || "/";
+					console.log(`    \x1B[31m${pagePath.slice(0, 50).padEnd(50)}\x1B[0m ${formatNumber(p.prevClicks).padStart(8)} prev clicks`);
+				}
+			}
+			console.log();
+		}
+		if (args.type === "keywords" || args.type === "all") {
+			const keywords = await provider.getKeywordsWithComparison(siteArg, range).catch(gscErrorHandler);
+			const topKeywords = keywords.current.slice(0, limit);
+			const lostKeywords = keywords.previous.filter((k) => k.lost).slice(0, 5);
+			console.log(`  \x1B[1mTop Keywords\x1B[0m \x1B[90m(${keywords.current.length} total)\x1B[0m`);
+			for (const k of topKeywords) {
+				const posChange = k.prevPosition ? formatPercent(-((k.position || 0) - k.prevPosition) / k.prevPosition * 100) : "";
+				console.log(`    ${k.keyword.slice(0, 40).padEnd(40)} pos ${(k.position || 0).toFixed(1).padStart(5)} ${posChange} ${formatNumber(k.clicks).padStart(6)} clicks`);
+			}
+			if (lostKeywords.length > 0) {
+				console.log();
+				console.log(`  \x1B[1mLost Keywords\x1B[0m \x1B[90m(had traffic in previous period)\x1B[0m`);
+				for (const k of lostKeywords) console.log(`    \x1B[31m${k.keyword.slice(0, 40).padEnd(40)}\x1B[0m pos ${(k.prevPosition || 0).toFixed(1).padStart(5)} ${formatNumber(k.prevClicks).padStart(6)} prev clicks`);
+			}
+			console.log();
+		}
+		logger.success("Comparison complete");
+	}
+});
+
+//#endregion
+//#region src/commands/config.ts
+const showCommand = defineCommand({
+	meta: {
+		name: "show",
+		description: "Show current config"
+	},
+	async run() {
+		const config = await loadConfig();
+		const configPath = getConfigPath();
+		logger.info(`Config: ${configPath}`);
+		console.log();
+		if (Object.keys(config).length === 0) {
+			logger.warn("No config set");
+			return;
+		}
+		console.log(JSON.stringify(config, null, 2));
+	}
+});
+const setCommand = defineCommand({
+	meta: {
+		name: "set",
+		description: "Set a config value"
+	},
+	args: {
+		key: {
+			type: "positional",
+			description: "Config key (defaultSite, defaultPeriod, defaultFormat, defaultDb)",
+			required: true
+		},
+		value: {
+			type: "positional",
+			description: "Value to set",
+			required: true
+		}
+	},
+	async run({ args }) {
+		const validKeys = [
+			"defaultSite",
+			"defaultPeriod",
+			"defaultFormat",
+			"defaultDb"
+		];
+		if (!validKeys.includes(args.key)) {
+			logger.error(`Invalid key: ${args.key}`);
+			logger.info(`Valid keys: ${validKeys.join(", ")}`);
+			process.exit(1);
+		}
+		const config = await loadConfig();
+		config[args.key] = args.value;
+		await saveConfig(config);
+		logger.success(`Set ${args.key} = ${args.value}`);
+	}
+});
+const unsetCommand = defineCommand({
+	meta: {
+		name: "unset",
+		description: "Remove a config value"
+	},
+	args: { key: {
+		type: "positional",
+		description: "Config key to remove",
+		required: true
+	} },
+	async run({ args }) {
+		const config = await loadConfig();
+		delete config[args.key];
+		await saveConfig(config);
+		logger.success(`Removed ${args.key}`);
+	}
+});
+const pathCommand = defineCommand({
+	meta: {
+		name: "path",
+		description: "Show config file path"
+	},
+	run() {
+		console.log(getConfigPath());
+	}
+});
+const configCommand = defineCommand({
+	meta: {
+		name: "config",
+		description: "Manage configuration"
+	},
+	subCommands: {
+		show: showCommand,
+		set: setCommand,
+		unset: unsetCommand,
+		path: pathCommand
+	}
+});
+
+//#endregion
+//#region src/commands/dump.ts
+const DUMP_DATA_TYPES = [
+	"pages",
+	"keywords",
+	"countries",
+	"devices"
+];
+async function getSites(client) {
+	return (await fetchSites(client)).filter((site) => site.siteUrl && site.permissionLevel !== "siteUnverifiedUser").map((site) => site.siteUrl);
+}
+async function runDump(provider, selectedSites, dataTypes, period, format, outputFile, options = {}) {
+	const daysOffset = options.fresh ? 1 : 3;
+	const endDate = dayjs().subtract(daysOffset, "days").format("YYYY-MM-DD");
+	const startDate = dayjs().subtract(period.amount, period.unit).subtract(daysOffset, "days").format("YYYY-MM-DD");
+	const range = {
+		period: {
+			start: startDate,
+			end: endDate
+		},
+		prevPeriod: {
+			start: dayjs(startDate).subtract(period.amount, period.unit).format("YYYY-MM-DD"),
+			end: dayjs(endDate).subtract(period.amount, period.unit).format("YYYY-MM-DD")
+		}
+	};
+	for (const siteUrl of selectedSites) {
+		const siteName = siteUrl.replace(/https?:\/\//, "").replace(/\/$/, "");
+		const output = {
+			siteUrl,
+			source: provider.source,
+			dateRange: {
+				startDate,
+				endDate
+			},
+			period: {
+				amount: period.amount,
+				unit: period.unit
+			},
+			dataTypes,
+			fresh: options.fresh || false,
+			searchType: options.searchType || "web"
+		};
+		const totalSteps = dataTypes.length;
+		let currentStep = 0;
+		for (const dataType of dataTypes) {
+			currentStep++;
+			clearLine();
+			process.stdout.write(progressBar(currentStep, totalSteps, `${dataType} (${siteName})`));
+			if (dataType === "pages") {
+				const pages = await provider.getPages(siteUrl, range);
+				output.pages = {
+					total: pages.length,
+					data: pages
+				};
+			} else if (dataType === "keywords") {
+				const keywordsData = await provider.getKeywordsWithComparison(siteUrl, range);
+				output.keywords = {
+					total: keywordsData.current.length,
+					current: keywordsData.current,
+					previous: keywordsData.previous,
+					metadata: keywordsData.metadata
+				};
+			} else if (dataType === "countries") {
+				const countriesData = await provider.getCountriesWithComparison(siteUrl, range);
+				output.countries = {
+					current: countriesData.current,
+					previous: countriesData.previous,
+					metadata: countriesData.metadata
+				};
+			} else if (dataType === "devices") {
+				const devicesData = await provider.getDevicesWithComparison(siteUrl, range);
+				output.devices = {
+					current: devicesData.current,
+					previous: devicesData.previous,
+					metadata: devicesData.metadata
+				};
+			}
+		}
+		clearLine();
+		const ext = format === "csv" ? "csv" : "json";
+		const filename = outputFile || `gsc-${siteName.replace(/\//g, "_")}-${dataTypes.join("-")}-${period.amount}${period.unit[0]}-${endDate}.${ext}`;
+		const content = format === "csv" ? exportToCSV(output) : JSON.stringify(output, null, 2);
+		await fs.writeFile(filename, content);
+		const totalItems = (output.pages?.total || 0) + (output.keywords?.total || 0) + (output.countries?.current?.length || 0) + (output.devices?.current?.length || 0);
+		logger.success(`Saved ${totalItems} items to ${filename} (source: ${provider.source})`);
+	}
+}
+async function interactiveMode(auth, dbPath, source) {
+	process.stdout.write("  Fetching sites...");
+	const sites = await getSites(googleSearchConsole(auth));
+	clearLine();
+	logger.success(`Found ${sites.length} sites`);
+	if (sites.length === 0) {
+		cancel("No sites found in your Google Search Console account.");
+		return;
+	}
+	const selectedSites = await multiselect({
+		message: "Select sites to dump data from:",
+		options: sites.map((site) => ({
+			value: site,
+			label: site
+		}))
+	});
+	if (isCancel(selectedSites) || selectedSites.length === 0) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	const dataTypes = await multiselect({
+		message: "What data would you like to dump?",
+		options: [
+			{
+				value: "pages",
+				label: "Pages (URLs and performance data)",
+				hint: "recommended"
+			},
+			{
+				value: "keywords",
+				label: "Keywords (search queries and rankings)"
+			},
+			{
+				value: "countries",
+				label: "Countries (geographic performance)"
+			},
+			{
+				value: "devices",
+				label: "Devices (desktop, mobile, tablet)"
+			}
+		],
+		required: true
+	});
+	if (isCancel(dataTypes) || dataTypes.length === 0) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	const periodInput = await text({
+		message: "Time period (e.g., 90d, 6m, 1y):",
+		placeholder: "180d",
+		defaultValue: "180d",
+		validate: (value) => {
+			if (!value) return void 0;
+			return parsePeriod(value) ? void 0 : "Invalid format. Use: 90d, 6m, 1y";
+		}
+	});
+	if (isCancel(periodInput)) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	const formatResult = await multiselect({
+		message: "Output format:",
+		options: [{
+			value: "json",
+			label: "JSON",
+			hint: "structured data"
+		}, {
+			value: "csv",
+			label: "CSV",
+			hint: "spreadsheet compatible"
+		}],
+		required: true
+	});
+	if (isCancel(formatResult)) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	let finalSource = source;
+	if (dbPath && source === "auto") {
+		const sourceResult = await select({
+			message: "Data source:",
+			options: [
+				{
+					value: "auto",
+					label: "Auto",
+					hint: "use DB if data exists, else API"
+				},
+				{
+					value: "api",
+					label: "API",
+					hint: "always fetch from Google"
+				},
+				{
+					value: "db",
+					label: "Database",
+					hint: "use synced data"
+				}
+			]
+		});
+		if (isCancel(sourceResult)) {
+			cancel("Operation cancelled.");
+			return;
+		}
+		finalSource = sourceResult;
+	}
+	const format = formatResult[0];
+	const period = parsePeriod(periodInput || "180d");
+	const ready = await confirm({ message: `Dump ${dataTypes.join(", ")} for ${selectedSites.length} site(s), ${period.amount}${period.unit[0]}, as ${format.toUpperCase()}?` });
+	if (isCancel(ready) || !ready) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	console.log();
+	const endDate = dayjs().subtract(3, "days").format("YYYY-MM-DD");
+	const startDate = dayjs().subtract(period.amount, period.unit).subtract(3, "days").format("YYYY-MM-DD");
+	const range = {
+		period: {
+			start: startDate,
+			end: endDate
+		},
+		prevPeriod: {
+			start: dayjs(startDate).subtract(period.amount, period.unit).format("YYYY-MM-DD"),
+			end: dayjs(endDate).subtract(period.amount, period.unit).format("YYYY-MM-DD")
+		}
+	};
+	let db = null;
+	if (dbPath) {
+		if (await fs.access(dbPath).then(() => true).catch(() => false)) db = createGscDb(betterSqlite3({ name: path.resolve(dbPath) })).db;
+	}
+	const provider = await createProvider({
+		auth,
+		db,
+		source: finalSource,
+		siteUrls: selectedSites,
+		range
+	});
+	logger.info(`Using ${provider.source.toUpperCase()} as data source`);
+	await runDump(provider, selectedSites, dataTypes, period, format, null);
+}
+async function nonInteractiveMode(auth, site, data, periodStr, format, output, dbPath, source, options = {}) {
+	if (site.length === 0) {
+		logger.error("--site required in non-interactive mode");
+		process.exit(1);
+	}
+	if (data.length === 0) {
+		logger.error("--data required in non-interactive mode");
+		process.exit(1);
+	}
+	const invalidData = data.filter((d) => !DUMP_DATA_TYPES.includes(d));
+	if (invalidData.length > 0) {
+		logger.error(`Invalid data types: ${invalidData.join(", ")}`);
+		logger.info("Valid types: pages, keywords, countries, devices");
+		process.exit(1);
+	}
+	const period = parsePeriod(periodStr);
+	if (!period) {
+		logger.error(`Invalid period: ${periodStr}`);
+		logger.info("Examples: 90d, 6m, 1y");
+		process.exit(1);
+	}
+	process.stdout.write("  Validating sites...");
+	const availableSites = await getSites(googleSearchConsole(auth));
+	clearLine();
+	const normalizedSites = [];
+	for (const s of site) {
+		const match = availableSites.find((avail) => avail === s || avail === `https://${s}` || avail === `http://${s}` || avail === `sc-domain:${s}` || avail.replace(/https?:\/\//, "").replace(/\/$/, "") === s.replace(/\/$/, ""));
+		if (!match) {
+			logger.error(`Site not found: ${s}`);
+			logger.info("Available sites:");
+			availableSites.slice(0, 5).forEach((a) => console.log(`    - ${a}`));
+			if (availableSites.length > 5) console.log(`    ... and ${availableSites.length - 5} more`);
+			process.exit(1);
+		}
+		normalizedSites.push(match);
+	}
+	const daysOffset = options.fresh ? 1 : 3;
+	const endDate = dayjs().subtract(daysOffset, "days").format("YYYY-MM-DD");
+	const startDate = dayjs().subtract(period.amount, period.unit).subtract(daysOffset, "days").format("YYYY-MM-DD");
+	const range = {
+		period: {
+			start: startDate,
+			end: endDate
+		},
+		prevPeriod: {
+			start: dayjs(startDate).subtract(period.amount, period.unit).format("YYYY-MM-DD"),
+			end: dayjs(endDate).subtract(period.amount, period.unit).format("YYYY-MM-DD")
+		}
+	};
+	let db = null;
+	if (dbPath) {
+		if (await fs.access(dbPath).then(() => true).catch(() => false)) db = createGscDb(betterSqlite3({ name: path.resolve(dbPath) })).db;
+		else if (source === "db") {
+			logger.error(`Database not found: ${dbPath}`);
+			logger.info("Run 'gscdump sync' first to create the database.");
+			process.exit(1);
+		}
+	}
+	const provider = await createProvider({
+		auth,
+		db,
+		source,
+		siteUrls: normalizedSites,
+		range
+	}).catch(gscErrorHandler);
+	const extras = [];
+	if (options.fresh) extras.push("fresh");
+	if (options.searchType && options.searchType !== "web") extras.push(options.searchType);
+	const extrasStr = extras.length ? ` [${extras.join(", ")}]` : "";
+	logger.info(`${normalizedSites.length} site(s), ${data.join("+")} data, ${period.amount}${period.unit[0]}, ${format}, source: ${provider.source}${extrasStr}`);
+	console.log();
+	await runDump(provider, normalizedSites, data, period, format, output, options);
+}
+const dumpCommand = defineCommand({
+	meta: {
+		name: "dump",
+		description: "Export GSC data to JSON or CSV files"
+	},
+	args: {
+		site: {
+			type: "string",
+			alias: "s",
+			description: "Site URL (comma-separated for multiple)"
+		},
+		data: {
+			type: "string",
+			alias: "d",
+			description: "Data types: pages,keywords,countries,devices"
+		},
+		period: {
+			type: "string",
+			alias: "p",
+			default: "180d",
+			description: "Time period: 90d, 6m, 1y"
+		},
+		format: {
+			type: "string",
+			alias: "f",
+			default: "json",
+			description: "Output format: json, csv"
+		},
+		output: {
+			type: "string",
+			alias: "o",
+			description: "Output filename"
+		},
+		source: {
+			type: "string",
+			default: "auto",
+			description: "Data source: auto, api, db"
+		},
+		db: {
+			type: "string",
+			description: "SQLite database path (for db/auto source)"
+		},
+		fresh: {
+			type: "boolean",
+			default: false,
+			description: "Include fresh/unfinalized data (last 3 days)"
+		},
+		type: {
+			type: "string",
+			alias: "t",
+			default: "web",
+			description: "Search type: web, image, video, news, discover, googleNews"
+		}
+	},
+	async run({ args }) {
+		const config = await loadConfig();
+		const siteArg = args.site || config.defaultSite;
+		const sites = siteArg ? siteArg.split(",") : [];
+		const data = args.data ? args.data.split(",") : [];
+		const periodArg = args.period === "180d" && config.defaultPeriod ? config.defaultPeriod : args.period;
+		const formatArg = args.format === "json" && config.defaultFormat ? config.defaultFormat : args.format;
+		const dbPath = args.db || config.defaultDb || null;
+		const source = [
+			"auto",
+			"api",
+			"db"
+		].includes(args.source) ? args.source : "auto";
+		const isInteractive = sites.length === 0 && data.length === 0;
+		const { getAuth: getAuth$1 } = await Promise.resolve().then(() => auth_exports);
+		const auth = await getAuth$1({
+			interactive: isInteractive,
+			config
+		});
+		const searchType = [
+			"web",
+			"image",
+			"video",
+			"news",
+			"discover",
+			"googleNews"
+		].includes(args.type) ? args.type : "web";
+		const options = {
+			fresh: args.fresh,
+			searchType
+		};
+		if (isInteractive) await interactiveMode(auth, dbPath, source);
+		else await nonInteractiveMode(auth, sites, data, periodArg, formatArg === "csv" ? "csv" : "json", args.output || null, dbPath, source, options);
+		logger.success("Done!");
+	}
+});
+
+//#endregion
+//#region src/commands/indexing.ts
+const inspectCommand = defineCommand({
+	meta: {
+		name: "inspect",
+		description: "Inspect URLs to check their indexing status (shorthand for `gscdump index inspect`)"
+	},
+	args: {
+		db: {
+			type: "string",
+			alias: "d",
+			default: "./gscdump.db",
+			description: "SQLite database path"
+		},
+		site: {
+			type: "string",
+			alias: "s",
+			description: "Site URL (e.g., sc-domain:example.com)"
+		},
+		limit: {
+			type: "string",
+			alias: "l",
+			default: "100",
+			description: "Max URLs to inspect"
+		},
+		delay: {
+			type: "string",
+			default: "200",
+			description: "Delay between requests (ms)"
+		},
+		quiet: {
+			type: "boolean",
+			alias: "q",
+			default: false,
+			description: "Suppress progress output"
+		},
+		json: {
+			type: "boolean",
+			default: false,
+			description: "Output as JSON"
+		}
+	},
+	async run({ args }) {
+		const config = await loadConfig();
+		const dbPath = String(args.db === "./gscdump.db" && config.defaultDb ? config.defaultDb : args.db);
+		const siteArg = String(args.site || config.defaultSite || "");
+		if (!siteArg) {
+			logger.error("Site required. Use --site or set defaultSite in config.");
+			process.exit(1);
+		}
+		const { getAuth: getAuth$1 } = await Promise.resolve().then(() => auth_exports);
+		const client = googleSearchConsole(await getAuth$1({
+			interactive: false,
+			config
+		}));
+		const { db, db0 } = createGscDb(betterSqlite3({ name: path.resolve(dbPath) }));
+		await setupSchema(db0);
+		await syncSites(db, client).catch(gscErrorHandler);
+		const siteRecord = await getSiteByProperty(db, siteArg);
+		if (!siteRecord) {
+			logger.error(`Site not found: ${siteArg}`);
+			process.exit(1);
+		}
+		const siteId = siteRecord.site_id || siteRecord.siteId;
+		const limit = Number.parseInt(String(args.limit), 10);
+		const delayMs = Number.parseInt(String(args.delay), 10);
+		const paths = await db.selectDistinct({ path: sitePathDateAnalytics.path }).from(sitePathDateAnalytics).where(eq(sitePathDateAnalytics.siteId, siteId)).limit(limit);
+		if (paths.length === 0) {
+			logger.warn("No URLs found. Run `gscdump sync` first.");
+			return;
+		}
+		if (!args.quiet && !args.json) logger.info(`Inspecting ${paths.length} URLs...`);
+		const results = [];
+		const stats = await batchInspectUrls(db, client, siteId, siteArg, paths.map((p) => p.path), {
+			delayMs,
+			onProgress: (result, i, total) => {
+				results.push(result);
+				if (!args.quiet && !args.json) {
+					clearLine();
+					process.stdout.write(progressBar(i + 1, total, result.path.slice(0, 40)));
+				}
+			}
+		}).catch(gscErrorHandler);
+		if (!args.quiet && !args.json) clearLine();
+		if (args.json) console.log(JSON.stringify({
+			stats,
+			results
+		}, null, 2));
+		else {
+			console.log();
+			logger.success(`Inspected ${paths.length} URLs`);
+			console.log(`  Indexed:     ${stats.indexed}`);
+			console.log(`  Not Indexed: ${stats.notIndexed}`);
+			console.log(`  Errors:      ${stats.errors}`);
+			console.log();
+		}
+	}
+});
+const indexingCommand = defineCommand({
+	meta: {
+		name: "index",
+		description: "Manage URL indexing via Google Indexing API"
+	},
+	subCommands: {
+		status: defineCommand({
+			meta: {
+				name: "status",
+				description: "Show indexing status for URLs"
+			},
+			args: {
+				db: {
+					type: "string",
+					alias: "d",
+					default: "./gscdump.db",
+					description: "SQLite database path"
+				},
+				site: {
+					type: "string",
+					alias: "s",
+					description: "Site URL (e.g., sc-domain:example.com)"
+				},
+				json: {
+					type: "boolean",
+					default: false,
+					description: "Output as JSON"
+				}
+			},
+			async run({ args }) {
+				const config = await loadConfig();
+				const dbPath = String(args.db === "./gscdump.db" && config.defaultDb ? config.defaultDb : args.db);
+				const siteArg = String(args.site || config.defaultSite || "");
+				if (!siteArg) {
+					logger.error("Site required. Use --site or set defaultSite in config.");
+					process.exit(1);
+				}
+				const { db, db0 } = createGscDb(betterSqlite3({ name: path.resolve(dbPath) }));
+				await setupSchema(db0);
+				const siteRecord = await getSiteByProperty(db, siteArg);
+				if (!siteRecord) {
+					logger.error(`Site not found: ${siteArg}`);
+					process.exit(1);
+				}
+				const stats = await getIndexingStats(db, siteRecord.site_id || siteRecord.siteId);
+				if (args.json) console.log(JSON.stringify(stats, null, 2));
+				else {
+					console.log();
+					logger.info(`Indexing Status for ${siteArg}`);
+					console.log();
+					console.log(`  Total URLs:    ${stats.total}`);
+					console.log(`  Indexed:       ${stats.indexed} (${stats.total ? Math.round(stats.indexed / stats.total * 100) : 0}%)`);
+					console.log(`  Not Indexed:   ${stats.notIndexed}`);
+					console.log(`  Unknown:       ${stats.unknown}`);
+					console.log(`  Requested:     ${stats.requested}`);
+					console.log();
+				}
+			}
+		}),
+		inspect: defineCommand({
+			meta: {
+				name: "inspect",
+				description: "Inspect URLs to check their indexing status"
+			},
+			args: {
+				db: {
+					type: "string",
+					alias: "d",
+					default: "./gscdump.db",
+					description: "SQLite database path"
+				},
+				site: {
+					type: "string",
+					alias: "s",
+					description: "Site URL (e.g., sc-domain:example.com)"
+				},
+				limit: {
+					type: "string",
+					alias: "l",
+					default: "100",
+					description: "Max URLs to inspect"
+				},
+				delay: {
+					type: "string",
+					default: "200",
+					description: "Delay between requests (ms)"
+				},
+				quiet: {
+					type: "boolean",
+					alias: "q",
+					default: false,
+					description: "Suppress progress output"
+				},
+				json: {
+					type: "boolean",
+					default: false,
+					description: "Output as JSON"
+				}
+			},
+			async run({ args }) {
+				const config = await loadConfig();
+				const dbPath = String(args.db === "./gscdump.db" && config.defaultDb ? config.defaultDb : args.db);
+				const siteArg = String(args.site || config.defaultSite || "");
+				if (!siteArg) {
+					logger.error("Site required. Use --site or set defaultSite in config.");
+					process.exit(1);
+				}
+				const { getAuth: getAuth$1 } = await Promise.resolve().then(() => auth_exports);
+				const client = googleSearchConsole(await getAuth$1({
+					interactive: false,
+					config
+				}));
+				const { db, db0 } = createGscDb(betterSqlite3({ name: path.resolve(dbPath) }));
+				await setupSchema(db0);
+				await syncSites(db, client).catch(gscErrorHandler);
+				const siteRecord = await getSiteByProperty(db, siteArg);
+				if (!siteRecord) {
+					logger.error(`Site not found: ${siteArg}`);
+					process.exit(1);
+				}
+				const siteId = siteRecord.site_id || siteRecord.siteId;
+				const limit = Number.parseInt(String(args.limit), 10);
+				const delayMs = Number.parseInt(String(args.delay), 10);
+				const paths = await db.selectDistinct({ path: sitePathDateAnalytics.path }).from(sitePathDateAnalytics).where(eq(sitePathDateAnalytics.siteId, siteId)).limit(limit);
+				if (paths.length === 0) {
+					logger.warn("No URLs found. Run `gscdump sync` first.");
+					return;
+				}
+				if (!args.quiet && !args.json) logger.info(`Inspecting ${paths.length} URLs...`);
+				const results = [];
+				const stats = await batchInspectUrls(db, client, siteId, siteArg, paths.map((p) => p.path), {
+					delayMs,
+					onProgress: (result, i, total) => {
+						results.push(result);
+						if (!args.quiet && !args.json) {
+							clearLine();
+							process.stdout.write(progressBar(i + 1, total, result.path.slice(0, 40)));
+						}
+					}
+				}).catch(gscErrorHandler);
+				if (!args.quiet && !args.json) clearLine();
+				if (args.json) console.log(JSON.stringify({
+					stats,
+					results
+				}, null, 2));
+				else {
+					console.log();
+					logger.success(`Inspected ${paths.length} URLs`);
+					console.log(`  Indexed:     ${stats.indexed}`);
+					console.log(`  Not Indexed: ${stats.notIndexed}`);
+					console.log(`  Errors:      ${stats.errors}`);
+					console.log();
+				}
+			}
+		}),
+		request: defineCommand({
+			meta: {
+				name: "request",
+				description: "Request indexing for URLs via Google Indexing API"
+			},
+			args: {
+				"db": {
+					type: "string",
+					alias: "d",
+					default: "./gscdump.db",
+					description: "SQLite database path"
+				},
+				"site": {
+					type: "string",
+					alias: "s",
+					description: "Site URL (e.g., sc-domain:example.com)"
+				},
+				"limit": {
+					type: "string",
+					alias: "l",
+					default: "200",
+					description: "Max URLs to request (API quota: 200/day)"
+				},
+				"delay": {
+					type: "string",
+					default: "100",
+					description: "Delay between requests (ms)"
+				},
+				"type": {
+					type: "string",
+					alias: "t",
+					default: "URL_UPDATED",
+					description: "Notification type: URL_UPDATED or URL_DELETED"
+				},
+				"not-indexed": {
+					type: "boolean",
+					default: true,
+					description: "Only request for non-indexed URLs"
+				},
+				"quiet": {
+					type: "boolean",
+					alias: "q",
+					default: false,
+					description: "Suppress progress output"
+				},
+				"json": {
+					type: "boolean",
+					default: false,
+					description: "Output as JSON"
+				}
+			},
+			async run({ args }) {
+				const config = await loadConfig();
+				const dbPath = String(args.db === "./gscdump.db" && config.defaultDb ? config.defaultDb : args.db);
+				const siteArg = String(args.site || config.defaultSite || "");
+				if (!siteArg) {
+					logger.error("Site required. Use --site or set defaultSite in config.");
+					process.exit(1);
+				}
+				const { getAuth: getAuth$1 } = await Promise.resolve().then(() => auth_exports);
+				const client = googleSearchConsole(await getAuth$1({
+					interactive: false,
+					config
+				}));
+				const { db, db0 } = createGscDb(betterSqlite3({ name: path.resolve(dbPath) }));
+				await setupSchema(db0);
+				await syncSites(db, client).catch(gscErrorHandler);
+				const siteRecord = await getSiteByProperty(db, siteArg);
+				if (!siteRecord) {
+					logger.error(`Site not found: ${siteArg}`);
+					process.exit(1);
+				}
+				const siteId = siteRecord.site_id || siteRecord.siteId;
+				const limit = Number.parseInt(String(args.limit), 10);
+				const delayMs = Number.parseInt(String(args.delay), 10);
+				const type = String(args.type);
+				const paths = await db.selectDistinct({ path: sitePathDateAnalytics.path }).from(sitePathDateAnalytics).where(eq(sitePathDateAnalytics.siteId, siteId)).limit(limit);
+				if (paths.length === 0) {
+					logger.warn("No URLs found. Run `gscdump sync` first.");
+					return;
+				}
+				if (!args.quiet && !args.json) {
+					logger.info(`Requesting indexing for ${paths.length} URLs...`);
+					logger.warn("Note: Indexing API quota is typically 200 requests/day");
+				}
+				const results = [];
+				const stats = await batchRequestIndexingForPaths(db, client, siteId, siteArg, paths.map((p) => p.path), {
+					type,
+					delayMs,
+					onProgress: (result, i, total) => {
+						results.push(result);
+						if (!args.quiet && !args.json) {
+							clearLine();
+							const status = result.error ? "ERR" : "OK";
+							process.stdout.write(progressBar(i + 1, total, `[${status}] ${result.url.slice(-40)}`));
+						}
+					}
+				}).catch(gscErrorHandler);
+				if (!args.quiet && !args.json) clearLine();
+				if (args.json) console.log(JSON.stringify({
+					stats,
+					results
+				}, null, 2));
+				else {
+					console.log();
+					logger.success(`Requested indexing for ${paths.length} URLs`);
+					console.log(`  Success: ${stats.success}`);
+					console.log(`  Errors:  ${stats.errors}`);
+					console.log();
+					if (stats.errors > 0) {
+						const errorResults = results.filter((r) => r.error);
+						logger.warn("Errors:");
+						errorResults.slice(0, 5).forEach((r) => {
+							console.log(`  ${r.url}: ${r.error}`);
+						});
+						if (errorResults.length > 5) console.log(`  ... and ${errorResults.length - 5} more`);
+					}
+				}
+			}
+		})
+	}
+});
+
+//#endregion
+//#region src/commands/init.ts
+async function loadEnvFile() {
+	const envPath = path.join(process.cwd(), ".env");
+	const content = await fs.readFile(envPath, "utf-8").catch(() => null);
+	if (!content) return null;
+	const env = {};
+	for (const line of content.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("#")) continue;
+		const match = trimmed.match(/^([^=]+)=(.*)$/);
+		if (match) {
+			const key = match[1].trim();
+			let value = match[2].trim();
+			if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
+			env[key] = value;
+		}
+	}
+	return env;
+}
+const initCommand = defineCommand({
+	meta: {
+		name: "init",
+		description: "Set up GSCDump (choose cloud or local mode)"
+	},
+	args: { force: {
+		type: "boolean",
+		alias: "f",
+		description: "Force re-initialization"
+	} },
+	async run({ args }) {
+		const config = await loadConfig();
+		if (config.mode && !args.force) {
+			logger.info(`Already configured in ${config.mode} mode`);
+			logger.info("Run with --force to reconfigure");
+			return;
+		}
+		const envFile = await loadEnvFile();
+		if (envFile?.GOOGLE_CLIENT_ID && envFile?.GOOGLE_CLIENT_SECRET && envFile?.GOOGLE_REFRESH_TOKEN) {
+			logger.info("Found .env file with Google credentials");
+			process.env.GOOGLE_CLIENT_ID = envFile.GOOGLE_CLIENT_ID;
+			process.env.GOOGLE_CLIENT_SECRET = envFile.GOOGLE_CLIENT_SECRET;
+			process.env.GOOGLE_REFRESH_TOKEN = envFile.GOOGLE_REFRESH_TOKEN;
+			if (envFile.GOOGLE_ACCESS_TOKEN) process.env.GOOGLE_ACCESS_TOKEN = envFile.GOOGLE_ACCESS_TOKEN;
+			await saveConfig({
+				...config,
+				mode: "local",
+				clientId: envFile.GOOGLE_CLIENT_ID,
+				clientSecret: envFile.GOOGLE_CLIENT_SECRET
+			});
+			const creds = (await authenticate({
+				clientId: envFile.GOOGLE_CLIENT_ID,
+				clientSecret: envFile.GOOGLE_CLIENT_SECRET
+			}, false)).credentials;
+			if (creds.access_token) await saveTokens({
+				access_token: creds.access_token,
+				refresh_token: creds.refresh_token || envFile.GOOGLE_REFRESH_TOKEN,
+				expiry_date: creds.expiry_date
+			});
+			console.log();
+			logger.success("Setup complete using .env credentials! Run gscdump to get started.");
+			return;
+		}
+		console.log();
+		console.log("  \x1B[1mWelcome to GSCDump!\x1B[0m");
+		console.log("  \x1B[90mGoogle Search Console data extraction CLI\x1B[0m");
+		console.log();
+		const mode = await select({
+			message: "Choose your setup mode:",
+			options: [{
+				value: "cloud",
+				label: "Cloud (Recommended)",
+				hint: "Easy setup via cloud.gscdump.com - no API keys needed"
+			}, {
+				value: "local",
+				label: "Local",
+				hint: "Use your own Google OAuth credentials"
+			}]
+		});
+		if (isCancel(mode)) process.exit(1);
+		if (mode === "cloud") {
+			const cloudUrl = config.cloudUrl || DEFAULT_CLOUD_URL;
+			await saveConfig({
+				...config,
+				mode: "cloud",
+				cloudUrl
+			});
+			await authenticateCloud(cloudUrl, true);
+		} else {
+			await saveConfig({
+				...config,
+				mode: "local"
+			});
+			await authenticate(await getAuthCredentials(true), true);
+		}
+		console.log();
+		logger.success("Setup complete! Run gscdump to get started.");
+	}
+});
+
+//#endregion
+//#region src/commands/mcp.ts
+async function checkAuth() {
+	if ((process.env.GOOGLE_ACCESS_TOKEN || process.env.GOOGLE_REFRESH_TOKEN) && process.env.GOOGLE_CLIENT_ID && process.env.GOOGLE_CLIENT_SECRET) return { ok: true };
+	const config = await loadConfig();
+	if (!config.mode) return {
+		ok: false,
+		error: `GSCDump not configured.
+
+Run this command to set up authentication:
+
+  npx @gscdump/cli init
+
+Or provide env vars: GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET, GOOGLE_ACCESS_TOKEN
+
+Then restart your MCP client.`
+	};
+	if (config.mode === "cloud") {
+		if (!await loadCloudTokens()) return {
+			ok: false,
+			error: `Cloud authentication expired or missing.
+
+Run this command to re-authenticate:
+
+  npx @gscdump/cli init
+
+Then restart your MCP client.`
+		};
+	} else if (!await loadTokens()) return {
+		ok: false,
+		error: `Local authentication missing.
+
+Run this command to authenticate:
+
+  npx @gscdump/cli auth
+
+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: () => getAuth({ interactive: false })
+		});
+		const transport = new StdioServerTransport();
+		await server.connect(transport);
+	}
+});
+
+//#endregion
+//#region src/commands/sitemaps.ts
+const listCommand = defineCommand({
+	meta: {
+		name: "list",
+		description: "List sitemaps for a site"
+	},
+	args: {
+		site: {
+			type: "string",
+			alias: "s",
+			required: true,
+			description: "Site URL (e.g., sc-domain:example.com or https://example.com/)"
+		},
+		json: {
+			type: "boolean",
+			default: false,
+			description: "Output as JSON"
+		}
+	},
+	async run({ args }) {
+		const sitemaps = await fetchSitemaps(googleSearchConsole(await getAuth({ interactive: false })), args.site).catch(gscErrorHandler);
+		if (args.json) {
+			console.log(JSON.stringify(sitemaps, null, 2));
+			return;
+		}
+		if (sitemaps.length === 0) {
+			logger.warn("No sitemaps found");
+			return;
+		}
+		logger.success(`Found ${sitemaps.length} sitemaps:`);
+		console.log();
+		for (const sm of sitemaps) {
+			const pending = sm.isPending ? " \x1B[33m(pending)\x1B[0m" : "";
+			const errors = sm.errors ? ` \x1B[31m${sm.errors} errors\x1B[0m` : "";
+			const warnings = sm.warnings ? ` \x1B[33m${sm.warnings} warnings\x1B[0m` : "";
+			console.log(`  ${sm.path}${pending}${errors}${warnings}`);
+		}
+	}
+});
+const getCommand = defineCommand({
+	meta: {
+		name: "get",
+		description: "Get details for a specific sitemap"
+	},
+	args: {
+		site: {
+			type: "string",
+			alias: "s",
+			required: true,
+			description: "Site URL"
+		},
+		url: {
+			type: "positional",
+			required: true,
+			description: "Sitemap URL"
+		},
+		json: {
+			type: "boolean",
+			default: false,
+			description: "Output as JSON"
+		}
+	},
+	async run({ args }) {
+		const sitemap = await fetchSitemap(googleSearchConsole(await getAuth({ interactive: false })), args.site, args.url).catch(gscErrorHandler);
+		if (args.json) {
+			console.log(JSON.stringify(sitemap, null, 2));
+			return;
+		}
+		console.log();
+		console.log(`  \x1B[1mPath:\x1B[0m ${sitemap.path}`);
+		console.log(`  \x1B[1mType:\x1B[0m ${sitemap.type || "sitemap"}`);
+		console.log(`  \x1B[1mLast Submitted:\x1B[0m ${sitemap.lastSubmitted || "N/A"}`);
+		console.log(`  \x1B[1mLast Downloaded:\x1B[0m ${sitemap.lastDownloaded || "N/A"}`);
+		console.log(`  \x1B[1mPending:\x1B[0m ${sitemap.isPending ? "Yes" : "No"}`);
+		console.log(`  \x1B[1mErrors:\x1B[0m ${sitemap.errors || 0}`);
+		console.log(`  \x1B[1mWarnings:\x1B[0m ${sitemap.warnings || 0}`);
+		if (sitemap.contents?.length) {
+			console.log();
+			console.log("  \x1B[1mContents:\x1B[0m");
+			for (const c of sitemap.contents) console.log(`    ${c.type}: ${c.submitted} submitted, ${c.indexed} indexed`);
+		}
+	}
+});
+const submitCommand = defineCommand({
+	meta: {
+		name: "submit",
+		description: "Submit a sitemap to GSC"
+	},
+	args: {
+		site: {
+			type: "string",
+			alias: "s",
+			required: true,
+			description: "Site URL"
+		},
+		url: {
+			type: "positional",
+			required: true,
+			description: "Sitemap URL to submit"
+		}
+	},
+	async run({ args }) {
+		await submitSitemap(googleSearchConsole(await getAuth({ interactive: false })), args.site, args.url).catch(gscErrorHandler);
+		logger.success(`Submitted sitemap: ${args.url}`);
+	}
+});
+const deleteCommand = defineCommand({
+	meta: {
+		name: "delete",
+		description: "Delete a sitemap from GSC"
+	},
+	args: {
+		site: {
+			type: "string",
+			alias: "s",
+			required: true,
+			description: "Site URL"
+		},
+		url: {
+			type: "positional",
+			required: true,
+			description: "Sitemap URL to delete"
+		}
+	},
+	async run({ args }) {
+		await deleteSitemap(googleSearchConsole(await getAuth({ interactive: false })), args.site, args.url).catch(gscErrorHandler);
+		logger.success(`Deleted sitemap: ${args.url}`);
+	}
+});
+const sitemapsCommand = defineCommand({
+	meta: {
+		name: "sitemaps",
+		description: "Manage sitemaps"
+	},
+	subCommands: {
+		list: listCommand,
+		get: getCommand,
+		submit: submitCommand,
+		delete: deleteCommand
+	}
+});
+
+//#endregion
+//#region src/commands/sites.ts
+const sitesCommand = defineCommand({
+	meta: {
+		name: "sites",
+		description: "List available GSC sites"
+	},
+	args: { json: {
+		type: "boolean",
+		default: false,
+		description: "Output as JSON for scripting"
+	} },
+	async run({ args }) {
+		const sites = (await fetchSites(googleSearchConsole(await getAuth({ interactive: false }))).catch(gscErrorHandler)).filter((site) => site.siteUrl && site.permissionLevel !== "siteUnverifiedUser").map((site) => ({
+			url: site.siteUrl,
+			permission: site.permissionLevel || "unknown"
+		}));
+		if (args.json) {
+			console.log(JSON.stringify(sites, null, 2));
+			return;
+		}
+		if (sites.length === 0) {
+			logger.warn("No verified sites found");
+			return;
+		}
+		logger.success(`Found ${sites.length} sites:`);
+		console.log();
+		for (const site of sites) {
+			const perm = site.permission === "siteOwner" ? "\x1B[32m" : "\x1B[90m";
+			console.log(`  ${site.url} ${perm}(${site.permission})\x1B[0m`);
+		}
+	}
+});
+
+//#endregion
+//#region src/commands/sync.ts
+async function runSync(client, dbPath, siteArg, period, granular, options) {
+	const resolvedPath = path.resolve(dbPath);
+	const report = {
+		database: resolvedPath,
+		period: {
+			start: "",
+			end: ""
+		},
+		sites: [],
+		totalRows: 0
+	};
+	if (!options.quiet && !options.json) logger.info(`Database: ${resolvedPath}`);
+	const { db, db0 } = createGscDb(betterSqlite3({ name: resolvedPath }));
+	await setupSchema(db0);
+	if (!options.quiet && !options.json) logger.start("Syncing sites...");
+	const syncedSites = await syncSites(db, client);
+	if (!options.quiet && !options.json) logger.success(`Synced ${syncedSites.length} sites`);
+	let sitesToSync = [];
+	if (siteArg) {
+		const siteRecord = await getSiteByProperty(db, siteArg);
+		if (!siteRecord) {
+			if (options.json) console.log(JSON.stringify({ error: `Site not found: ${siteArg}` }));
+			else {
+				logger.error(`Site not found: ${siteArg}`);
+				logger.info("Available sites:");
+				syncedSites.slice(0, 5).forEach((s) => console.log(`    - ${s.property}`));
+			}
+			process.exit(1);
+		}
+		sitesToSync = [{
+			siteId: siteRecord.site_id || siteRecord.siteId,
+			siteUrl: siteRecord.property
+		}];
+	} else sitesToSync = syncedSites.map((s) => ({
+		siteId: s.siteId,
+		siteUrl: s.property
+	}));
+	const periodRange = userPeriodRange(period);
+	const daysOffset = options.fresh ? 1 : 3;
+	const adjustedEndDate = dayjs(periodRange.period.endDate).subtract(daysOffset, "day").format("YYYY-MM-DD");
+	const baseStartDate = dayjs(periodRange.period.startDate).subtract(daysOffset, "day").format("YYYY-MM-DD");
+	const adjustedPrevEndDate = dayjs(periodRange.prevPeriod.endDate).subtract(daysOffset, "day").format("YYYY-MM-DD");
+	const adjustedPrevStartDate = dayjs(periodRange.prevPeriod.startDate).subtract(daysOffset, "day").format("YYYY-MM-DD");
+	const getRangeForSite = async (siteId) => {
+		let startDate = baseStartDate;
+		if (options.since) startDate = options.since;
+		else if (options.incremental) {
+			const lastSynced = await getLastSyncedDate(db, siteId);
+			if (lastSynced) {
+				const incrementalStart = dayjs(lastSynced).add(1, "day").format("YYYY-MM-DD");
+				startDate = incrementalStart > baseStartDate ? incrementalStart : baseStartDate;
+			}
+		}
+		if (startDate > adjustedEndDate) return {
+			range: {
+				period: {
+					start: startDate,
+					end: adjustedEndDate
+				},
+				prevPeriod: {
+					start: adjustedPrevStartDate,
+					end: adjustedPrevEndDate
+				}
+			},
+			startDate,
+			skipped: true
+		};
+		return {
+			range: {
+				period: {
+					start: startDate,
+					end: adjustedEndDate
+				},
+				prevPeriod: {
+					start: adjustedPrevStartDate,
+					end: adjustedPrevEndDate
+				}
+			},
+			startDate,
+			skipped: false
+		};
+	};
+	report.period = {
+		start: options.since || baseStartDate,
+		end: adjustedEndDate
+	};
+	if (!options.quiet && !options.json) {
+		const modeNote = options.incremental ? " (incremental)" : options.since ? ` (since ${options.since})` : options.fresh ? " (fresh)" : "";
+		logger.info(`Period: ${options.since || baseStartDate} to ${adjustedEndDate}${modeNote}`);
+		console.log();
+	}
+	const dataTypes = granular ? [
+		"pages",
+		"keywords",
+		"keyword-paths",
+		"countries",
+		"devices"
+	] : [
+		"pages",
+		"keywords",
+		"countries",
+		"devices"
+	];
+	for (const { siteId, siteUrl } of sitesToSync) {
+		const siteName = siteUrl.replace(/^(sc-domain:|https?:\/\/)/, "");
+		const { range, startDate, skipped } = await getRangeForSite(siteId);
+		if (skipped) {
+			if (!options.quiet && !options.json) logger.info(`${siteName} is up to date (last synced: ${startDate})`);
+			continue;
+		}
+		const siteReport = {
+			site: siteUrl,
+			rows: {
+				pages: 0,
+				keywords: 0,
+				countries: 0,
+				devices: 0,
+				total: 0
+			}
+		};
+		if (!options.quiet && !options.json && (options.incremental || options.since)) logger.info(`${siteName}: syncing ${startDate} to ${adjustedEndDate}`);
+		for (let i = 0; i < dataTypes.length; i++) {
+			const dataType = dataTypes[i];
+			if (!options.quiet && !options.json) {
+				clearLine();
+				process.stdout.write(progressBar(i + 1, dataTypes.length, `${dataType} (${siteName})`));
+			}
+			let rows = [];
+			if (dataType === "pages") {
+				rows = await syncPages(db, client, siteId, siteUrl, range);
+				siteReport.rows.pages = rows.length;
+			} else if (dataType === "keywords") {
+				rows = await syncKeywords(db, client, siteId, siteUrl, range);
+				siteReport.rows.keywords = rows.length;
+			} else if (dataType === "keyword-paths") {
+				rows = await syncKeywordPaths(db, client, siteId, siteUrl, range);
+				siteReport.rows.keywordPaths = rows.length;
+			} else if (dataType === "countries") {
+				rows = await syncCountries(db, client, siteId, siteUrl, range);
+				siteReport.rows.countries = rows.length;
+			} else if (dataType === "devices") {
+				rows = await syncDevices(db, client, siteId, siteUrl, range);
+				siteReport.rows.devices = rows.length;
+			}
+			siteReport.rows.total += rows.length;
+		}
+		if (!options.quiet && !options.json) clearLine();
+		await updateLastSynced(db, siteId);
+		report.sites.push(siteReport);
+		report.totalRows += siteReport.rows.total;
+		if (!options.quiet && !options.json) logger.success(`Synced ${siteName} (${siteReport.rows.total.toLocaleString()} rows)`);
+	}
+	if (!options.quiet && !options.json) {
+		console.log();
+		logger.success(`Database saved to ${resolvedPath}`);
+	}
+	return report;
+}
+const syncCommand = defineCommand({
+	meta: {
+		name: "sync",
+		description: "Sync GSC data to SQLite database"
+	},
+	args: {
+		db: {
+			type: "string",
+			alias: "d",
+			default: "./gscdump.db",
+			description: "SQLite database path"
+		},
+		site: {
+			type: "string",
+			alias: "s",
+			description: "Site URL (e.g., sc-domain:example.com)"
+		},
+		period: {
+			type: "string",
+			alias: "p",
+			default: "90d",
+			description: "Time period: 90d, 6m, 1y, max (all GSC history ~16mo)"
+		},
+		granular: {
+			type: "boolean",
+			alias: "g",
+			default: false,
+			description: "Include keyword-per-page data (large dataset)"
+		},
+		quiet: {
+			type: "boolean",
+			alias: "q",
+			default: false,
+			description: "Suppress output"
+		},
+		json: {
+			type: "boolean",
+			default: false,
+			description: "Output sync report as JSON"
+		},
+		fresh: {
+			type: "boolean",
+			default: false,
+			description: "Include fresh/unfinalized data (last 3 days)"
+		},
+		incremental: {
+			type: "boolean",
+			alias: "i",
+			default: false,
+			description: "Only fetch data since last sync"
+		},
+		since: {
+			type: "string",
+			description: "Fetch data from specific date (YYYY-MM-DD)"
+		}
+	},
+	async run({ args }) {
+		const config = await loadConfig();
+		const dbPath = args.db === "./gscdump.db" && config.defaultDb ? config.defaultDb : args.db;
+		const siteArg = args.site || config.defaultSite || null;
+		const periodArg = args.period === "90d" && config.defaultPeriod ? config.defaultPeriod : args.period;
+		const { getAuth: getAuth$1 } = await Promise.resolve().then(() => auth_exports);
+		const report = await runSync(googleSearchConsole(await getAuth$1({
+			interactive: false,
+			config
+		})), dbPath, siteArg, periodArg, args.granular, {
+			quiet: args.quiet,
+			json: args.json,
+			fresh: args.fresh,
+			incremental: args.incremental,
+			since: args.since
+		}).catch(gscErrorHandler);
+		if (args.json) console.log(JSON.stringify(report, null, 2));
+		else if (!args.quiet) logger.success("Done!");
+	}
+});
+
+//#endregion
+//#region src/index.ts
+runMain(defineCommand({
+	meta: {
+		name: "gscdump",
+		version: VERSION,
+		description: "Google Search Console Data Extractor"
+	},
+	subCommands: {
+		init: initCommand,
+		dump: dumpCommand,
+		sync: syncCommand,
+		compare: compareCommand,
+		analyze: analyzeCommand,
+		sites: sitesCommand,
+		sitemaps: sitemapsCommand,
+		index: indexingCommand,
+		inspect: inspectCommand,
+		auth: authCommand,
+		config: configCommand,
+		mcp: mcpCommand
+	},
+	setup() {
+		if (!process.argv.includes("mcp")) showSplash();
+	},
+	async run({ args }) {
+		if (!args._.length) await dumpCommand.run({
+			args,
+			rawArgs: [],
+			cmd: dumpCommand
+		});
+	}
+}));
+
+//#endregion
+export { getAuth as a, loadTokens as c, clearTokens as i, saveCloudTokens as l, authenticateCloud as n, getAuthCredentials as o, clearCloudTokens as r, loadCloudTokens as s, authenticate as t, saveTokens as u };