@gscdump/cli 0.37.2 → 0.37.4

package/dist/_chunks/sync.mjs

@@ -0,0 +1,489 @@
+import { OUTPUT_ARGS, applyOutputMode, clearLine, displayPath, formatAge, logger, runWithConcurrency } from "./utils.mjs";
+import { TABLE_DIMS, allTables, createCommandContext, createLocalStore, transformGscRow } from "./context.mjs";
+import process from "node:process";
+import { defineCommand } from "citty";
+import { SearchTypes } from "gscdump/query";
+import { createEmptyTypesStore } from "@gscdump/engine/entities";
+import { progressBar } from "gscdump";
+import { daysAgoUtc, getDateRange } from "gscdump/dates";
+import { DEFAULT_ROLLUPS, rebuildRollups } from "@gscdump/engine/rollups";
+const DEFAULT_TABLES = [
+	"pages",
+	"queries",
+	"countries",
+	"dates"
+];
+const DEFAULT_TYPES = ["web"];
+const ALL_SEARCH_TYPES = Object.values(SearchTypes);
+const DEFAULT_PENDING_DAYS = 3;
+const DEFAULT_CONCURRENCY = 8;
+const EMPTY_TYPE_PROBE_MIN_DAYS = 7;
+const EMPTY_TYPE_PROTECTED = ["web"];
+function createProgressTracker(total, quiet) {
+	if (quiet) return {
+		tick: () => {},
+		done: () => {}
+	};
+	let current = 0;
+	let lastLabel = "";
+	let timer = null;
+	const render = () => {
+		clearLine();
+		process.stdout.write(progressBar(current, total, lastLabel));
+	};
+	timer = setInterval(render, 100);
+	return {
+		tick: (label) => {
+			current++;
+			lastLabel = label;
+		},
+		done: () => {
+			if (timer) {
+				clearInterval(timer);
+				timer = null;
+			}
+			clearLine();
+		}
+	};
+}
+async function syncTable(store, siteUrl, table, searchType, dates, client, concurrency, force, progress) {
+	const dims = TABLE_DIMS[table];
+	const siteId = store.siteIdFor(siteUrl);
+	let totalRows = 0;
+	let skipped = 0;
+	let failed = 0;
+	const priorStates = await store.engine.getSyncStates({
+		userId: store.userId,
+		siteId,
+		table,
+		searchType
+	});
+	const stateByDate = new Map(priorStates.map((s) => [s.date, s]));
+	const label = searchType === "web" ? table : `${table}/${searchType}`;
+	await runWithConcurrency(dates, concurrency, async (date) => {
+		const prior = stateByDate.get(date);
+		if (!force && prior?.state === "done") {
+			skipped++;
+			progress.tick(`${label} ${date} (skip)`);
+			return;
+		}
+		const scope = {
+			userId: store.userId,
+			siteId,
+			table,
+			date,
+			searchType
+		};
+		await store.engine.setSyncState(scope, "inflight");
+		const result = await runOneDate(store, client, siteUrl, table, searchType, dims, date).catch((err) => ({
+			kind: "error",
+			error: err
+		}));
+		if (result.kind === "error") {
+			await store.engine.setSyncState(scope, "failed", { error: result.error.message });
+			failed++;
+			progress.tick(`${label} ${date} (fail)`);
+			return;
+		}
+		await store.engine.setSyncState(scope, "done");
+		totalRows += result.rows;
+		progress.tick(`${label} ${date}`);
+	});
+	return {
+		rows: totalRows,
+		skipped,
+		failed
+	};
+}
+async function runOneDate(store, client, siteUrl, table, searchType, dims, date) {
+	const rowLimit = 25e3;
+	const rows = [];
+	let startRow = 0;
+	while (true) {
+		const batch = (await client._rawQuery(siteUrl, {
+			startDate: date,
+			endDate: date,
+			dimensions: dims,
+			searchType,
+			rowLimit,
+			startRow
+		})).rows || [];
+		for (const apiRow of batch) {
+			const transformed = transformGscRow(table, {
+				keys: apiRow.keys ?? [],
+				clicks: apiRow.clicks ?? 0,
+				impressions: apiRow.impressions ?? 0,
+				ctr: apiRow.ctr ?? 0,
+				position: apiRow.position ?? 0
+			});
+			if (transformed) rows.push(transformed.row);
+		}
+		if (batch.length === 0) break;
+		startRow += batch.length;
+	}
+	const writeCtx = {
+		userId: store.userId,
+		siteId: store.siteIdFor(siteUrl),
+		table,
+		date,
+		searchType
+	};
+	await store.engine.writeDay(writeCtx, rows);
+	return {
+		kind: "ok",
+		rows: rows.length
+	};
+}
+const syncCommand = defineCommand({
+	meta: {
+		name: "sync",
+		description: "Sync GSC data to local Parquet store"
+	},
+	args: {
+		"site": {
+			type: "string",
+			alias: "s",
+			description: "Site URL"
+		},
+		"start": {
+			type: "string",
+			description: "Start date (YYYY-MM-DD) for historical sync"
+		},
+		"end": {
+			type: "string",
+			description: "End date (YYYY-MM-DD); defaults to 3 days ago"
+		},
+		"days": {
+			type: "string",
+			description: `Number of days back to sync (default: ${DEFAULT_PENDING_DAYS})`
+		},
+		"tables": {
+			type: "string",
+			alias: "t",
+			description: `Tables to sync (default: ${DEFAULT_TABLES.join(",")}); comma-separated`
+		},
+		"types": {
+			type: "string",
+			description: `GSC search types to sync (default: ${DEFAULT_TYPES.join(",")}); comma-separated. Allowed: ${ALL_SEARCH_TYPES.join(",")}.`
+		},
+		"force-types": {
+			type: "boolean",
+			default: false,
+			description: "Ignore stored empty-type markers and re-probe every requested type"
+		},
+		"no-rollups": {
+			type: "boolean",
+			default: false,
+			description: "Skip the post-sync rollup rebuild (daily/weekly totals, top-N tables)"
+		},
+		"full": {
+			type: "boolean",
+			description: "Sync the last 450 days (full GSC history)"
+		},
+		...OUTPUT_ARGS,
+		"force": {
+			type: "boolean",
+			default: false,
+			description: "Re-sync dates already marked done (default: skip them for idempotent resume)"
+		},
+		"status": {
+			type: "boolean",
+			default: false,
+			description: "Print watermarks + sync-state summary instead of syncing"
+		},
+		"concurrency": {
+			type: "string",
+			alias: "c",
+			description: `Concurrent in-flight day fetches per table (default: ${DEFAULT_CONCURRENCY})`
+		},
+		"serial-tables": {
+			type: "boolean",
+			default: false,
+			description: "Run tables sequentially (default: run all tables in parallel)"
+		},
+		"retry-failed": {
+			type: "boolean",
+			default: false,
+			description: "Only re-run dates currently in `failed` state (cheaper than --force)"
+		},
+		"dry-run": {
+			type: "boolean",
+			default: false,
+			description: "Print the planned (table, searchType, date) work and exit without hitting the API"
+		}
+	},
+	async run({ args }) {
+		const { json, quiet } = applyOutputMode(args);
+		if (args.status) {
+			const ctx = await createCommandContext();
+			await printSyncStatus({
+				config: ctx.config,
+				dataDir: ctx.dataDir
+			}, args.site ? String(args.site) : void 0, json);
+			return;
+		}
+		const ctx = await createCommandContext({
+			needsAuth: true,
+			needsStore: true
+		});
+		const client = ctx.client;
+		const siteUrl = await ctx.resolveSite(args.site ? String(args.site) : void 0);
+		const tables = args.tables ? String(args.tables).split(",").map((t) => t.trim()).filter(isKnownTable) : DEFAULT_TABLES;
+		const requestedTypes = args.types ? String(args.types).split(",").map((t) => t.trim()).filter(isKnownSearchType) : DEFAULT_TYPES;
+		if (requestedTypes.length === 0) {
+			logger.error(`No valid search types specified. Allowed: ${ALL_SEARCH_TYPES.join(",")}`);
+			process.exit(1);
+		}
+		const siteId = ctx.store.siteIdFor(siteUrl);
+		const emptyTypesStore = createEmptyTypesStore({ dataSource: ctx.store.dataSource });
+		const emptyTypesDoc = await emptyTypesStore.load({
+			userId: ctx.store.userId,
+			siteId
+		});
+		const forceTypes = Boolean(args["force-types"]);
+		const skippedTypes = [];
+		const types = [];
+		for (const t of requestedTypes) {
+			if (!forceTypes && emptyTypesDoc.emptyTypes.includes(t) && !EMPTY_TYPE_PROTECTED.includes(t)) {
+				skippedTypes.push(t);
+				continue;
+			}
+			types.push(t);
+		}
+		if (types.length === 0) {
+			logger.warn(`All requested types (${requestedTypes.join(", ")}) are marked empty for this site. Pass --force-types to re-probe.`);
+			return;
+		}
+		if (skippedTypes.length > 0 && !quiet) logger.info(`Skipping ${skippedTypes.join(", ")} (marked empty for this site; pass --force-types to re-probe).`);
+		const endDate = args.end ? String(args.end) : daysAgoUtc(DEFAULT_PENDING_DAYS);
+		let startDate;
+		if (args.start) startDate = String(args.start);
+		else if (args.full) startDate = daysAgoUtc(450);
+		else if (args.days) startDate = daysAgoUtc(Number.parseInt(String(args.days), 10) + DEFAULT_PENDING_DAYS - 1);
+		else startDate = daysAgoUtc(5);
+		let dates = getDateRange(startDate, endDate);
+		if (dates.length === 0) {
+			logger.error(`No dates to sync (start=${startDate}, end=${endDate})`);
+			process.exit(1);
+		}
+		const store = ctx.store;
+		if (args["retry-failed"]) {
+			const failedSet = /* @__PURE__ */ new Set();
+			for (const table of tables) for (const type of types) {
+				const states = await store.engine.getSyncStates({
+					userId: store.userId,
+					siteId,
+					table,
+					searchType: type
+				});
+				for (const s of states) if (s.state === "failed" && s.date >= startDate && s.date <= endDate) failedSet.add(s.date);
+			}
+			dates = dates.filter((d) => failedSet.has(d));
+			if (dates.length === 0) {
+				logger.success("No failed dates in range — nothing to retry.");
+				return;
+			}
+			args.force = true;
+			if (!quiet) logger.info(`--retry-failed: ${dates.length} date(s) to retry`);
+		}
+		if (args["dry-run"]) {
+			const plan = [];
+			for (const table of tables) for (const type of types) for (const date of dates) plan.push({
+				table,
+				searchType: type,
+				date
+			});
+			if (json) {
+				console.log(JSON.stringify({
+					siteUrl,
+					range: {
+						start: startDate,
+						end: endDate
+					},
+					tables,
+					types,
+					totalCalls: plan.length,
+					plan
+				}, null, 2));
+				return;
+			}
+			console.log();
+			logger.info(`Plan: ${plan.length} API call(s) for ${siteUrl}`);
+			console.log(`  Tables:   ${tables.join(", ")}`);
+			console.log(`  Types:    ${types.join(", ")}`);
+			console.log(`  Range:    ${startDate} → ${endDate} (${dates.length} days)`);
+			console.log();
+			logger.info("Pass without --dry-run to execute.");
+			return;
+		}
+		if (!quiet) {
+			logger.info(`Syncing ${siteUrl} (${tables.join(", ")}) [${types.join(", ")}] → ${displayPath(store.dataDir)}`);
+			logger.info(`Range: ${startDate} → ${endDate} (${dates.length} days)`);
+		}
+		const concurrency = args.concurrency ? Math.max(1, Number.parseInt(String(args.concurrency), 10) || DEFAULT_CONCURRENCY) : DEFAULT_CONCURRENCY;
+		const serialTables = Boolean(args["serial-tables"]);
+		const start = Date.now();
+		const totals = {};
+		const jobs = [];
+		for (const table of tables) for (const type of types) {
+			const label = type === "web" ? table : `${table}/${type}`;
+			jobs.push({
+				table,
+				type,
+				label
+			});
+		}
+		const progress = createProgressTracker(dates.length * jobs.length, quiet);
+		if (serialTables) for (const job of jobs) totals[job.label] = await syncTable(store, siteUrl, job.table, job.type, dates, client, concurrency, args.force, progress);
+		else {
+			const results = await Promise.all(jobs.map((job) => syncTable(store, siteUrl, job.table, job.type, dates, client, concurrency, args.force, progress)));
+			jobs.forEach((job, i) => {
+				totals[job.label] = results[i];
+			});
+		}
+		progress.done();
+		const seconds = ((Date.now() - start) / 1e3).toFixed(1);
+		if (!quiet) {
+			logger.success(`Synced ${siteUrl} in ${seconds}s`);
+			for (const [t, n] of Object.entries(totals)) {
+				const suffix = [n.skipped > 0 ? `${n.skipped} skipped` : null, n.failed > 0 ? `\x1B[31m${n.failed} failed\x1B[0m` : null].filter(Boolean).join(", ");
+				const tail = suffix ? ` (${suffix})` : "";
+				console.log(`  ${t}: ${n.rows.toLocaleString()} rows${tail}`);
+			}
+			console.log();
+		}
+		const anyFailed = Object.values(totals).some((t) => t.failed > 0);
+		const rowsByType = /* @__PURE__ */ new Map();
+		const failedByType = /* @__PURE__ */ new Map();
+		for (const job of jobs) {
+			const t = totals[job.label];
+			rowsByType.set(job.type, (rowsByType.get(job.type) ?? 0) + t.rows);
+			failedByType.set(job.type, (failedByType.get(job.type) ?? 0) + t.failed);
+		}
+		if (!forceTypes && dates.length >= EMPTY_TYPE_PROBE_MIN_DAYS) {
+			const toMark = [];
+			for (const type of types) {
+				if (EMPTY_TYPE_PROTECTED.includes(type)) continue;
+				if ((failedByType.get(type) ?? 0) > 0) continue;
+				if ((rowsByType.get(type) ?? 0) === 0) toMark.push(type);
+			}
+			if (toMark.length > 0) {
+				await emptyTypesStore.mark({
+					userId: store.userId,
+					siteId
+				}, toMark);
+				if (!quiet) logger.info(`Marked empty for future syncs: ${toMark.join(", ")} (0 rows across ${dates.length} days; pass --force-types to re-probe).`);
+			}
+		}
+		if (forceTypes && emptyTypesDoc.emptyTypes.length > 0) {
+			const toClear = [];
+			for (const type of types) if (emptyTypesDoc.emptyTypes.includes(type) && (rowsByType.get(type) ?? 0) > 0) toClear.push(type);
+			if (toClear.length > 0) {
+				await emptyTypesStore.clear({
+					userId: store.userId,
+					siteId
+				}, toClear);
+				if (!quiet) logger.info(`Cleared empty markers for: ${toClear.join(", ")} (re-probe found data).`);
+			}
+		}
+		const noRollups = Boolean(args["no-rollups"]);
+		const anyRowsSynced = Object.values(totals).some((t) => t.rows > 0);
+		if (!noRollups && anyRowsSynced) {
+			if (!quiet) logger.info(`Rebuilding rollups for [${siteId}] (${DEFAULT_ROLLUPS.length} rollups)…`);
+			const rollupStart = Date.now();
+			const results = await rebuildRollups({
+				engine: {
+					runSQL: (opts) => store.engine.runSQL(opts),
+					listPartitions: async ({ ctx, table, searchType }) => {
+						return (await store.engine.listLive({
+							userId: ctx.userId,
+							...ctx.siteId !== void 0 ? { siteId: ctx.siteId } : {},
+							table,
+							...searchType !== void 0 ? { searchType } : {}
+						})).map((e) => ({
+							partition: e.partition,
+							bytes: e.bytes
+						}));
+					}
+				},
+				dataSource: store.dataSource,
+				ctx: {
+					userId: store.userId,
+					siteId
+				},
+				defs: DEFAULT_ROLLUPS
+			}).catch((err) => {
+				logger.warn(`Rollup rebuild failed: ${err.message}`);
+				return [];
+			});
+			if (!quiet && results.length > 0) {
+				const kb = results.reduce((a, r) => a + r.bytes, 0) / 1024;
+				const ms = Date.now() - rollupStart;
+				logger.success(`Rebuilt ${results.length} rollup(s) in ${ms}ms — ${kb.toFixed(1)} KB`);
+			}
+		}
+		if (anyFailed) process.exit(1);
+	}
+});
+function isKnownTable(name) {
+	return allTables().includes(name);
+}
+function isKnownSearchType(name) {
+	return ALL_SEARCH_TYPES.includes(name);
+}
+async function printSyncStatus(resolved, siteFilter, asJson) {
+	const store = createLocalStore({ dataDir: resolved.dataDir });
+	const siteId = siteFilter ? store.siteIdFor(siteFilter) : void 0;
+	const watermarks = await store.engine.getWatermarks({
+		userId: store.userId,
+		siteId
+	});
+	const states = await store.engine.getSyncStates({
+		userId: store.userId,
+		siteId
+	});
+	const failed = states.filter((s) => s.state === "failed");
+	const inflight = states.filter((s) => s.state === "inflight");
+	if (asJson) {
+		console.log(JSON.stringify({
+			dataDir: store.dataDir,
+			siteFilter: siteFilter ?? null,
+			watermarks,
+			failed,
+			inflight
+		}, null, 2));
+		return;
+	}
+	console.log();
+	console.log(`  \x1B[1m${displayPath(store.dataDir)}\x1B[0m`);
+	if (siteFilter) console.log(`  \x1B[90mSite: ${siteFilter}\x1B[0m`);
+	console.log();
+	if (watermarks.length === 0) {
+		console.log(`  No sync watermarks. Run \`gscdump sync\` to ingest data.`);
+		console.log();
+		return;
+	}
+	console.log(`  \x1B[1mWatermarks:\x1B[0m`);
+	const sorted = [...watermarks].sort((a, b) => {
+		if (a.table !== b.table) return a.table.localeCompare(b.table);
+		return (a.siteId ?? "").localeCompare(b.siteId ?? "");
+	});
+	for (const w of sorted) {
+		const scope = w.siteId ? `${w.table}@${w.siteId}` : w.table;
+		console.log(`  ${scope.padEnd(28)} \x1B[36m${w.oldestDateSynced}\x1B[0m → \x1B[36m${w.newestDateSynced}\x1B[0m  \x1B[90m(last ${formatAge(w.lastSyncAt)})\x1B[0m`);
+	}
+	if (inflight.length > 0) {
+		console.log();
+		console.log(`  \x1B[33m${inflight.length} inflight:\x1B[0m`);
+		for (const s of inflight) console.log(`    ${s.table}${s.siteId ? `@${s.siteId}` : ""} ${s.date} (attempt ${s.attempts}, started ${formatAge(s.updatedAt)})`);
+	}
+	if (failed.length > 0) {
+		console.log();
+		console.log(`  \x1B[31m${failed.length} failed:\x1B[0m`);
+		for (const s of failed) console.log(`    ${s.table}${s.siteId ? `@${s.siteId}` : ""} ${s.date}: ${s.error ?? "unknown"}`);
+		console.log();
+		console.log(`  Re-run \`gscdump sync --force\` to retry failed dates.`);
+	}
+	console.log();
+}
+export { syncCommand };

