@gscdump/cli 0.3.1 → 0.4.0

package/dist/index.mjs

@@ -1,58 +1,19 @@
 #!/usr/bin/env node
-import "node:module";
-import process from "node:process";
+import process$1 from "node:process";
 import { defineCommand, runMain } from "citty";
+import { cancel, confirm, isCancel, multiselect, select, text } from "@clack/prompts";
 import fs from "node:fs/promises";
 import { createServer } from "node:http";
 import path from "node:path";
-import { cancel, isCancel, multiselect, select, text } from "@clack/prompts";
 import { OAuth2Client } from "google-auth-library";
-import os from "node:os";
 import { consola } from "consola";
 import { batchInspectUrls, batchRequestIndexing, deleteSitemap, fetchSitemap, fetchSitemaps, fetchSites, fetchSitesWithSitemaps, formatErrorForCli, getIndexingMetadata, googleSearchConsole, inspectUrl, requestIndexing, submitSitemap } from "gscdump";
+import os from "node:os";
 import { between, country, date, device, gsc, page, query, searchAppearance } from "gscdump/query";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
 
-//#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");
@@ -64,7 +25,7 @@ function handleGscError(error) {
 	console.error();
 	console.error(formatErrorForCli(error));
 	console.error();
-	process.exit(1);
+	process$1.exit(1);
 }
 /**
 * Creates a .catch() handler for GSC API errors.
@@ -98,7 +59,7 @@ function progressBar(current, total, label, width = 30) {
 	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");
+	process$1.stdout.write("\r\x1B[K");
 }
 function toCSV(data, columns) {
 	return [columns.join(","), ...data.map((row) => columns.map((col) => {
@@ -141,20 +102,103 @@ function exportToCSV(output) {
 	return sections.join("\n\n");
 }
 
+//#endregion
+//#region src/cloud.ts
+async function cloudFetch(url, options) {
+	const res = await fetch(url, options);
+	if (res.status === 401) {
+		logger.error("CLI session expired or revoked. Run gscdump init --force to re-authenticate.");
+		process$1.exit(1);
+	}
+	if (!res.ok) {
+		const body = await res.json().catch(() => ({ message: res.statusText }));
+		throw new Error(body.message || `HTTP ${res.status}: ${res.statusText}`);
+	}
+	return res.json();
+}
+function buildUrl(base, path$1, query$1) {
+	const url = new URL(path$1, base);
+	if (query$1) {
+		for (const [k, v] of Object.entries(query$1)) if (v !== void 0 && v !== "") url.searchParams.set(k, v);
+	}
+	return url.toString();
+}
+function createCloudClient(cloudUrl, sessionId) {
+	const headers = {
+		"x-cli-session": sessionId,
+		"content-type": "application/json"
+	};
+	return {
+		me: () => cloudFetch(buildUrl(cloudUrl, "/api/cli/me"), { headers }),
+		availableSites: () => cloudFetch(buildUrl(cloudUrl, "/api/cli/sites/available"), { headers }),
+		registerSite: (siteUrl) => cloudFetch(buildUrl(cloudUrl, "/api/sites/register"), {
+			method: "POST",
+			headers,
+			body: JSON.stringify({ siteUrl })
+		}),
+		syncStatus: (siteId) => cloudFetch(buildUrl(cloudUrl, `/api/sites/${siteId}/sync-status`), { headers }),
+		data: (siteId, params) => cloudFetch(buildUrl(cloudUrl, `/api/sites/${siteId}/data`, params), { headers }),
+		sitemaps: (siteId) => cloudFetch(buildUrl(cloudUrl, `/api/sites/${siteId}/sitemaps`), { headers }),
+		analysis: (siteId, tool, params) => cloudFetch(buildUrl(cloudUrl, `/api/sites/${siteId}/analysis/${tool}`, params), { headers }),
+		query: (siteId, params) => cloudFetch(buildUrl(cloudUrl, `/api/sites/${siteId}/query`, params), { headers }),
+		indexing: (siteId, params) => cloudFetch(buildUrl(cloudUrl, `/api/sites/${siteId}/indexing`, params), { headers }),
+		indexingDiagnostics: (siteId) => cloudFetch(buildUrl(cloudUrl, `/api/sites/${siteId}/indexing/diagnostics`), { headers }),
+		indexingUrls: (siteId, params) => cloudFetch(buildUrl(cloudUrl, `/api/sites/${siteId}/indexing/urls`, params), { headers }),
+		indexPercent: (siteId, params) => cloudFetch(buildUrl(cloudUrl, `/api/sites/${siteId}/index-percent`, params), { headers }),
+		sitemapAction: (siteId, body) => cloudFetch(buildUrl(cloudUrl, `/api/sites/${siteId}/sitemaps`), {
+			method: "POST",
+			headers,
+			body: JSON.stringify(body)
+		}),
+		triggerSync: (siteId) => cloudFetch(buildUrl(cloudUrl, `/api/sites/${siteId}/sync`), {
+			method: "POST",
+			headers
+		}),
+		deleteSite: (siteId) => cloudFetch(buildUrl(cloudUrl, `/api/sites/${siteId}`), {
+			method: "DELETE",
+			headers
+		}),
+		bulkRegister: (siteUrls) => cloudFetch(buildUrl(cloudUrl, "/api/sites/bulk-register"), {
+			method: "POST",
+			headers,
+			body: JSON.stringify({ siteUrls })
+		}),
+		analysisPost: (siteId, body) => cloudFetch(buildUrl(cloudUrl, `/api/cli/sites/${siteId}/analysis`), {
+			method: "POST",
+			headers,
+			body: JSON.stringify(body)
+		}),
+		detail: (siteId, body) => cloudFetch(buildUrl(cloudUrl, `/api/cli/sites/${siteId}/detail`), {
+			method: "POST",
+			headers,
+			body: JSON.stringify(body)
+		})
+	};
+}
+
+//#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/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");
 }
@@ -173,8 +217,8 @@ async function clearTokens() {
 	logger.success("Logged out, tokens cleared");
 }
 async function getAuthCredentials(interactive) {
-	const envClientId = process.env.GOOGLE_CLIENT_ID;
-	const envClientSecret = process.env.GOOGLE_CLIENT_SECRET;
+	const envClientId = process$1.env.GOOGLE_CLIENT_ID;
+	const envClientSecret = process$1.env.GOOGLE_CLIENT_SECRET;
 	if (envClientId && envClientSecret) {
 		logger.success("Using OAuth2 credentials from environment");
 		return {
@@ -189,7 +233,7 @@ async function getAuthCredentials(interactive) {
 	};
 	if (!interactive) {
 		logger.error("GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRET required for non-interactive mode");
-		process.exit(1);
+		process$1.exit(1);
 	}
 	console.log();
 	console.log("  \x1B[1mOAuth 2.0 Setup Required\x1B[0m");
@@ -206,12 +250,12 @@ async function getAuthCredentials(interactive) {
 		placeholder: "your-client-id.googleusercontent.com",
 		validate: (v) => v ? void 0 : "Required"
 	});
-	if (isCancel(clientIdResult)) process.exit(1);
+	if (isCancel(clientIdResult)) process$1.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);
+	if (isCancel(clientSecretResult)) process$1.exit(1);
 	console.log();
 	logger.info("Tip: Set GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRET env vars to skip prompts");
 	return {
@@ -272,8 +316,8 @@ async function getAuthCodeViaLoopback(authUrl) {
 }
 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;
+	const envAccessToken = process$1.env.GOOGLE_ACCESS_TOKEN;
+	const envRefreshToken = process$1.env.GOOGLE_REFRESH_TOKEN;
 	if (envAccessToken || envRefreshToken) {
 		oauth2Client.setCredentials({
 			access_token: envAccessToken,
@@ -303,7 +347,7 @@ async function authenticate(credentials, interactive) {
 	}
 	if (!interactive) {
 		logger.error("No saved tokens. Run interactively first to authenticate.");
-		process.exit(1);
+		process$1.exit(1);
 	}
 	const authUrl = oauth2Client.generateAuthUrl({
 		access_type: "offline",
@@ -349,11 +393,11 @@ async function authenticateCloud(cloudUrl, interactive) {
 	}
 	if (!interactive) {
 		logger.error("No cloud tokens. Run gscdump init to authenticate.");
-		process.exit(1);
+		process$1.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);
+		process$1.exit(1);
 	});
 	console.log();
 	console.log("  \x1B[1mOpen this URL in your browser:\x1B[0m");
@@ -368,8 +412,13 @@ async function authenticateCloud(cloudUrl, interactive) {
 		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");
+			await saveCloudTokens({
+				...pollRes.tokens,
+				sessionId: pollRes.sessionId,
+				user: pollRes.user
+			});
+			if (pollRes.user?.email) logger.success(`Authenticated as ${pollRes.user.email}`);
+			else logger.success("Authenticated via cloud.gscdump.com");
 			const oauth2Client = new OAuth2Client();
 			oauth2Client.setCredentials({
 				access_token: pollRes.tokens.accessToken,
@@ -380,11 +429,11 @@ async function authenticateCloud(cloudUrl, interactive) {
 		}
 		if (pollRes.status === "error") {
 			logger.error("Authorization failed");
-			process.exit(1);
+			process$1.exit(1);
 		}
 	}
 	logger.error("Authorization timed out");
-	process.exit(1);
+	process$1.exit(1);
 }
 async function getAuth(opts = {}) {
 	const { interactive = true, config: providedConfig } = opts;
@@ -392,19 +441,269 @@ async function getAuth(opts = {}) {
 	if (!config.mode) {
 		if (!interactive) {
 			logger.error("Not configured. Run gscdump init first.");
-			process.exit(1);
+			process$1.exit(1);
 		}
 		logger.warn("GSCDump not configured");
 		logger.info("Run: gscdump init");
-		process.exit(1);
+		process$1.exit(1);
 	}
 	if (config.mode === "cloud") return authenticateCloud(config.cloudUrl || DEFAULT_CLOUD_URL, interactive);
 	return authenticate(await getAuthCredentials(interactive), interactive);
 }
+async function getCloudClient() {
+	const config = await loadConfig();
+	if (config.mode !== "cloud") return null;
+	const tokens = await loadCloudTokens();
+	if (!tokens?.sessionId) return null;
+	return createCloudClient(config.cloudUrl || DEFAULT_CLOUD_URL, tokens.sessionId);
+}
+
+//#endregion
+//#region src/commands/analysis.ts
+const ANALYSIS_TOOLS = [
+	"striking-distance",
+	"opportunity",
+	"movers",
+	"decay",
+	"zero-click",
+	"brand",
+	"cannibalization",
+	"clustering",
+	"concentration",
+	"seasonality"
+];
+async function resolveSiteId(cloud, siteUrl) {
+	const config = await loadConfig();
+	const target = siteUrl || config.defaultSite;
+	const me = await cloud.me().catch((e) => {
+		logger.error(`Failed to fetch profile: ${e.message}`);
+		process$1.exit(1);
+	});
+	if (me.sites.length === 0) {
+		logger.error("No registered sites. Run gscdump register first.");
+		process$1.exit(1);
+	}
+	const match = target ? me.sites.find((s) => s.siteUrl === target || s.siteUrl.includes(target)) : void 0;
+	if (match) return match.siteId;
+	if (me.sites.length === 1) return me.sites[0].siteId;
+	const selected = await select({
+		message: "Select a site",
+		options: me.sites.map((s) => ({
+			value: s.siteId,
+			label: s.siteUrl
+		}))
+	});
+	if (isCancel(selected)) {
+		cancel("Cancelled");
+		process$1.exit(0);
+	}
+	return selected;
+}
+function extractResults(data) {
+	if (Array.isArray(data.results)) return {
+		results: data.results,
+		total: data.meta?.total ?? data.results.length
+	};
+	if (Array.isArray(data.keywords)) return {
+		results: data.keywords,
+		total: data.totalCount ?? data.keywords.length
+	};
+	if (Array.isArray(data.clusters)) {
+		const clusters = data.clusters;
+		return {
+			results: clusters,
+			total: data.meta?.totalClusters ?? clusters.length
+		};
+	}
+	if (Array.isArray(data.rising)) {
+		const rows = [...data.rising.map((r) => ({
+			...r,
+			direction: "rising"
+		})), ...(data.declining || []).map((r) => ({
+			...r,
+			direction: "declining"
+		}))];
+		return {
+			results: rows,
+			total: rows.length
+		};
+	}
+	if (Array.isArray(data.brand)) {
+		const rows = [...data.brand.map((r) => ({
+			...r,
+			segment: "brand"
+		})), ...(data.nonBrand || []).map((r) => ({
+			...r,
+			segment: "non-brand"
+		}))];
+		return {
+			results: rows,
+			total: rows.length
+		};
+	}
+	if (Array.isArray(data.monthlyBreakdown)) return {
+		results: data.monthlyBreakdown,
+		total: data.monthlyBreakdown.length
+	};
+	if (data.giniCoefficient !== void 0) {
+		const { meta: _m, ...rest } = data;
+		return {
+			results: [rest],
+			total: 1
+		};
+	}
+	return {
+		results: [],
+		total: 0
+	};
+}
+const TOOL_EXTRA_ARGS = {
+	"brand": { "brand-terms": {
+		type: "string",
+		description: "Comma-separated brand terms (required)"
+	} },
+	"movers": {
+		"prev-start": {
+			type: "string",
+			description: "Previous period start date (required)"
+		},
+		"prev-end": {
+			type: "string",
+			description: "Previous period end date (required)"
+		}
+	},
+	"decay": {
+		"prev-start": {
+			type: "string",
+			description: "Previous period start date (required)"
+		},
+		"prev-end": {
+			type: "string",
+			description: "Previous period end date (required)"
+		}
+	},
+	"concentration": { dimension: {
+		type: "string",
+		description: "Dimension: pages or keywords (default: pages)"
+	} },
+	"seasonality": { metric: {
+		type: "string",
+		description: "Metric: clicks or impressions (default: clicks)"
+	} },
+	"clustering": { "cluster-by": {
+		type: "string",
+		description: "Cluster by: prefix, intent, or both (default: both)"
+	} }
+};
+function buildBody(tool, args) {
+	const body = {
+		type: tool,
+		startDate: args.start ? String(args.start) : void 0,
+		endDate: args.end ? String(args.end) : void 0,
+		limit: args.limit ? Number(args.limit) : void 0
+	};
+	if (args["brand-terms"]) body.brandTerms = String(args["brand-terms"]).split(",").map((t) => t.trim()).filter(Boolean);
+	if (args["prev-start"]) body.prevStartDate = String(args["prev-start"]);
+	if (args["prev-end"]) body.prevEndDate = String(args["prev-end"]);
+	if (args.dimension) body.dimension = String(args.dimension);
+	if (args.metric) body.metric = String(args.metric);
+	if (args["cluster-by"]) body.clusterBy = String(args["cluster-by"]);
+	return body;
+}
+function makeToolCommand(tool) {
+	const extraArgs = TOOL_EXTRA_ARGS[tool] || {};
+	return defineCommand({
+		meta: {
+			name: tool,
+			description: `Run ${tool} analysis`
+		},
+		args: {
+			site: {
+				type: "string",
+				alias: "s",
+				description: "Site URL"
+			},
+			start: {
+				type: "string",
+				description: "Start date (YYYY-MM-DD)"
+			},
+			end: {
+				type: "string",
+				description: "End date (YYYY-MM-DD)"
+			},
+			limit: {
+				type: "string",
+				alias: "l",
+				default: "100",
+				description: "Max results"
+			},
+			format: {
+				type: "string",
+				alias: "f",
+				default: "table",
+				description: "Output: table, json, csv"
+			},
+			json: {
+				type: "boolean",
+				default: false,
+				description: "Output as JSON"
+			},
+			...extraArgs
+		},
+		async run({ args }) {
+			const cloud = await getCloudClient();
+			if (!cloud) {
+				logger.error("Analysis requires cloud mode. Run gscdump init to set up cloud mode.");
+				process$1.exit(1);
+			}
+			const siteId = await resolveSiteId(cloud, args.site);
+			logger.info(`Running ${tool} analysis...`);
+			const body = buildBody(tool, args);
+			const data = await cloud.analysisPost(siteId, body).catch((e) => {
+				logger.error(`Analysis failed: ${e.message}`);
+				process$1.exit(1);
+			});
+			const format = args.json ? "json" : String(args.format);
+			if (format === "json") {
+				console.log(JSON.stringify(data, null, 2));
+				return;
+			}
+			const { results, total } = extractResults(data);
+			if (format === "csv" && results.length > 0) {
+				const cols$1 = Object.keys(results[0]);
+				console.log(toCSV(results, cols$1));
+				return;
+			}
+			if (results.length === 0) {
+				logger.warn("No results found");
+				return;
+			}
+			const cols = Object.keys(results[0]);
+			const widths = cols.map((c) => Math.max(c.length, ...results.map((r) => String(r[c] ?? "").length).slice(0, 20)));
+			console.log();
+			console.log(`  ${cols.map((c, i) => c.padEnd(widths[i])).join("  ")}`);
+			console.log(`  ${cols.map((_, i) => "─".repeat(widths[i])).join("  ")}`);
+			for (const row of results) console.log(`  ${cols.map((c, i) => {
+				const val = row[c];
+				return (typeof val === "number" ? Number.isInteger(val) ? String(val) : val.toFixed(2) : String(val ?? "")).padEnd(widths[i]);
+			}).join("  ")}`);
+			console.log();
+			logger.success(`${results.length} results`);
+			if (total > results.length) logger.info(`Total: ${total} (showing ${results.length})`);
+		}
+	});
+}
+const analysisCommand = defineCommand({
+	meta: {
+		name: "analysis",
+		description: "SEO analysis tools (cloud mode only)"
+	},
+	subCommands: Object.fromEntries(ANALYSIS_TOOLS.map((tool) => [tool, makeToolCommand(tool)]))
+});
 
 //#endregion
 //#region src/commands/auth.ts
-const statusCommand = defineCommand({
+const statusCommand$2 = defineCommand({
 	meta: {
 		name: "status",
 		description: "Show current authentication status"
@@ -425,12 +724,16 @@ const statusCommand = defineCommand({
 				logger.info("Run gscdump init --force to re-authenticate");
 				return;
 			}
+			const hasSession = !!tokens.sessionId;
 			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();
+			if (tokens.user?.email) console.log(`  User:          \x1B[36m${tokens.user.email}\x1B[0m`);
+			if (tokens.user?.publicId) console.log(`  User ID:       \x1B[90m${tokens.user.publicId}\x1B[0m`);
+			console.log(`  Session:       ${hasSession ? "\x1B[32mactive\x1B[0m" : "\x1B[31mmissing\x1B[0m"}`);
 			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) {
@@ -475,7 +778,7 @@ const authCommand = defineCommand({
 		description: "Manage authentication"
 	},
 	subCommands: {
-		status: statusCommand,
+		status: statusCommand$2,
 		logout: logoutCommand
 	}
 });
@@ -526,7 +829,7 @@ const setCommand = defineCommand({
 		if (!validKeys.includes(args.key)) {
 			logger.error(`Invalid key: ${args.key}`);
 			logger.info(`Valid keys: ${validKeys.join(", ")}`);
-			process.exit(1);
+			process$1.exit(1);
 		}
 		const config = await loadConfig();
 		config[args.key] = args.value;
@@ -589,6 +892,44 @@ function getDimensions(dataType) {
 		case "devices": return [device, date];
 	}
 }
+function getDimensionNames(dataType) {
+	switch (dataType) {
+		case "pages": return "page,date";
+		case "keywords": return "query,date";
+		case "countries": return "country,date";
+		case "devices": return "device,date";
+	}
+}
+async function resolveCloudSite$3(cloud, target) {
+	const me = await cloud.me().catch((e) => {
+		logger.error(`Failed to fetch sites: ${e.message}`);
+		process$1.exit(1);
+	});
+	if (me.sites.length === 0) {
+		logger.error("No registered sites. Run gscdump register first.");
+		process$1.exit(1);
+	}
+	let site = target ? me.sites.find((s) => s.siteUrl === target || s.siteUrl.includes(target)) : void 0;
+	if (!site) if (me.sites.length === 1) site = me.sites[0];
+	else {
+		const selected = await select({
+			message: "Select a site",
+			options: me.sites.map((s) => ({
+				value: s.siteId,
+				label: s.siteUrl
+			}))
+		});
+		if (isCancel(selected)) {
+			cancel("Cancelled");
+			process$1.exit(0);
+		}
+		site = me.sites.find((s) => s.siteId === selected);
+	}
+	return {
+		siteId: site.siteId,
+		siteUrl: site.siteUrl
+	};
+}
 const dumpCommand = defineCommand({
 	meta: {
 		name: "dump",
@@ -651,32 +992,6 @@ const dumpCommand = defineCommand({
 	},
 	async run({ args }) {
 		const config = await loadConfig();
-		const { getAuth: getAuth$1 } = await Promise.resolve().then(() => auth_exports);
-		const client = googleSearchConsole(await getAuth$1({
-			interactive: false,
-			config
-		}));
-		let siteUrl = String(args.site || config.defaultSite || "");
-		if (!siteUrl || args.interactive) {
-			const verified = (await client.sites()).filter((s) => s.permissionLevel !== "siteUnverifiedUser");
-			if (verified.length === 0) {
-				logger.error("No verified sites found");
-				process.exit(1);
-			}
-			const selected = await select({
-				message: "Select a site",
-				options: verified.map((s) => ({
-					value: s.siteUrl,
-					label: s.siteUrl
-				})),
-				initialValue: siteUrl || verified[0]?.siteUrl
-			});
-			if (isCancel(selected)) {
-				cancel("Cancelled");
-				process.exit(0);
-			}
-			siteUrl = selected;
-		}
 		let startDate;
 		let endDate;
 		if (args.start && args.end) {
@@ -689,7 +1004,7 @@ const dumpCommand = defineCommand({
 			});
 			if (isCancel(startInput)) {
 				cancel("Cancelled");
-				process.exit(0);
+				process$1.exit(0);
 			}
 			const endInput = await text({
 				message: "End date (YYYY-MM-DD)",
@@ -697,7 +1012,7 @@ const dumpCommand = defineCommand({
 			});
 			if (isCancel(endInput)) {
 				cancel("Cancelled");
-				process.exit(0);
+				process$1.exit(0);
 			}
 			startDate = String(startInput) || (/* @__PURE__ */ new Date(Date.now() - Number(args.days) * 864e5)).toISOString().split("T")[0];
 			endDate = String(endInput) || (/* @__PURE__ */ new Date(Date.now() - 3 * 864e5)).toISOString().split("T")[0];