package/dist/_chunks/utils.mjs

@@ -0,0 +1,191 @@
+import { useCliRuntime } from "./config.mjs";
+import process from "node:process";
+import fs from "node:fs/promises";
+import os from "node:os";
+import { Buffer } from "node:buffer";
+import { SearchTypes } from "gscdump/query";
+var version = "0.37.4";
+const ALL_SEARCH_TYPES = Object.values(SearchTypes);
+const VERSION = version;
+function noSubcommandSelected(parent, subNames) {
+	const argv = useCliRuntime().rawArgs;
+	const idx = argv.indexOf(parent);
+	if (idx < 0) return true;
+	const next = argv[idx + 1];
+	if (!next) return true;
+	return !subNames.includes(next);
+}
+const logger = new Proxy({}, {
+	get(_target, property) {
+		const active = useCliRuntime().logger;
+		const value = active[property];
+		return typeof value === "function" ? value.bind(active) : value;
+	},
+	set(_target, property, value) {
+		const active = useCliRuntime().logger;
+		active[property] = value;
+		return true;
+	}
+});
+function setQuiet(quiet) {
+	if (quiet) {
+		const runtime = useCliRuntime();
+		runtime.quiet = true;
+		runtime.logger.level = 1;
+	}
+}
+const OUTPUT_ARGS = {
+	json: {
+		type: "boolean",
+		default: false,
+		description: "Output as JSON"
+	},
+	quiet: {
+		type: "boolean",
+		alias: "q",
+		default: false,
+		description: "Suppress info/success output"
+	}
+};
+function applyOutputMode(args) {
+	const json = Boolean(args.json);
+	const quiet = json || Boolean(args.quiet);
+	setQuiet(quiet);
+	return {
+		json,
+		quiet
+	};
+}
+function parseSearchType(value, flag = "--search-type") {
+	if (!value) return void 0;
+	const v = String(value);
+	if (!ALL_SEARCH_TYPES.includes(v)) {
+		logger.error(`Invalid ${flag}: ${v}. Allowed: ${ALL_SEARCH_TYPES.join(", ")}`);
+		process.exit(1);
+	}
+	return v;
+}
+const ANSI_RE = /\x1B\[[0-9;]*m/g;
+function setNoColor(disable) {
+	if (disable) useCliRuntime().colorEnabled = false;
+}
+function configureColor(opts) {
+	if (opts.noColor || !opts.forceColor && !opts.stderrIsTTY) setNoColor(true);
+}
+function isColorEnabled() {
+	return useCliRuntime().colorEnabled;
+}
+async function withConfiguredOutput(run) {
+	if (isColorEnabled()) return run();
+	const original = process.stdout.write;
+	const write = original.bind(process.stdout);
+	process.stdout.write = ((chunk, ...rest) => {
+		if (typeof chunk === "string") chunk = chunk.replace(ANSI_RE, "");
+		else if (chunk instanceof Uint8Array) chunk = Buffer.from(chunk).toString("utf8").replace(ANSI_RE, "");
+		return write(chunk, ...rest);
+	});
+	try {
+		return await run();
+	} finally {
+		process.stdout.write = original;
+	}
+}
+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) {
+	return [...text].map((char, i) => {
+		const colorIndex = Math.floor(i / text.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 clearLine() {
+	process.stdout.write("\r\x1B[K");
+}
+function displayPath(absPath) {
+	const cwd = process.cwd();
+	const home = os.homedir();
+	if (absPath === cwd) return ".";
+	if (absPath.startsWith(`${cwd}/`)) return absPath.slice(cwd.length + 1);
+	if (absPath === home) return "~";
+	if (absPath.startsWith(`${home}/`)) return `~/${absPath.slice(home.length + 1)}`;
+	return absPath;
+}
+function formatAge(ms) {
+	const delta = Date.now() - ms;
+	if (delta < 6e4) return "just now";
+	if (delta < 36e5) return `${Math.floor(delta / 6e4)}m ago`;
+	if (delta < 864e5) return `${Math.floor(delta / 36e5)}h ago`;
+	return `${Math.floor(delta / 864e5)}d ago`;
+}
+async function runWithConcurrency(items, concurrency, processor) {
+	const cursor = { i: 0 };
+	async function worker() {
+		while (true) {
+			const i = cursor.i++;
+			if (i >= items.length) return;
+			await processor(items[i], i);
+		}
+	}
+	await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, worker));
+}
+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");
+}
+async function readUrlList(args) {
+	if (args.file) return (await fs.readFile(String(args.file), "utf-8")).split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
+	if (args.urls) return (Array.isArray(args.urls) ? args.urls : [args.urls]).map(String).filter(Boolean);
+	if (!process.stdin.isTTY) {
+		const chunks = [];
+		for await (const chunk of process.stdin) chunks.push(chunk);
+		return Buffer.concat(chunks).toString("utf-8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
+	}
+	return [];
+}
+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");
+}
+export { ALL_SEARCH_TYPES, OUTPUT_ARGS, VERSION, applyOutputMode, clearLine, configureColor, displayPath, exportToCSV, formatAge, logger, noSubcommandSelected, parseSearchType, readUrlList, runWithConcurrency, showSplash, toCSV, withConfiguredOutput };

package/dist/cli.d.mts

@@ -0,0 +1,28 @@
+import { ConsolaInstance } from "consola";
+type CliEnvironmentSource = Record<string, string | undefined>;
+interface CliRuntime {
+  activeProfileOverride: string | null;
+  colorEnabled: boolean;
+  configDir: string;
+  configDirOverridden: boolean;
+  environment: CliEnvironmentSource;
+  logger: ConsolaInstance;
+  quiet: boolean;
+  rawArgs: string[];
+}
+interface CreateCliRuntimeOptions {
+  configDir?: string;
+  environment?: CliEnvironmentSource;
+  rawArgs?: readonly string[];
+  stderr?: NodeJS.WriteStream;
+}
+declare function createCliRuntime(opts?: CreateCliRuntimeOptions): CliRuntime;
+declare const main: import("citty").CommandDef<import("citty").ArgsDef>;
+interface RunCliOptions {
+  rawArgs?: string[];
+  loadEnv?: boolean;
+  environment?: Record<string, string | undefined>;
+  runtime?: CliRuntime;
+}
+declare function runCli(opts?: RunCliOptions): Promise<void>;
+export { type CliRuntime, type CreateCliRuntimeOptions, RunCliOptions, createCliRuntime, main, runCli };