@@ -719,12 +1034,82 @@ const dumpCommand = defineCommand({
 			});
 			if (isCancel(selected)) {
 				cancel("Cancelled");
-				process.exit(0);
+				process$1.exit(0);
 			}
 			dataTypes = selected;
 		} else dataTypes = ["pages", "keywords"];
 		const rowLimit = Number.parseInt(String(args.limit), 10);
 		const format = String(args.format);
+		const cloud = await getCloudClient();
+		if (cloud) {
+			const { siteId, siteUrl: siteUrl$1 } = await resolveCloudSite$3(cloud, args.site || config.defaultSite);
+			const output$1 = {
+				siteUrl: siteUrl$1,
+				dateRange: {
+					start: startDate,
+					end: endDate
+				},
+				exportedAt: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			const totalSteps$1 = dataTypes.length;
+			let currentStep$1 = 0;
+			for (const dataType of dataTypes) {
+				currentStep$1++;
+				if (!args.quiet) {
+					clearLine();
+					process$1.stdout.write(progressBar(currentStep$1, totalSteps$1, dataType));
+				}
+				const dimensions = getDimensionNames(dataType);
+				const result = await cloud.query(siteId, {
+					startDate,
+					endDate,
+					dimensions,
+					rowLimit: String(rowLimit)
+				}).catch((e) => {
+					logger.error(`Query failed: ${e.message}`);
+					process$1.exit(1);
+				});
+				output$1[dataType] = {
+					total: result.rows.length,
+					data: result.rows
+				};
+			}
+			if (!args.quiet) {
+				clearLine();
+				logger.success(`Exported ${dataTypes.join(", ")} for ${siteUrl$1}`);
+			}
+			const content$1 = format === "csv" ? exportToCSV(output$1) : JSON.stringify(output$1, null, 2);
+			if (args.output) {
+				await fs.writeFile(String(args.output), content$1);
+				if (!args.quiet) logger.info(`Written to ${args.output}`);
+			} else console.log(content$1);
+			return;
+		}
+		const client = googleSearchConsole(await getAuth({
+			interactive: false,
+			config
+		}));
+		let siteUrl = String(args.site || config.defaultSite || "");
+		if (!siteUrl || args.interactive) {
+			const verified = (await client.sites()).filter((s) => s.permissionLevel !== "siteUnverifiedUser");
+			if (verified.length === 0) {
+				logger.error("No verified sites found");
+				process$1.exit(1);
+			}
+			const selected = await select({
+				message: "Select a site",
+				options: verified.map((s) => ({
+					value: s.siteUrl,
+					label: s.siteUrl
+				})),
+				initialValue: siteUrl || verified[0]?.siteUrl
+			});
+			if (isCancel(selected)) {
+				cancel("Cancelled");
+				process$1.exit(0);
+			}
+			siteUrl = selected;
+		}
 		const output = {
 			siteUrl,
 			dateRange: {
@@ -739,7 +1124,7 @@ const dumpCommand = defineCommand({
 			currentStep++;
 			if (!args.quiet) {
 				clearLine();
-				process.stdout.write(progressBar(currentStep, totalSteps, dataType));
+				process$1.stdout.write(progressBar(currentStep, totalSteps, dataType));
 			}
 			const dimensions = getDimensions(dataType);
 			const builder = gsc.select(...dimensions).where(between(date, startDate, endDate)).limit(rowLimit);
@@ -750,22 +1135,383 @@ const dumpCommand = defineCommand({
 				data: rows
 			};
 		}
-		if (!args.quiet) {
-			clearLine();
-			logger.success(`Exported ${dataTypes.join(", ")} for ${siteUrl}`);
+		if (!args.quiet) {
+			clearLine();
+			logger.success(`Exported ${dataTypes.join(", ")} for ${siteUrl}`);
+		}
+		const content = format === "csv" ? exportToCSV(output) : JSON.stringify(output, null, 2);
+		if (args.output) {
+			await fs.writeFile(String(args.output), content);
+			if (!args.quiet) logger.info(`Written to ${args.output}`);
+		} else console.log(content);
+	}
+});
+
+//#endregion
+//#region src/commands/indexing.ts
+async function resolveCloudSite$2(cloud, target) {
+	const me = await cloud.me().catch((e) => {
+		logger.error(`Failed to fetch sites: ${e.message}`);
+		process$1.exit(1);
+	});
+	if (me.sites.length === 0) {
+		logger.error("No registered sites. Run gscdump register first.");
+		process$1.exit(1);
+	}
+	let site = target ? me.sites.find((s) => s.siteUrl === target || s.siteUrl.includes(target)) : void 0;
+	if (!site) if (me.sites.length === 1) site = me.sites[0];
+	else {
+		const selected = await select({
+			message: "Select a site",
+			options: me.sites.map((s) => ({
+				value: s.siteId,
+				label: s.siteUrl
+			}))
+		});
+		if (isCancel(selected)) {
+			cancel("Cancelled");
+			process$1.exit(0);
+		}
+		site = me.sites.find((s) => s.siteId === selected);
+	}
+	return {
+		siteId: site.siteId,
+		siteUrl: site.siteUrl
+	};
+}
+const statusCommand$1 = defineCommand({
+	meta: {
+		name: "status",
+		description: "Show indexing status overview (cloud mode)"
+	},
+	args: {
+		site: {
+			type: "string",
+			alias: "s",
+			description: "Site URL"
+		},
+		days: {
+			type: "string",
+			alias: "d",
+			default: "28",
+			description: "Days of trend data (max 90)"
+		},
+		json: {
+			type: "boolean",
+			default: false,
+			description: "Output as JSON"
+		}
+	},
+	async run({ args }) {
+		const cloud = await getCloudClient();
+		if (!cloud) {
+			logger.error("Indexing status requires cloud mode. Run gscdump init to set up.");
+			process$1.exit(1);
+		}
+		const config = await loadConfig();
+		const { siteId, siteUrl } = await resolveCloudSite$2(cloud, args.site || config.defaultSite);
+		const data = await cloud.indexing(siteId, { days: String(args.days) }).catch((e) => {
+			logger.error(`Failed to fetch indexing data: ${e.message}`);
+			process$1.exit(1);
+		});
+		if (args.json) {
+			console.log(JSON.stringify(data, null, 2));
+			return;
+		}
+		const s = data.summary;
+		console.log();
+		console.log(`  \x1B[1m${siteUrl}\x1B[0m — Indexing Status`);
+		console.log();
+		console.log(`  Total URLs:     \x1B[36m${s.totalUrls.toLocaleString()}\x1B[0m`);
+		console.log(`  Indexed:        \x1B[32m${s.indexed.toLocaleString()}\x1B[0m (${s.indexedPercent}%)`);
+		console.log(`  Not Indexed:    \x1B[31m${s.notIndexed.toLocaleString()}\x1B[0m`);
+		if (s.pending > 0) console.log(`  Pending:        \x1B[33m${s.pending.toLocaleString()}\x1B[0m`);
+		if (s.change7d !== null || s.change28d !== null) {
+			console.log();
+			if (s.change7d !== null) {
+				const color = s.change7d > 0 ? "\x1B[32m+" : s.change7d < 0 ? "\x1B[31m" : "\x1B[90m";
+				console.log(`  7d change:      ${color}${s.change7d}%\x1B[0m`);
+			}
+			if (s.change28d !== null) {
+				const color = s.change28d > 0 ? "\x1B[32m+" : s.change28d < 0 ? "\x1B[31m" : "\x1B[90m";
+				console.log(`  28d change:     ${color}${s.change28d}%\x1B[0m`);
+			}
+		}
+		if (data.trend.length > 1) {
+			console.log();
+			console.log("  \x1B[1mTrend (indexed %)\x1B[0m");
+			const recent = data.trend.slice(-14);
+			for (const t of recent) {
+				const bar = "█".repeat(Math.round(t.indexedPercent / 5));
+				console.log(`  ${t.date}  \x1B[36m${bar}\x1B[0m ${t.indexedPercent}%`);
+			}
+		}
+		console.log();
+	}
+});
+const diagnosticsCommand = defineCommand({
+	meta: {
+		name: "diagnostics",
+		description: "Show indexing issue diagnostics (cloud mode)"
+	},
+	args: {
+		site: {
+			type: "string",
+			alias: "s",
+			description: "Site URL"
+		},
+		json: {
+			type: "boolean",
+			default: false,
+			description: "Output as JSON"
+		}
+	},
+	async run({ args }) {
+		const cloud = await getCloudClient();
+		if (!cloud) {
+			logger.error("Indexing diagnostics requires cloud mode. Run gscdump init to set up.");
+			process$1.exit(1);
+		}
+		const config = await loadConfig();
+		const { siteId, siteUrl } = await resolveCloudSite$2(cloud, args.site || config.defaultSite);
+		const data = await cloud.indexingDiagnostics(siteId).catch((e) => {
+			logger.error(`Failed to fetch diagnostics: ${e.message}`);
+			process$1.exit(1);
+		});
+		if (args.json) {
+			console.log(JSON.stringify(data, null, 2));
+			return;
+		}
+		console.log();
+		console.log(`  \x1B[1m${siteUrl}\x1B[0m — Indexing Diagnostics`);
+		console.log();
+		console.log(`  Total: \x1B[36m${data.summary.totalUrls.toLocaleString()}\x1B[0m URLs, \x1B[32m${data.summary.indexed.toLocaleString()}\x1B[0m indexed (${data.summary.indexedPercent}%)`);
+		console.log();
+		if (data.issues.length === 0) {
+			logger.success("No indexing issues found!");
+			return;
+		}
+		console.log("  \x1B[1mIssues\x1B[0m");
+		for (const issue of data.issues) {
+			const color = issue.severity === "error" ? "\x1B[31m" : issue.severity === "warning" ? "\x1B[33m" : "\x1B[90m";
+			console.log(`  ${color}${issue.severity.toUpperCase().padEnd(7)}\x1B[0m ${issue.label} — \x1B[36m${issue.count.toLocaleString()}\x1B[0m URLs`);
+		}
+		console.log();
+	}
+});
+const urlsCommand = defineCommand({
+	meta: {
+		name: "urls",
+		description: "List URLs with indexing status (cloud mode)"
+	},
+	args: {
+		site: {
+			type: "string",
+			alias: "s",
+			description: "Site URL"
+		},
+		status: {
+			type: "string",
+			description: "Filter: indexed, not_indexed, pending"
+		},
+		issue: {
+			type: "string",
+			description: "Filter by issue type"
+		},
+		search: {
+			type: "string",
+			description: "Search URLs"
+		},
+		limit: {
+			type: "string",
+			alias: "l",
+			default: "50",
+			description: "Max results"
+		},
+		offset: {
+			type: "string",
+			default: "0",
+			description: "Offset for pagination"
+		},
+		json: {
+			type: "boolean",
+			default: false,
+			description: "Output as JSON"
+		}
+	},
+	async run({ args }) {
+		const cloud = await getCloudClient();
+		if (!cloud) {
+			logger.error("Indexing URLs requires cloud mode. Run gscdump init to set up.");
+			process$1.exit(1);
+		}
+		const config = await loadConfig();
+		const { siteId, siteUrl } = await resolveCloudSite$2(cloud, args.site || config.defaultSite);
+		const params = {
+			limit: String(args.limit),
+			offset: String(args.offset)
+		};
+		if (args.status) params.status = String(args.status);
+		if (args.issue) params.issue = String(args.issue);
+		if (args.search) params.search = String(args.search);
+		const data = await cloud.indexingUrls(siteId, params).catch((e) => {
+			logger.error(`Failed to fetch URLs: ${e.message}`);
+			process$1.exit(1);
+		});
+		if (args.json) {
+			console.log(JSON.stringify(data, null, 2));
+			return;
+		}
+		console.log();
+		console.log(`  \x1B[1m${siteUrl}\x1B[0m — ${data.pagination.total.toLocaleString()} URLs (showing ${data.urls.length})`);
+		console.log();
+		for (const url of data.urls) {
+			const verdictColor = url.verdict === "PASS" ? "\x1B[32m" : url.verdict ? "\x1B[31m" : "\x1B[33m";
+			const verdictLabel = url.verdict === "PASS" ? "INDEXED" : url.verdict ? "NOT INDEXED" : "PENDING";
+			console.log(`  ${verdictColor}${verdictLabel.padEnd(12)}\x1B[0m ${url.url}`);
+			if (url.coverageState && url.coverageState !== "Submitted and indexed") console.log(`               \x1B[90m${url.coverageState}\x1B[0m`);
+		}
+		if (data.pagination.hasMore) console.log(`\n  \x1B[90m... ${data.pagination.total - data.pagination.offset - data.urls.length} more (use --offset ${data.pagination.offset + data.urls.length})\x1B[0m`);
+		console.log();
+	}
+});
+const inspectCommand = defineCommand({
+	meta: {
+		name: "inspect",
+		description: "Inspect a specific URL's indexing status (local mode)"
+	},
+	args: {
+		site: {
+			type: "string",
+			alias: "s",
+			required: true,
+			description: "Site URL (e.g., sc-domain:example.com)"
+		},
+		url: {
+			type: "positional",
+			required: true,
+			description: "URL to inspect"
+		},
+		json: {
+			type: "boolean",
+			default: false,
+			description: "Output as JSON"
+		}
+	},
+	async run({ args }) {
+		const result = await inspectUrl(googleSearchConsole(await getAuth({ interactive: false })), args.site, args.url).catch((e) => {
+			logger.error(`Inspection failed: ${e.message}`);
+			process$1.exit(1);
+		});
+		if (args.json) {
+			console.log(JSON.stringify(result, null, 2));
+			return;
+		}
+		const indexStatus = result.inspectionResult?.indexStatusResult;
+		console.log();
+		console.log(`  \x1B[1mURL:\x1B[0m ${args.url}`);
+		console.log();
+		if (indexStatus) {
+			const verdict = indexStatus.verdict;
+			const verdictColor = verdict === "PASS" ? "\x1B[32m" : "\x1B[31m";
+			console.log(`  Verdict:        ${verdictColor}${verdict}\x1B[0m`);
+			if (indexStatus.coverageState) console.log(`  Coverage:       ${indexStatus.coverageState}`);
+			if (indexStatus.robotsTxtState) console.log(`  Robots.txt:     ${indexStatus.robotsTxtState}`);
+			if (indexStatus.indexingState) console.log(`  Indexing:       ${indexStatus.indexingState}`);
+			if (indexStatus.lastCrawlTime) console.log(`  Last Crawl:     ${indexStatus.lastCrawlTime}`);
+			if (indexStatus.pageFetchState) console.log(`  Page Fetch:     ${indexStatus.pageFetchState}`);
+			if (indexStatus.googleCanonical) console.log(`  Google Canon:   ${indexStatus.googleCanonical}`);
+			if (indexStatus.userCanonical) console.log(`  User Canon:     ${indexStatus.userCanonical}`);
+		} else console.log(JSON.stringify(result, null, 2));
+		console.log();
+	}
+});
+const indexPercentCommand = defineCommand({
+	meta: {
+		name: "index-percent",
+		description: "Show index percent, invisible URLs, and orphan pages (cloud mode)"
+	},
+	args: {
+		site: {
+			type: "string",
+			alias: "s",
+			description: "Site URL"
+		},
+		json: {
+			type: "boolean",
+			default: false,
+			description: "Output as JSON"
+		}
+	},
+	async run({ args }) {
+		const cloud = await getCloudClient();
+		if (!cloud) {
+			logger.error("Index percent requires cloud mode. Run gscdump init to set up.");
+			process$1.exit(1);
+		}
+		const config = await loadConfig();
+		const { siteId, siteUrl } = await resolveCloudSite$2(cloud, args.site || config.defaultSite);
+		const data = await cloud.indexPercent(siteId).catch((e) => {
+			logger.error(`Failed to fetch index percent: ${e.message}`);
+			process$1.exit(1);
+		});
+		if (args.json) {
+			console.log(JSON.stringify(data, null, 2));
+			return;
+		}
+		const s = data.summary;
+		console.log();
+		console.log(`  \x1B[1m${siteUrl}\x1B[0m — Index Percent`);
+		console.log();
+		console.log(`  Index Percent:     \x1B[36m${s.currentPercent}%\x1B[0m`);
+		console.log(`  Sitemap URLs:      ${s.totalSitemapUrls.toLocaleString()}`);
+		console.log(`  Visible in Search: \x1B[32m${s.visibleUrls.toLocaleString()}\x1B[0m`);
+		if (s.change7d !== null) {
+			const color = s.change7d > 0 ? "\x1B[32m+" : s.change7d < 0 ? "\x1B[31m" : "\x1B[90m";
+			console.log(`  7d change:         ${color}${s.change7d.toFixed(1)}%\x1B[0m`);
+		}
+		if (s.change28d !== null) {
+			const color = s.change28d > 0 ? "\x1B[32m+" : s.change28d < 0 ? "\x1B[31m" : "\x1B[90m";
+			console.log(`  28d change:        ${color}${s.change28d.toFixed(1)}%\x1B[0m`);
+		}
+		if (data.invisibleCount > 0) {
+			console.log();
+			console.log(`  \x1B[1mInvisible URLs\x1B[0m (\x1B[33m${data.invisibleCount}\x1B[0m — in sitemap but no search traffic)`);
+			for (const u of data.invisibleUrls.slice(0, 10)) console.log(`    ${u.url}`);
+			if (data.invisibleCount > 10) console.log(`    \x1B[90m... and ${data.invisibleCount - 10} more\x1B[0m`);
+		}
+		if (data.orphanCount > 0) {
+			console.log();
+			console.log(`  \x1B[1mOrphan Pages\x1B[0m (\x1B[33m${data.orphanCount}\x1B[0m — has traffic but not in sitemap)`);
+			for (const u of data.orphanPages.slice(0, 10)) console.log(`    ${u.url} \x1B[90m(${u.clicks} clicks)\x1B[0m`);
+			if (data.orphanCount > 10) console.log(`    \x1B[90m... and ${data.orphanCount - 10} more\x1B[0m`);
+		}
+		if (data.sitemaps.length > 0) {
+			console.log();
+			console.log("  \x1B[1mSitemaps\x1B[0m");
+			for (const sm of data.sitemaps) console.log(`    ${sm.path} \x1B[90m(${sm.urlCount.toLocaleString()} URLs)\x1B[0m`);
 		}
-		const content = format === "csv" ? exportToCSV(output) : JSON.stringify(output, null, 2);
-		if (args.output) {
-			await fs.writeFile(String(args.output), content);
-			if (!args.quiet) logger.info(`Written to ${args.output}`);
-		} else console.log(content);
+		console.log();
+	}
+});
+const indexingCommand = defineCommand({
+	meta: {
+		name: "indexing",
+		description: "Indexing status, diagnostics, and URL inspection"
+	},
+	subCommands: {
+		"status": statusCommand$1,
+		"diagnostics": diagnosticsCommand,
+		"urls": urlsCommand,
+		"inspect": inspectCommand,
+		"index-percent": indexPercentCommand
 	}
 });
 
 //#endregion
 //#region src/commands/init.ts
 async function loadEnvFile() {
-	const envPath = path.join(process.cwd(), ".env");
+	const envPath = path.join(process$1.cwd(), ".env");
 	const content = await fs.readFile(envPath, "utf-8").catch(() => null);
 	if (!content) return null;
 	const env = {};
@@ -802,10 +1548,10 @@ const initCommand = defineCommand({
 		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;
+			process$1.env.GOOGLE_CLIENT_ID = envFile.GOOGLE_CLIENT_ID;
+			process$1.env.GOOGLE_CLIENT_SECRET = envFile.GOOGLE_CLIENT_SECRET;
+			process$1.env.GOOGLE_REFRESH_TOKEN = envFile.GOOGLE_REFRESH_TOKEN;
+			if (envFile.GOOGLE_ACCESS_TOKEN) process$1.env.GOOGLE_ACCESS_TOKEN = envFile.GOOGLE_ACCESS_TOKEN;
 			await saveConfig({
 				...config,
 				mode: "local",
@@ -841,7 +1587,7 @@ const initCommand = defineCommand({
 				hint: "Use your own Google OAuth credentials"
 			}]
 		});
-		if (isCancel(mode)) process.exit(1);
+		if (isCancel(mode)) process$1.exit(1);
 		if (mode === "cloud") {
 			const cloudUrl = config.cloudUrl || DEFAULT_CLOUD_URL;
 			await saveConfig({
@@ -1063,7 +1809,7 @@ const batchInspectUrlsInput = z.object({
 //#endregion
 //#region src/mcp/server/index.ts
 function createGscMcpServer(options) {
-	const { name = "gscdump", version = "1.0.0", getAuth: getAuth$1 } = options;
+	const { name = "gscdump", version = "1.0.0", getAuth: getAuth$1, cloudClient } = options;
 	const server = new McpServer({
 		name,
 		version
@@ -1236,13 +1982,212 @@ function createGscMcpServer(options) {
 			text: JSON.stringify(result, null, 2)
 		}] };
 	});
+	if (cloudClient) {
+		const siteIdSchema = z.object({ siteId: z.string().describe("Site ID from gscdump platform (use cloud-list-sites to find)") });
+		const analysisSchema = z.object({
+			siteId: z.string().describe("Site ID from gscdump platform"),
+			tool: z.enum([
+				"striking-distance",
+				"opportunity",
+				"movers",
+				"decay",
+				"zero-click",
+				"brand",
+				"cannibalization",
+				"clustering",
+				"concentration",
+				"seasonality"
+			]).describe("Analysis tool to run"),
+			startDate: z.string().optional().describe("Start date (YYYY-MM-DD)"),
+			endDate: z.string().optional().describe("End date (YYYY-MM-DD)"),
+			limit: z.number().optional().describe("Max results")
+		});
+		server.registerTool("cloud-list-sites", {
+			description: "List registered sites on gscdump.com with sync status and progress",
+			inputSchema: z.object({}).shape
+		}, async () => {
+			const result = await cloudClient.me();
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(result, null, 2)
+			}] };
+		});
+		server.registerTool("cloud-sync-status", {
+			description: "Get detailed sync status for a site on gscdump.com",
+			inputSchema: siteIdSchema.shape
+		}, async ({ siteId }) => {
+			const result = await cloudClient.syncStatus(siteId);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(result, null, 2)
+			}] };
+		});
+		server.registerTool("cloud-sitemaps", {
+			description: "Get sitemap health data for a site from gscdump.com (includes URL counts, error tracking, history)",
+			inputSchema: siteIdSchema.shape
+		}, async ({ siteId }) => {
+			const result = await cloudClient.sitemaps(siteId);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(result, null, 2)
+			}] };
+		});
+		server.registerTool("cloud-analysis", {
+			description: "Run SEO analysis on synced data (striking-distance, opportunity, movers, decay, zero-click, brand, cannibalization, clustering, concentration, seasonality)",
+			inputSchema: analysisSchema.shape
+		}, async ({ siteId, tool, startDate, endDate, limit }) => {
+			const params = {};
+			if (startDate) params.startDate = startDate;
+			if (endDate) params.endDate = endDate;
+			if (limit) params.limit = String(limit);
+			const result = await cloudClient.analysis(siteId, tool, params);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(result, null, 2)
+			}] };
+		});
+		server.registerTool("cloud-register-site", {
+			description: "Register a site for syncing on gscdump.com",
+			inputSchema: z.object({ siteUrl: z.string().describe("Site URL to register (e.g., example.com)") }).shape
+		}, async ({ siteUrl }) => {
+			const result = await cloudClient.registerSite(siteUrl);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(result, null, 2)
+			}] };
+		});
+		server.registerTool("cloud-query", {
+			description: "Live GSC query via gscdump.com platform (bypasses synced data, queries Google directly)",
+			inputSchema: z.object({
+				siteId: z.string().describe("Site ID from gscdump platform"),
+				startDate: z.string().describe("Start date (YYYY-MM-DD)"),
+				endDate: z.string().describe("End date (YYYY-MM-DD)"),
+				dimensions: z.string().optional().describe("Comma-separated: page,query,country,device,date,searchAppearance"),
+				rowLimit: z.number().optional().describe("Max rows (default 1000, max 25000)")
+			}).shape
+		}, async ({ siteId, startDate, endDate, dimensions, rowLimit }) => {
+			const params = {
+				startDate,
+				endDate
+			};
+			if (dimensions) params.dimensions = dimensions;
+			if (rowLimit) params.rowLimit = String(rowLimit);
+			const result = await cloudClient.query(siteId, params);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(result, null, 2)
+			}] };
+		});
+		server.registerTool("cloud-indexing", {
+			description: "Get indexing status trend and summary for a site on gscdump.com",
+			inputSchema: z.object({
+				siteId: z.string().describe("Site ID from gscdump platform"),
+				days: z.number().optional().describe("Days of trend data (default 28, max 90)")
+			}).shape
+		}, async ({ siteId, days }) => {
+			const params = {};
+			if (days) params.days = String(days);
+			const result = await cloudClient.indexing(siteId, params);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(result, null, 2)
+			}] };
+		});
+		server.registerTool("cloud-indexing-diagnostics", {
+			description: "Get indexing issue diagnostics with counts and severity for a site",
+			inputSchema: siteIdSchema.shape
+		}, async ({ siteId }) => {
+			const result = await cloudClient.indexingDiagnostics(siteId);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(result, null, 2)
+			}] };
+		});
+		server.registerTool("cloud-indexing-urls", {
+			description: "Get paginated URL list with indexing status, verdict, and coverage details",
+			inputSchema: z.object({
+				siteId: z.string().describe("Site ID from gscdump platform"),
+				status: z.enum([
+					"indexed",
+					"not_indexed",
+					"pending"
+				]).optional().describe("Filter by status"),
+				issue: z.string().optional().describe("Filter by issue type"),
+				search: z.string().optional().describe("Search URLs"),
+				limit: z.number().optional().describe("Max results (default 100, max 500)"),
+				offset: z.number().optional().describe("Pagination offset")
+			}).shape
+		}, async ({ siteId, status, issue, search, limit, offset }) => {
+			const params = {};
+			if (status) params.status = status;
+			if (issue) params.issue = issue;
+			if (search) params.search = search;
+			if (limit) params.limit = String(limit);
+			if (offset) params.offset = String(offset);
+			const result = await cloudClient.indexingUrls(siteId, params);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(result, null, 2)
+			}] };
+		});
+		server.registerTool("cloud-index-percent", {
+			description: "Get index percent trend, invisible URLs (in sitemap but no traffic), and orphan pages (traffic but not in sitemap)",
+			inputSchema: siteIdSchema.shape
+		}, async ({ siteId }) => {
+			const result = await cloudClient.indexPercent(siteId);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(result, null, 2)
+			}] };
+		});
+		server.registerTool("cloud-trigger-sync", {
+			description: "Trigger a fresh data sync for a site on gscdump.com",
+			inputSchema: siteIdSchema.shape
+		}, async ({ siteId }) => {
+			const result = await cloudClient.triggerSync(siteId);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(result, null, 2)
+			}] };
+		});
+		server.registerTool("cloud-delete-site", {
+			description: "Unregister a site from gscdump.com (stops syncing, removes pending jobs)",
+			inputSchema: siteIdSchema.shape
+		}, async ({ siteId }) => {
+			const result = await cloudClient.deleteSite(siteId);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(result, null, 2)
+			}] };
+		});
+		server.registerTool("cloud-sitemap-action", {
+			description: "Submit, delete, or refresh sitemaps via gscdump.com",
+			inputSchema: z.object({
+				siteId: z.string().describe("Site ID from gscdump platform"),
+				action: z.enum([
+					"submit",
+					"delete",
+					"refresh"
+				]).describe("Action to perform"),
+				sitemapUrl: z.string().optional().describe("Sitemap URL (required for submit/delete)")
+			}).shape
+		}, async ({ siteId, action, sitemapUrl }) => {
+			const body = { action };
+			if (sitemapUrl) body.sitemapUrl = sitemapUrl;
+			const result = await cloudClient.sitemapAction(siteId, body);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(result, null, 2)
+			}] };
+		});
+	}
 	return server;
 }
 
 //#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 };
+	if ((process$1.env.GOOGLE_ACCESS_TOKEN || process$1.env.GOOGLE_REFRESH_TOKEN) && process$1.env.GOOGLE_CLIENT_ID && process$1.env.GOOGLE_CLIENT_SECRET) return { ok: true };
 	const config = await loadConfig();
 	if (!config.mode) return {
 		ok: false,
@@ -1287,13 +2232,14 @@ const mcpCommand = defineCommand({
 	async run() {
 		const authCheck = await checkAuth();
 		if (!authCheck.ok) {
-			process.stderr.write(`\n${authCheck.error}\n\n`);
-			process.exit(1);
+			process$1.stderr.write(`\n${authCheck.error}\n\n`);
+			process$1.exit(1);
 		}
 		const server = createGscMcpServer({
 			name: "gscdump",
 			version: VERSION,
-			getAuth: () => getAuth({ interactive: false })
+			getAuth: () => getAuth({ interactive: false }),
+			cloudClient: await getCloudClient()
 		});
 		const transport = new StdioServerTransport();
 		await server.connect(transport);
@@ -1310,6 +2256,36 @@ const DIMENSION_MAP = {
 	device,
 	searchAppearance
 };
+async function resolveCloudSite$1(cloud, target) {
+	const me = await cloud.me().catch((e) => {
+		logger.error(`Failed to fetch sites: ${e.message}`);
+		process$1.exit(1);
+	});
+	if (me.sites.length === 0) {
+		logger.error("No registered sites. Run gscdump register first.");
+		process$1.exit(1);
+	}
+	let site = target ? me.sites.find((s) => s.siteUrl === target || s.siteUrl.includes(target)) : void 0;
+	if (!site) if (me.sites.length === 1) site = me.sites[0];
+	else {
+		const selected = await select({
+			message: "Select a site",
+			options: me.sites.map((s) => ({
+				value: s.siteId,
+				label: s.siteUrl
+			}))
+		});
+		if (isCancel(selected)) {
+			cancel("Cancelled");
+			process$1.exit(0);
+		}
+		site = me.sites.find((s) => s.siteId === selected);
+	}
+	return {
+		siteId: site.siteId,
+		siteUrl: site.siteUrl
+	};
+}
 const queryCommand = defineCommand({
 	meta: {
 		name: "query",
@@ -1366,34 +2342,8 @@ const queryCommand = defineCommand({
 	},
 	async run({ args }) {
 		const config = await loadConfig();
-		const { getAuth: getAuth$1 } = await Promise.resolve().then(() => auth_exports);
-		const client = googleSearchConsole(await getAuth$1({
-			interactive: false,
-			config
-		}));
-		let siteUrl = String(args.site || config.defaultSite || "");
-		if (!siteUrl || args.interactive) {
-			const verified = (await client.sites()).filter((s) => s.permissionLevel !== "siteUnverifiedUser");
-			if (verified.length === 0) {
-				logger.error("No verified sites found");
-				process.exit(1);
-			}
-			const selected = await select({
-				message: "Select a site",
-				options: verified.map((s) => ({
-					value: s.siteUrl,
-					label: s.siteUrl
-				})),
-				initialValue: siteUrl || verified[0]?.siteUrl
-			});
-			if (isCancel(selected)) {
-				cancel("Cancelled");
-				process.exit(0);
-			}
-			siteUrl = selected;
-		}
-		let dimensions;
-		if (args.dimensions) dimensions = String(args.dimensions).split(",").filter((d) => d in DIMENSION_MAP).map((d) => DIMENSION_MAP[d]);
+		let dimNames;
+		if (args.dimensions) dimNames = String(args.dimensions).split(",").filter((d) => d in DIMENSION_MAP);
 		else if (args.interactive) {
 			const selected = await multiselect({
 				message: "Select dimensions",
@@ -1405,10 +2355,10 @@ const queryCommand = defineCommand({
 			});
 			if (isCancel(selected)) {
 				cancel("Cancelled");
-				process.exit(0);
+				process$1.exit(0);
 			}
-			dimensions = selected.map((d) => DIMENSION_MAP[d]);
-		} else dimensions = [page, query];
+			dimNames = selected;
+		} else dimNames = ["page", "query"];
 		let startDate;
 		let endDate;
 		if (args.start && args.end) {
@@ -1421,7 +2371,7 @@ const queryCommand = defineCommand({
 			});
 			if (isCancel(startInput)) {
 				cancel("Cancelled");
-				process.exit(0);
+				process$1.exit(0);
 			}
 			const endInput = await text({
 				message: "End date (YYYY-MM-DD)",
@@ -1429,7 +2379,7 @@ const queryCommand = defineCommand({
 			});
 			if (isCancel(endInput)) {
 				cancel("Cancelled");
-				process.exit(0);
+				process$1.exit(0);
 			}
 			startDate = String(startInput) || (/* @__PURE__ */ new Date(Date.now() - 28 * 864e5)).toISOString().split("T")[0];
 			endDate = String(endInput) || (/* @__PURE__ */ new Date(Date.now() - 3 * 864e5)).toISOString().split("T")[0];
@@ -1439,6 +2389,63 @@ const queryCommand = defineCommand({
 		}
 		const rowLimit = Number.parseInt(String(args.limit), 10);
 		const format = String(args.format);
+		const cloud = await getCloudClient();
+		if (cloud) {
+			const { siteId, siteUrl: siteUrl$1 } = await resolveCloudSite$1(cloud, args.site || config.defaultSite);
+			if (!args.quiet) logger.info(`Querying ${siteUrl$1}...`);
+			const result = await cloud.query(siteId, {
+				startDate,
+				endDate,
+				dimensions: dimNames.join(","),
+				rowLimit: String(rowLimit)
+			}).catch((e) => {
+				logger.error(`Query failed: ${e.message}`);
+				process$1.exit(1);
+			});
+			if (!args.quiet) logger.success(`Fetched ${result.rows.length} rows`);
+			const output$1 = {
+				siteUrl: siteUrl$1,
+				dimensions: dimNames,
+				dateRange: {
+					start: startDate,
+					end: endDate
+				},
+				total: result.rows.length,
+				data: result.rows
+			};
+			const content$1 = format === "csv" ? exportToCSV(output$1) : JSON.stringify(output$1, null, 2);
+			if (args.output) {
+				await fs.writeFile(String(args.output), content$1);
+				if (!args.quiet) logger.info(`Written to ${args.output}`);
+			} else console.log(content$1);
+			return;
+		}
+		const client = googleSearchConsole(await getAuth({
+			interactive: false,
+			config
+		}));
+		const dimensions = dimNames.map((d) => DIMENSION_MAP[d]);
+		let siteUrl = String(args.site || config.defaultSite || "");
+		if (!siteUrl || args.interactive) {
+			const verified = (await client.sites()).filter((s) => s.permissionLevel !== "siteUnverifiedUser");
+			if (verified.length === 0) {
+				logger.error("No verified sites found");
+				process$1.exit(1);
+			}
+			const selected = await select({
+				message: "Select a site",
+				options: verified.map((s) => ({
+					value: s.siteUrl,
+					label: s.siteUrl
+				})),
+				initialValue: siteUrl || verified[0]?.siteUrl
+			});
+			if (isCancel(selected)) {
+				cancel("Cancelled");
+				process$1.exit(0);
+			}
+			siteUrl = selected;
+		}
 		const builder = gsc.select(...dimensions).where(between(date, startDate, endDate)).limit(rowLimit);
 		if (!args.quiet) logger.info(`Querying ${siteUrl}...`);
 		const rows = [];
@@ -1446,7 +2453,7 @@ const queryCommand = defineCommand({
 			rows.push(...batch);
 			if (!args.quiet) {
 				clearLine();
-				process.stdout.write(progressBar(rows.length, rowLimit, `${rows.length} rows`));
+				process$1.stdout.write(progressBar(rows.length, rowLimit, `${rows.length} rows`));
 			}
 		}
 		if (!args.quiet) {
@@ -1455,7 +2462,7 @@ const queryCommand = defineCommand({
 		}
 		const output = {
 			siteUrl,
-			dimensions: dimensions.map((d) => String(d)),
+			dimensions: dimNames,
 			dateRange: {
 				start: startDate,
 				end: endDate
@@ -1471,6 +2478,84 @@ const queryCommand = defineCommand({
 	}
 });
 
+//#endregion
+//#region src/commands/register.ts
+const registerCommand = defineCommand({
+	meta: {
+		name: "register",
+		description: "Register site(s) for syncing (cloud mode only)"
+	},
+	args: { site: {
+		type: "positional",
+		description: "Site URL(s) to register (space-separated for bulk)",
+		required: false
+	} },
+	async run({ args }) {
+		const cloud = await getCloudClient();
+		if (!cloud) {
+			logger.error("Register requires cloud mode. Run gscdump init to set up cloud mode.");
+			process$1.exit(1);
+		}
+		const rawArgs = process$1.argv.slice(3).filter((a) => !a.startsWith("-"));
+		const siteUrls = rawArgs.length > 0 ? rawArgs : args.site ? [args.site] : [];
+		if (siteUrls.length > 1) {
+			logger.info(`Registering ${siteUrls.length} sites...`);
+			const result$1 = await cloud.bulkRegister(siteUrls).catch((e) => {
+				logger.error(`Bulk registration failed: ${e.message}`);
+				process$1.exit(1);
+			});
+			console.log();
+			for (const r of result$1.results) {
+				const icon = r.status === "registered" ? "\x1B[32m✓\x1B[0m" : r.status === "already_exists" ? "\x1B[33m~\x1B[0m" : "\x1B[31m✗\x1B[0m";
+				const detail = r.status === "registered" ? `ID: ${r.siteId}` : r.status === "already_exists" ? "already registered" : r.error || r.status;
+				console.log(`  ${icon} ${r.siteUrl} — ${detail}`);
+			}
+			console.log();
+			const s = result$1.summary;
+			logger.success(`${s.registered} registered, ${s.alreadyExists} existing, ${s.notFound} not found, ${s.errors} errors`);
+			return;
+		}
+		let siteUrl = siteUrls[0];
+		if (!siteUrl) {
+			const available = await cloud.availableSites().catch((e) => {
+				logger.error(`Failed to fetch available sites: ${e.message}`);
+				process$1.exit(1);
+			});
+			const unregistered = available.filter((s) => !s.registered);
+			if (unregistered.length === 0) {
+				if (available.length > 0) logger.info("All available sites are already registered");
+				else logger.warn("No GSC sites found for this account");
+				return;
+			}
+			const selected = await select({
+				message: "Select a site to register for syncing",
+				options: unregistered.map((s) => ({
+					value: s.siteUrl,
+					label: s.siteUrl,
+					hint: s.permissionLevel
+				}))
+			});
+			if (isCancel(selected)) {
+				cancel("Cancelled");
+				process$1.exit(0);
+			}
+			siteUrl = selected;
+		}
+		logger.info(`Registering ${siteUrl}...`);
+		const result = await cloud.registerSite(siteUrl).catch((e) => {
+			logger.error(`Registration failed: ${e.message}`);
+			process$1.exit(1);
+		});
+		if (result.existing) logger.info(`Site already registered (${result.status})`);
+		else logger.success(`Site registered! Sync queued.`);
+		console.log();
+		console.log(`  Site ID: \x1B[36m${result.siteId}\x1B[0m`);
+		console.log(`  Status:  ${result.status}`);
+		console.log();
+		logger.info("Run gscdump sync status to check sync progress");
+	}
+});
+
 //#endregion
 //#region src/commands/sitemaps.ts
 const listCommand = defineCommand({
@@ -1482,7 +2567,6 @@ const listCommand = defineCommand({
 		site: {
 			type: "string",
 			alias: "s",
-			required: true,
 			description: "Site URL (e.g., sc-domain:example.com or https://example.com/)"
 		},
 		json: {
@@ -1492,6 +2576,69 @@ const listCommand = defineCommand({
 		}
 	},
 	async run({ args }) {
+		const cloud = await getCloudClient();
+		if (cloud) {
+			const config = await loadConfig();
+			const target = args.site || config.defaultSite;
+			const me = await cloud.me().catch((e) => {
+				logger.error(`Failed to fetch sites: ${e.message}`);
+				process$1.exit(1);
+			});
+			if (me.sites.length === 0) {
+				logger.warn("No registered sites. Run gscdump register first.");
+				return;
+			}
+			let site = target ? me.sites.find((s) => s.siteUrl === target || s.siteUrl.includes(target)) : void 0;
+			if (!site) if (me.sites.length === 1) site = me.sites[0];
+			else {
+				const selected = await select({
+					message: "Select a site",
+					options: me.sites.map((s) => ({
+						value: s.siteId,
+						label: s.siteUrl
+					}))
+				});
+				if (isCancel(selected)) {
+					cancel("Cancelled");
+					process$1.exit(0);
+				}
+				site = me.sites.find((s) => s.siteId === selected);
+			}
+			const data = await cloud.sitemaps(site.siteId).catch((e) => {
+				logger.error(`Failed to fetch sitemaps: ${e.message}`);
+				process$1.exit(1);
+			});
+			if (args.json) {
+				console.log(JSON.stringify(data, null, 2));
+				return;
+			}
+			if (data.sitemaps.length === 0) {
+				logger.warn("No sitemaps found");
+				return;
+			}
+			logger.success(`${data.sitemaps.length} sitemaps:`);
+			console.log();
+			for (const sm of data.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` : "";
+				const urls = sm.urlCount ? ` \x1B[36m${sm.urlCount.toLocaleString()} URLs\x1B[0m` : "";
+				console.log(`  ${sm.path}${urls}${pending}${errors}${warnings}`);
+			}
+			if (data.history.length > 0) {
+				console.log();
+				console.log("  \x1B[1mRecent History\x1B[0m");
+				for (const h of data.history.slice(0, 7)) {
+					const errStr = h.errors > 0 ? ` \x1B[31m${h.errors} err\x1B[0m` : "";
+					console.log(`  ${h.date}: ${h.urlCount.toLocaleString()} URLs${errStr}`);
+				}
+			}
+			return;
+		}
+		if (!args.site) {
+			logger.error("Site URL required (-s)");
+			process$1.exit(1);
+		}
 		const sitemaps = await fetchSitemaps(googleSearchConsole(await getAuth({ interactive: false })), args.site).catch(gscErrorHandler);
 		if (args.json) {
 			console.log(JSON.stringify(sitemaps, null, 2));
@@ -1574,6 +2721,29 @@ const submitCommand = defineCommand({
 		}
 	},
 	async run({ args }) {
+		const cloud = await getCloudClient();
+		if (cloud) {
+			const config = await loadConfig();
+			const me = await cloud.me().catch((e) => {
+				logger.error(`Failed to fetch sites: ${e.message}`);
+				process$1.exit(1);
+			});
+			const target = args.site || config.defaultSite;
+			const site = me.sites.find((s) => s.siteUrl === target || s.siteUrl.includes(target));
+			if (!site) {
+				logger.error(`Site not found: ${target}`);
+				process$1.exit(1);
+			}
+			await cloud.sitemapAction(site.siteId, {
+				action: "submit",
+				sitemapUrl: args.url
+			}).catch((e) => {
+				logger.error(`Submit failed: ${e.message}`);
+				process$1.exit(1);
+			});
+			logger.success(`Submitted sitemap: ${args.url}`);
+			return;
+		}
 		await submitSitemap(googleSearchConsole(await getAuth({ interactive: false })), args.site, args.url).catch(gscErrorHandler);
 		logger.success(`Submitted sitemap: ${args.url}`);
 	}
@@ -1597,10 +2767,77 @@ const deleteCommand = defineCommand({
 		}
 	},
 	async run({ args }) {
+		const cloud = await getCloudClient();
+		if (cloud) {
+			const config = await loadConfig();
+			const me = await cloud.me().catch((e) => {
+				logger.error(`Failed to fetch sites: ${e.message}`);
+				process$1.exit(1);
+			});
+			const target = args.site || config.defaultSite;
+			const site = me.sites.find((s) => s.siteUrl === target || s.siteUrl.includes(target));
+			if (!site) {
+				logger.error(`Site not found: ${target}`);
+				process$1.exit(1);
+			}
+			await cloud.sitemapAction(site.siteId, {
+				action: "delete",
+				sitemapUrl: args.url
+			}).catch((e) => {
+				logger.error(`Delete failed: ${e.message}`);
+				process$1.exit(1);
+			});
+			logger.success(`Deleted sitemap: ${args.url}`);
+			return;
+		}
 		await deleteSitemap(googleSearchConsole(await getAuth({ interactive: false })), args.site, args.url).catch(gscErrorHandler);
 		logger.success(`Deleted sitemap: ${args.url}`);
 	}
 });
+const refreshCommand = defineCommand({
+	meta: {
+		name: "refresh",
+		description: "Refresh sitemap data from GSC (cloud mode)"
+	},
+	args: { site: {
+		type: "string",
+		alias: "s",
+		description: "Site URL"
+	} },
+	async run({ args }) {
+		const cloud = await getCloudClient();
+		if (!cloud) {
+			logger.error("Sitemap refresh requires cloud mode. Run gscdump init to set up.");
+			process$1.exit(1);
+		}
+		const config = await loadConfig();
+		const me = await cloud.me().catch((e) => {
+			logger.error(`Failed to fetch sites: ${e.message}`);
+			process$1.exit(1);
+		});
+		const target = args.site || config.defaultSite;
+		let site = target ? me.sites.find((s) => s.siteUrl === target || s.siteUrl.includes(target)) : me.sites.length === 1 ? me.sites[0] : void 0;
+		if (!site) {
+			const selected = await select({
+				message: "Select a site",
+				options: me.sites.map((s) => ({
+					value: s.siteId,
+					label: s.siteUrl
+				}))
+			});
+			if (isCancel(selected)) {
+				cancel("Cancelled");
+				process$1.exit(0);
+			}
+			site = me.sites.find((s) => s.siteId === selected);
+		}
+		const result = await cloud.sitemapAction(site.siteId, { action: "refresh" }).catch((e) => {
+			logger.error(`Refresh failed: ${e.message}`);
+			process$1.exit(1);
+		});
+		logger.success(`Refreshed sitemaps (${result.sitemapCount} found)`);
+	}
+});
 const sitemapsCommand = defineCommand({
 	meta: {
 		name: "sitemaps",
@@ -1610,7 +2847,8 @@ const sitemapsCommand = defineCommand({
 		list: listCommand,
 		get: getCommand,
 		submit: submitCommand,
-		delete: deleteCommand
+		delete: deleteCommand,
+		refresh: refreshCommand
 	}
 });
 
@@ -1627,6 +2865,30 @@ const sitesCommand = defineCommand({
 		description: "Output as JSON for scripting"
 	} },
 	async run({ args }) {
+		const cloud = await getCloudClient();
+		if (cloud) {
+			const me = await cloud.me().catch((e) => {
+				logger.error(`Failed to fetch sites: ${e.message}`);
+				process.exit(1);
+			});
+			if (args.json) {
+				console.log(JSON.stringify(me.sites, null, 2));
+				return;
+			}
+			if (me.sites.length === 0) {
+				logger.warn("No registered sites. Run gscdump register to add a site.");
+				return;
+			}
+			logger.success(`${me.sites.length} registered sites:`);
+			console.log();
+			for (const site of me.sites) {
+				const statusColor = site.syncStatus === "synced" ? "\x1B[32m" : site.syncStatus === "syncing" ? "\x1B[33m" : site.syncStatus === "error" ? "\x1B[31m" : "\x1B[90m";
+				console.log(`  ${site.siteUrl} ${statusColor}(${site.syncStatus || "pending"})\x1B[0m`);
+				if (site.syncProgress.percent > 0 && site.syncProgress.percent < 100) console.log(`    ${progressBar(site.syncProgress.percent, 100, `${site.syncProgress.percent}%`, 20)}`);
+				if (site.oldestDateSynced && site.newestDateSynced) console.log(`    \x1B[90m${site.oldestDateSynced} → ${site.newestDateSynced}\x1B[0m`);
+			}
+			return;
+		}
 		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"
@@ -1648,6 +2910,200 @@ const sitesCommand = defineCommand({
 	}
 });
 
+//#endregion
+//#region src/commands/sync.ts
+async function resolveCloudSite(cloud, target) {
+	const me = await cloud.me().catch((e) => {
+		logger.error(`Failed to fetch sites: ${e.message}`);
+		process$1.exit(1);
+	});
+	if (me.sites.length === 0) {
+		logger.error("No registered sites. Run gscdump register first.");
+		process$1.exit(1);
+	}
+	let site = target ? me.sites.find((s) => s.siteUrl === target || s.siteUrl.includes(target)) : void 0;
+	if (!site) if (me.sites.length === 1) site = me.sites[0];
+	else {
+		const selected = await select({
+			message: "Select a site",
+			options: me.sites.map((s) => ({
+				value: s.siteId,
+				label: s.siteUrl,
+				hint: s.syncStatus || "unknown"
+			}))
+		});
+		if (isCancel(selected)) {
+			cancel("Cancelled");
+			process$1.exit(0);
+		}
+		site = me.sites.find((s) => s.siteId === selected);
+	}
+	return {
+		siteId: site.siteId,
+		siteUrl: site.siteUrl
+	};
+}
+function requireCloud(cloud) {
+	if (!cloud) {
+		logger.error("Sync requires cloud mode. Run gscdump init to set up cloud mode.");
+		process$1.exit(1);
+	}
+}
+const statusCommand = defineCommand({
+	meta: {
+		name: "status",
+		description: "Check sync status for a site"
+	},
+	args: {
+		site: {
+			type: "string",
+			alias: "s",
+			description: "Site URL"
+		},
+		json: {
+			type: "boolean",
+			default: false,
+			description: "Output as JSON"
+		}
+	},
+	async run({ args }) {
+		const cloud = await getCloudClient();
+		requireCloud(cloud);
+		const config = await loadConfig();
+		const { siteId } = await resolveCloudSite(cloud, args.site || config.defaultSite);
+		const status = await cloud.syncStatus(siteId).catch((e) => {
+			logger.error(`Failed to fetch sync status: ${e.message}`);
+			process$1.exit(1);
+		});
+		if (args.json) {
+			console.log(JSON.stringify(status, null, 2));
+			return;
+		}
+		console.log();
+		console.log(`  \x1B[1m${status.siteUrl}\x1B[0m`);
+		console.log();
+		const statusColor = status.syncStatus === "synced" ? "\x1B[32m" : status.isSyncing ? "\x1B[33m" : status.syncStatus === "error" ? "\x1B[31m" : "\x1B[90m";
+		console.log(`  Status:   ${statusColor}${status.syncStatus}\x1B[0m`);
+		console.log(`  Progress: ${progressBar(status.progress, 100, `${status.progress}%`)}`);
+		console.log(`  Days:     \x1B[36m${status.daysSynced}\x1B[0m / ${status.daysAvailable} synced`);
+		if (status.oldestDateSynced) console.log(`  Range:    ${status.oldestDateSynced} \x1B[90m→\x1B[0m ${status.newestDateSynced}`);
+		console.log();
+		console.log("  \x1B[1mJobs\x1B[0m");
+		console.log(`  Queued:     ${status.jobs.queued}`);
+		console.log(`  Processing: ${status.jobs.processing}`);
+		console.log(`  Completed:  \x1B[32m${status.jobs.completed}\x1B[0m`);
+		if (status.jobs.failed > 0) console.log(`  Failed:     \x1B[31m${status.jobs.failed}\x1B[0m`);
+		const tableNames = Object.keys(status.tables);
+		if (tableNames.length > 0) {
+			console.log();
+			console.log("  \x1B[1mTables\x1B[0m");
+			for (const name of tableNames) {
+				const t = status.tables[name];
+				const rows = t.totalRows > 0 ? ` (${t.totalRows.toLocaleString()} rows)` : "";
+				console.log(`  ${name}: \x1B[32m${t.completed}\x1B[0m done, ${t.queued} queued${t.failed > 0 ? `, \x1B[31m${t.failed} failed\x1B[0m` : ""}${rows}`);
+			}
+		}
+		if (status.failedJobs.length > 0) {
+			console.log();
+			console.log("  \x1B[31mFailed Jobs\x1B[0m");
+			for (const j of status.failedJobs.slice(0, 5)) console.log(`  ${j.date} ${j.tableName}: ${j.error}`);
+			if (status.failedJobs.length > 5) console.log(`  \x1B[90m... and ${status.failedJobs.length - 5} more\x1B[0m`);
+		}
+		console.log();
+	}
+});
+const triggerCommand = defineCommand({
+	meta: {
+		name: "trigger",
+		description: "Trigger a fresh sync for a site"
+	},
+	args: { site: {
+		type: "string",
+		alias: "s",
+		description: "Site URL"
+	} },
+	async run({ args }) {
+		const cloud = await getCloudClient();
+		requireCloud(cloud);
+		const config = await loadConfig();
+		const { siteId, siteUrl } = await resolveCloudSite(cloud, args.site || config.defaultSite);
+		const result = await cloud.triggerSync(siteId).catch((e) => {
+			logger.error(`Failed to trigger sync: ${e.message}`);
+			process$1.exit(1);
+		});
+		logger.success(`Sync triggered for ${siteUrl}`);
+		console.log(`  ${result.message}`);
+		console.log();
+	}
+});
+const syncCommand = defineCommand({
+	meta: {
+		name: "sync",
+		description: "Sync status and management (cloud mode only)"
+	},
+	subCommands: {
+		status: statusCommand,
+		trigger: triggerCommand
+	}
+});
+
+//#endregion
+//#region src/commands/unregister.ts
+const unregisterCommand = defineCommand({
+	meta: {
+		name: "unregister",
+		description: "Unregister a site from syncing (cloud mode only)"
+	},
+	args: { site: {
+		type: "positional",
+		description: "Site URL to unregister",
+		required: false
+	} },
+	async run({ args }) {
+		const cloud = await getCloudClient();
+		if (!cloud) {
+			logger.error("Unregister requires cloud mode. Run gscdump init to set up.");
+			process$1.exit(1);
+		}
+		const config = await loadConfig();
+		const target = args.site || config.defaultSite;
+		const me = await cloud.me().catch((e) => {
+			logger.error(`Failed to fetch sites: ${e.message}`);
+			process$1.exit(1);
+		});
+		if (me.sites.length === 0) {
+			logger.warn("No registered sites.");
+			return;
+		}
+		let site = target ? me.sites.find((s) => s.siteUrl === target || s.siteUrl.includes(target)) : void 0;
+		if (!site) {
+			const selected = await select({
+				message: "Select a site to unregister",
+				options: me.sites.map((s) => ({
+					value: s.siteId,
+					label: s.siteUrl,
+					hint: s.syncStatus || "unknown"
+				}))
+			});
+			if (isCancel(selected)) {
+				cancel("Cancelled");
+				process$1.exit(0);
+			}
+			site = me.sites.find((s) => s.siteId === selected);
+		}
+		const confirmed = await confirm({ message: `Unregister ${site.siteUrl}? This will stop syncing and delete pending jobs.` });
+		if (isCancel(confirmed) || !confirmed) {
+			cancel("Cancelled");
+			process$1.exit(0);
+		}
+		const result = await cloud.deleteSite(site.siteId).catch((e) => {
+			logger.error(`Failed to unregister: ${e.message}`);
+			process$1.exit(1);
+		});
+		logger.success(`Unregistered ${result.siteUrl}`);
+	}
+});
+
 //#endregion
 //#region src/index.ts
 runMain(defineCommand({
@@ -1662,14 +3118,19 @@ runMain(defineCommand({
 		query: queryCommand,
 		sites: sitesCommand,
 		sitemaps: sitemapsCommand,
+		register: registerCommand,
+		unregister: unregisterCommand,
+		sync: syncCommand,
+		indexing: indexingCommand,
+		analysis: analysisCommand,
 		auth: authCommand,
 		config: configCommand,
 		mcp: mcpCommand
 	},
 	setup() {
-		if (!process.argv.includes("mcp")) showSplash();
+		if (!process$1.argv.includes("mcp")) showSplash();
 	}
 }));
 
 //#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 };
+export {  };