@gscdump/cli 3.4.4 → 3.6.0

package/dist/commands/query.mjs

@@ -1,9 +1,13 @@
 import { queryCommandMeta } from "../command-meta.mjs";
 import { loadConfig } from "../config.mjs";
-import { ALL_SEARCH_TYPES, exportToCSV, logger, parseSearchType } from "../utils.mjs";
+import { terminalOutputOptions } from "../render/terminal.mjs";
+import { ALL_SEARCH_TYPES, logger, parseSearchType, toCSV } from "../utils.mjs";
 import { allTables, inferTable } from "../local-store.mjs";
 import { createCommandContext } from "../context.mjs";
 import { gscErrorHandler } from "../error-handler.mjs";
+import { renderTable } from "../render/layout.mjs";
+import { asRecord, columnsFor } from "../render/analysis.mjs";
+import { renderQuery } from "../render/query.mjs";
 import process from "node:process";
 import { defineCommand } from "citty";
 import fs from "node:fs/promises";
@@ -53,6 +57,8 @@ const AGGREGATION_TYPES = [
 	"byPage",
 	"byProperty"
 ];
+const POSITIVE_INTEGER_RE = /^\d+$/;
+const ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
 function buildFilterFromArg(col, raw) {
 	if (raw.startsWith("!~")) return makeLeaf(col, "notContains", raw.slice(2));
 	if (raw.startsWith("!re:")) return notRegex(col, raw.slice(4));
@@ -148,8 +154,7 @@ const queryCommand = defineCommand({
 		"limit": {
 			type: "string",
 			alias: "l",
-			default: "1000",
-			description: "Max rows (default: 1000)"
+			description: "Max rows (default: saved defaultLimit or 1000)"
 		},
 		"output": {
 			type: "string",
@@ -159,8 +164,7 @@ const queryCommand = defineCommand({
 		"format": {
 			type: "string",
 			alias: "f",
-			default: "json",
-			description: "Output format: json or csv"
+			description: "Output format: table, json, or csv (default: saved defaultFormat or json)"
 		},
 		"sql": {
 			type: "string",
@@ -231,24 +235,33 @@ const queryCommand = defineCommand({
 		}
 	},
 	async run({ args }) {
+		const ctxConfig = await loadConfig();
+		const format = args.format ?? ctxConfig.defaultFormat ?? "json";
+		if (format !== "json" && format !== "csv" && format !== "table") {
+			logger.error("Invalid --format. Use table, json, or csv.");
+			process.exit(1);
+		}
 		if (args.sql) {
 			await runRawSqlMode({
 				sql: String(args.sql),
 				site: args.site ? String(args.site) : void 0,
 				table: args.table ? String(args.table) : "pages",
 				output: args.output ? String(args.output) : void 0,
+				format,
 				quiet: Boolean(args.quiet),
 				searchType: parseSearchType(args.type, "--type")
 			});
 			return;
 		}
-		const ctxConfig = await loadConfig();
 		const dimNames = await resolveDimensions(args);
 		const { startDate, endDate } = await resolveRange(args);
 		await promptFilters(args);
-		const limitArg = args.limit != null ? String(args.limit) : null;
-		const rowLimit = limitArg != null && limitArg !== "1000" ? Number.parseInt(limitArg, 10) : ctxConfig.defaultLimit ?? 1e3;
-		const format = String(args.format);
+		const limitArg = String(args.limit ?? ctxConfig.defaultLimit ?? 1e3);
+		const rowLimit = Number(limitArg);
+		if (!POSITIVE_INTEGER_RE.test(limitArg) || !Number.isSafeInteger(rowLimit) || rowLimit < 1) {
+			logger.error("Invalid --limit. Use a positive safe integer, such as --limit 1000.");
+			process.exit(1);
+		}
 		const dimensionFilter = buildDimensionFilter(args);
 		const searchType = parseSearchType(args.type ?? ctxConfig.defaultSearchType, "--type");
 		const dataState = args["data-state"] ? String(args["data-state"]) : ctxConfig.defaultDataState;
@@ -285,7 +298,7 @@ const queryCommand = defineCommand({
 				}, null, 2));
 				return;
 			}
-			if (!args.quiet) logger.info(`Querying ${siteUrl} via live GSC API...`);
+			if (!args.quiet) logger.debug(`Querying ${siteUrl} via live GSC API...`);
 			const result = await runLiveQuery(ctx.client, siteUrl, {
 				startDate,
 				endDate,
@@ -314,7 +327,7 @@ const queryCommand = defineCommand({
 			return;
 		}
 		if (dataState || aggregationType) logger.warn("--data-state / --aggregation-type are ignored without --live");
-		if (!args.quiet) logger.info(`Querying ${siteUrl} from local Parquet store...`);
+		if (!args.quiet) logger.debug(`Querying ${siteUrl} from local Parquet store...`);
 		const state = buildLocalState(dimNames, startDate, endDate, rowLimit, dimensionFilter);
 		const store = ctx.store;
 		const table = inferTable(dimNames);
@@ -357,7 +370,14 @@ const queryCommand = defineCommand({
 	}
 });
 async function resolveDimensions(args) {
-	if (args.dimensions) return String(args.dimensions).split(",").filter((d) => DIMENSIONS.includes(d));
+	if (args.dimensions != null) {
+		const dimensions = String(args.dimensions).split(",").map((d) => d.trim());
+		if (dimensions.some((d) => !DIMENSIONS.includes(d))) {
+			logger.error(`Invalid --dimensions. Use a comma-separated list from: ${DIMENSIONS.join(", ")}.`);
+			process.exit(1);
+		}
+		return [...new Set(dimensions)];
+	}
 	if (args.interactive) {
 		const selected = await multiselect({
 			message: "Select dimensions",
@@ -376,35 +396,48 @@ async function resolveDimensions(args) {
 	return ["page", "query"];
 }
 async function resolveRange(args) {
-	if (args.start && args.end) return {
-		startDate: String(args.start),
-		endDate: String(args.end)
-	};
+	let startDate = args.start != null ? String(args.start) : void 0;
+	let endDate = args.end != null ? String(args.end) : void 0;
 	if (args.interactive) {
-		const startInput = await text({
-			message: "Start date (YYYY-MM-DD)",
-			placeholder: daysAgoUtc(28)
-		});
-		if (isCancel(startInput)) {
-			cancel("Cancelled");
-			process.exit(0);
+		if (startDate === void 0) {
+			const startInput = await text({
+				message: "Start date (YYYY-MM-DD)",
+				placeholder: daysAgoUtc(28)
+			});
+			if (isCancel(startInput)) {
+				cancel("Cancelled");
+				process.exit(0);
+			}
+			startDate = String(startInput) || daysAgoUtc(28);
 		}
-		const endInput = await text({
-			message: "End date (YYYY-MM-DD)",
-			placeholder: daysAgoUtc(3)
-		});
-		if (isCancel(endInput)) {
-			cancel("Cancelled");
-			process.exit(0);
+		if (endDate === void 0) {
+			const endInput = await text({
+				message: "End date (YYYY-MM-DD)",
+				placeholder: daysAgoUtc(3)
+			});
+			if (isCancel(endInput)) {
+				cancel("Cancelled");
+				process.exit(0);
+			}
+			endDate = String(endInput) || daysAgoUtc(3);
+		}
+	}
+	startDate ??= daysAgoUtc(31);
+	endDate ??= daysAgoUtc(3);
+	for (const [flag, value] of [["--start", startDate], ["--end", endDate]]) {
+		const date = /* @__PURE__ */ new Date(`${value}T00:00:00Z`);
+		if (!ISO_DATE_RE.test(value) || !Number.isFinite(date.getTime()) || date.toISOString().slice(0, 10) !== value) {
+			logger.error(`Invalid ${flag}. Use a calendar date in YYYY-MM-DD format.`);
+			process.exit(1);
 		}
-		return {
-			startDate: String(startInput) || daysAgoUtc(28),
-			endDate: String(endInput) || daysAgoUtc(3)
-		};
+	}
+	if (startDate > endDate) {
+		logger.error("Invalid date range. --start must be on or before --end.");
+		process.exit(1);
 	}
 	return {
-		startDate: daysAgoUtc(31),
-		endDate: daysAgoUtc(3)
+		startDate,
+		endDate
 	};
 }
 async function promptFilters(args) {
@@ -492,7 +525,7 @@ async function runRawSqlMode(opts) {
 	});
 	const siteUrl = await ctx.resolveSite(opts.site);
 	const store = ctx.store;
-	if (!opts.quiet) logger.info(`Running raw SQL over table "${opts.table}" for ${siteUrl}`);
+	if (!opts.quiet) logger.debug(`Running raw SQL over table "${opts.table}" for ${siteUrl}`);
 	const { rows, sql } = await store.runRawSql({
 		sql: opts.sql,
 		siteUrl,
@@ -502,11 +535,11 @@ async function runRawSqlMode(opts) {
 		logger.error(`SQL failed: ${e.message}`);
 		process.exit(1);
 	});
-	const payload = JSON.stringify({
+	const payload = opts.format === "table" ? renderTable(rows, columnsFor(rows), terminalOutputOptions(Boolean(opts.output && opts.output !== "-"))).join("\n") : opts.format === "csv" ? toCSV(rows, Object.keys(rows[0] ?? {})) : JSON.stringify({
 		sql,
 		total: rows.length,
 		data: rows
-	}, null, 2);
+	}, (_key, value) => typeof value === "bigint" ? value.toString() : value, 2);
 	if (opts.output && opts.output !== "-") {
 		await fs.writeFile(opts.output, payload);
 		if (!opts.quiet) logger.info(`Written to ${opts.output}`);
@@ -524,7 +557,20 @@ function logProfile(spans) {
 	logger.info(`Query timing breakdown:\n${lines.join("\n")}\n${row("total", total)}`);
 }
 async function writeOutput(opts) {
-	const content = opts.format === "csv" ? exportToCSV(opts.output) : JSON.stringify(opts.output, null, 2);
+	const range = asRecord(opts.output.dateRange);
+	const content = opts.format === "table" ? renderQuery({
+		site: String(opts.output.siteUrl),
+		start: String(range.start),
+		end: String(range.end),
+		dimensions: opts.output.dimensions,
+		rows: opts.output.data
+	}, terminalOutputOptions(Boolean(opts.path && opts.path !== "-"))) : opts.format === "csv" ? toCSV(opts.output.data, [
+		...opts.output.dimensions,
+		"clicks",
+		"impressions",
+		"ctr",
+		"position"
+	]) : JSON.stringify(opts.output, null, 2);
 	if (opts.path && opts.path !== "-") {
 		await fs.writeFile(opts.path, content);
 		if (!opts.quiet) logger.info(`Written to ${opts.path}`);

package/dist/commands/report.mjs

@@ -1,11 +1,13 @@
 import { reportCommandMeta } from "../command-meta.mjs";
+import { terminalOutputOptions } from "../render/terminal.mjs";
 import { logger } from "../utils.mjs";
 import { resolveAnalysisSource } from "../analysis-local.mjs";
+import { renderCliReport } from "../render/report.mjs";
 import { defineCommand } from "citty";
 import { defaultAnalyzerRegistry } from "@gscdump/analysis/registry";
-import { err, ok, unwrapResult } from "gscdump/result";
-import { defaultReportRegistry, dryRunReport, formatReport, runReport } from "@gscdump/analysis/report";
 import { resolveWindow } from "@gscdump/engine/period";
+import { err, ok, unwrapResult } from "gscdump/result";
+import { defaultReportRegistry, dryRunReport, runReport } from "@gscdump/analysis/report";
 function reportFlagErrorToException(error) {
 	const exception = new Error(error.message);
 	exception.reportFlagError = error;
@@ -201,7 +203,7 @@ function makeReportCommand(report) {
 				console.log(JSON.stringify(result, null, 2));
 				return;
 			}
-			console.log(formatReport(result));
+			console.log(renderCliReport(result, terminalOutputOptions()));
 			if (result.meta.degraded) logger.warn(`degraded: ${result.meta.steps.filter((s) => s.status === "error").map((s) => `${s.key}(${s.error})`).join(", ")}`);
 		}
 	});

package/dist/commands/sitemaps.mjs

@@ -1,31 +1,36 @@
+import { parseAuthentication, resolveAuthentication } from "../auth-state.mjs";
 import { sitemapsCommandMeta } from "../command-meta.mjs";
 import { resolveCliEnvironment } from "../environment.mjs";
-import { OUTPUT_ARGS, applyOutputMode, logger, noSubcommandSelected } from "../utils.mjs";
+import { OUTPUT_ARGS, applyOutputMode, logger, noSubcommandSelected, parseIntegerOption } from "../utils.mjs";
 import { createCommandContext } from "../context.mjs";
 import { gscErrorHandler } from "../error-handler.mjs";
 import { discoverLiveSitemap, loadSitemapUrls } from "../sitemap.mjs";
 import process from "node:process";
 import { defineCommand } from "citty";
-import { fetchSitemap } from "gscdump/sites";
 import { createGscdumpV1Client } from "@gscdump/sdk/v1";
+import { fetchSitemap } from "gscdump/sites";
 const HOSTED_ARGS = {
 	"api-root": {
 		type: "string",
-		description: "Hosted API root; defaults to GSCDUMP_API_ROOT or https://gscdump.com/api/_gscdump"
+		description: "Hosted API root; defaults to saved cloud authentication or https://gscdump.com/api"
 	},
 	"api-key": {
 		type: "string",
 		description: "Hosted API key; defaults to GSCDUMP_API_KEY"
 	}
 };
-function hostedClient(args) {
+async function hostedClient(args) {
 	const environment = resolveCliEnvironment().values;
-	const apiRoot = String(args["api-root"] || environment.GSCDUMP_API_ROOT || "https://gscdump.com/api/_gscdump");
-	const apiKey = String(args["api-key"] || environment.GSCDUMP_API_KEY || "");
-	if (!apiKey) throw new Error("Hosted sitemap reads require --api-key or GSCDUMP_API_KEY");
+	const authentication = args["api-key"] ? parseAuthentication({
+		_tag: "Cloud",
+		apiKey: args["api-key"],
+		apiRoot: String(args["api-root"] || environment.GSCDUMP_API_ROOT || "https://gscdump.com/api")
+	}) : await resolveAuthentication();
+	if (authentication._tag !== "Cloud") throw new Error("Hosted sitemap reads require cloud authentication. Run `gscdump auth login --mode cloud` or supply --api-key.");
+	if (args["api-root"] && String(args["api-root"]).replace(/\/+$/, "") !== authentication.apiRoot) throw new Error("The API root changed. Supply --api-key explicitly for the new API root.");
 	return createGscdumpV1Client({
-		apiRoot,
-		credential: apiKey
+		apiRoot: authentication.apiRoot,
+		credential: authentication.apiKey
 	});
 }
 const listCommand = defineCommand({
@@ -257,8 +262,8 @@ const urlsCommand = defineCommand({
 	},
 	async run({ args }) {
 		const { json } = applyOutputMode(args);
-		const limit = args.limit ? Number.parseInt(String(args.limit), 10) : void 0;
-		const maxDepth = args["max-depth"] ? Number.parseInt(String(args["max-depth"]), 10) : void 0;
+		const limit = parseIntegerOption(args.limit, "--limit");
+		const maxDepth = parseIntegerOption(args["max-depth"], "--max-depth", 0);
 		const result = await loadSitemapUrls(String(args.url), {
 			maxUrls: limit,
 			maxDepth
@@ -298,7 +303,7 @@ const currentCommand = defineCommand({
 	},
 	async run({ args }) {
 		const { json } = applyOutputMode(args);
-		const result = await hostedClient(args).getSiteSitemaps({ params: { siteId: String(args["site-id"]) } });
+		const result = await (await hostedClient(args)).getSiteSitemaps({ params: { siteId: String(args["site-id"]) } });
 		if (json) {
 			console.log(JSON.stringify(result.data, null, 2));
 			return;
@@ -328,8 +333,8 @@ const historyCommand = defineCommand({
 	},
 	async run({ args }) {
 		const { json } = applyOutputMode(args);
-		const days = args.days ? Number.parseInt(String(args.days), 10) : void 0;
-		const result = await hostedClient(args).getSiteSitemapChanges({
+		const days = parseIntegerOption(args.days, "--days");
+		const result = await (await hostedClient(args)).getSiteSitemapChanges({
 			params: { siteId: String(args["site-id"]) },
 			query: { ...days ? { days } : {} }
 		});
@@ -362,7 +367,7 @@ const membershipCommand = defineCommand({
 	async run({ args }) {
 		const { json } = applyOutputMode(args);
 		const urls = String(args.urls).split(",").map((url) => url.trim()).filter(Boolean);
-		const result = await hostedClient(args).querySitemapMembership({
+		const result = await (await hostedClient(args)).querySitemapMembership({
 			params: { siteId: String(args["site-id"]) },
 			body: {
 				urls,
@@ -411,13 +416,14 @@ const lastmodCommand = defineCommand({
 	},
 	async run({ args }) {
 		const { json } = applyOutputMode(args);
-		const result = await hostedClient(args).listSitemapUrls({
+		const limit = parseIntegerOption(args.limit, "--limit");
+		const result = await (await hostedClient(args)).listSitemapUrls({
 			params: { siteId: String(args["site-id"]) },
 			query: {
 				...args.generation ? { generationId: String(args.generation) } : {},
 				...args.feedpath ? { feedpath: String(args.feedpath) } : {},
 				...args.cursor ? { cursor: String(args.cursor) } : {},
-				...args.limit ? { limit: Number.parseInt(String(args.limit), 10) } : {}
+				...limit !== void 0 ? { limit } : {}
 			}
 		});
 		if (json) {
@@ -452,7 +458,7 @@ const exportCommand = defineCommand({
 	},
 	async run({ args }) {
 		const { json } = applyOutputMode(args);
-		const result = await hostedClient(args).getSitemapExport({
+		const result = await (await hostedClient(args)).getSitemapExport({
 			params: { siteId: String(args["site-id"]) },
 			query: {
 				...args.generation ? { generationId: String(args.generation) } : {},

package/dist/commands/skill.mjs

@@ -0,0 +1,52 @@
+import { skillCommandMeta } from "../command-meta.mjs";
+import { OUTPUT_ARGS, applyOutputMode, displayPath, logger } from "../utils.mjs";
+import { SKILL_AGENTS, SKILL_NAME, installSkill } from "../skill.mjs";
+import process from "node:process";
+import { defineCommand } from "citty";
+import os from "node:os";
+const installCommand = defineCommand({
+	meta: {
+		name: "install",
+		description: `Copy the ${SKILL_NAME} skill into an agent skill directory`
+	},
+	args: {
+		agent: {
+			type: "string",
+			description: `Agent skill directory: ${SKILL_AGENTS.join(" or ")} (default claude)`,
+			default: "claude"
+		},
+		target: {
+			type: "string",
+			description: "Write into this directory instead of the agent home directory"
+		},
+		...OUTPUT_ARGS
+	},
+	async run({ args }) {
+		const { json } = applyOutputMode(args);
+		const agent = SKILL_AGENTS.find((name) => name === args.agent);
+		if (!agent) {
+			logger.error(`Unknown agent "${args.agent}". Use ${SKILL_AGENTS.join(" or ")}.`);
+			process.exit(2);
+		}
+		const result = await installSkill({
+			agent,
+			homeDirectory: os.homedir(),
+			target: args.target
+		});
+		if (result._tag === "Err") {
+			logger.error(result.message);
+			process.exit(1);
+		}
+		if (json) {
+			console.log(JSON.stringify(result.installation));
+			return;
+		}
+		logger.success(`Installed the ${SKILL_NAME} skill for ${agent} at ${displayPath(result.installation.destination)}`);
+		logger.info("Read its SKILL.md before running other commands.");
+	}
+});
+const skillCommand = defineCommand({
+	meta: skillCommandMeta,
+	subCommands: { install: installCommand }
+});
+export { skillCommand };

package/dist/commands/stats.mjs

@@ -1,8 +1,14 @@
+import { terminalOutputOptions } from "../render/terminal.mjs";
 import { OUTPUT_ARGS, applyOutputMode, displayPath, formatAge, logger } from "../utils.mjs";
 import { allTables } from "../local-store.mjs";
 import { createCommandContext } from "../context.mjs";
+import { renderTable, textLines } from "../render/layout.mjs";
+import { formatMetric } from "../render/metrics.mjs";
+import { barColumn } from "../render/charts.mjs";
+import { columnsFor } from "../render/analysis.mjs";
 import process from "node:process";
 import { defineCommand } from "citty";
+import { decodeSiteId, parseGscSiteUrl } from "gscdump";
 import { filesystemStats } from "@gscdump/engine/filesystem";
 const statsCommand = defineCommand({
 	meta: {
@@ -68,33 +74,59 @@ const statsCommand = defineCommand({
 			console.log(JSON.stringify(payload, null, 2));
 			return;
 		}
-		console.log();
-		console.log(`  \x1B[1m${displayPath(store.dataDir)}\x1B[0m`);
-		console.log(`  \x1B[90mDisk: ${disk.files} file(s), ${formatBytes(disk.bytes)}\x1B[0m`);
-		console.log();
-		const totalRows = perTable.reduce((acc, t) => acc + sumRows(t.live), 0);
-		const totalBytes = perTable.reduce((acc, t) => acc + sumBytes(t.live), 0);
-		const totalFiles = perTable.reduce((acc, t) => acc + t.live.length, 0);
-		const totalRetiredFiles = perTable.reduce((acc, t) => acc + t.retired.length, 0);
-		const totalRetiredBytes = perTable.reduce((acc, t) => acc + sumBytes(t.retired), 0);
-		for (const { table, live, retired } of perTable) {
-			const rows = sumRows(live).toLocaleString();
-			const bytes = formatBytes(sumBytes(live));
-			const retiredSuffix = retired.length > 0 ? ` \x1B[90m(+${retired.length} retired, ${formatBytes(sumBytes(retired))})\x1B[0m` : "";
-			console.log(`  ${table.padEnd(15)} \x1B[36m${String(live.length).padStart(4)}\x1B[0m files, ${rows.padStart(10)} rows, ${bytes}${retiredSuffix}`);
-		}
-		console.log();
-		console.log(`  \x1B[1mTotal:\x1B[0m ${totalFiles} files, ${totalRows.toLocaleString()} rows, ${formatBytes(totalBytes)} live`);
-		if (totalRetiredFiles > 0) console.log(`  \x1B[90mRetired: ${totalRetiredFiles} files, ${formatBytes(totalRetiredBytes)} awaiting GC\x1B[0m`);
-		if (watermarks.length > 0) {
-			console.log();
-			console.log(`  \x1B[1mSync watermarks:\x1B[0m`);
-			for (const w of sortWatermarks(watermarks)) {
-				const scope = w.siteId ? `${w.table}@${w.siteId}` : w.table;
-				console.log(`  ${scope.padEnd(24)} \x1B[36m${w.oldestDateSynced}\x1B[0m → \x1B[36m${w.newestDateSynced}\x1B[0m  \x1B[90m(last ${formatAge(w.lastSyncAt)})\x1B[0m`);
+		const options = terminalOutputOptions();
+		const rows = perTable.filter(({ live, retired }) => live.length || retired.length).map(({ table, live, retired }) => ({
+			table,
+			liveFiles: live.length,
+			liveRows: sumRows(live),
+			liveBytes: sumBytes(live),
+			retiredFiles: retired.length,
+			retiredBytes: sumBytes(retired)
+		}));
+		const retired = rows.some((row) => row.retiredFiles > 0);
+		const lines = [
+			...textLines(`Store / ${displayPath(store.dataDir)}`, options, "accent"),
+			...textLines(`Disk ${formatMetric("bytes", disk.bytes)}  ${disk.files} files`, options),
+			"",
+			...rows.length ? renderTable(rows, [
+				{
+					key: "table",
+					label: "Table"
+				},
+				...columnsFor(rows, ["liveFiles", "liveRows"]),
+				barColumn(rows, "liveBytes", options),
+				...retired ? [{
+					key: "retiredFiles",
+					label: "Retired files",
+					numeric: true
+				}, {
+					key: "retiredBytes",
+					label: "Retired bytes",
+					numeric: true,
+					format: (value) => formatMetric("bytes", value)
+				}] : []
+			], options) : textLines("Empty Store.", options)
+		];
+		if (rows.length > 1) lines.push(...textLines(`Total ${formatMetric("bytes", rows.reduce((sum, row) => sum + row.liveBytes, 0))} live`, options, "muted"));
+		if (watermarks.length) lines.push("", ...renderTable(sortWatermarks(watermarks).map((w) => ({
+			scope: w.siteId ? `${w.table}@${parseGscSiteUrl(decodeSiteId(w.siteId)).hostname}` : w.table,
+			dates: `${w.oldestDateSynced} to ${w.newestDateSynced}`,
+			synced: formatAge(w.lastSyncAt)
+		})), [
+			{
+				key: "scope",
+				label: ""
+			},
+			{
+				key: "dates",
+				label: "Dates"
+			},
+			{
+				key: "synced",
+				label: "Synced"
 			}
-		}
-		console.log();
+		], options));
+		console.log(lines.join("\n"));
 	}
 });
 function sortWatermarks(ws) {
@@ -109,10 +141,4 @@ function sumRows(entries) {
 function sumBytes(entries) {
 	return entries.reduce((acc, e) => acc + e.bytes, 0);
 }
-function formatBytes(n) {
-	if (n < 1024) return `${n} B`;
-	if (n < 1048576) return `${(n / 1024).toFixed(1)} KB`;
-	if (n < 1073741824) return `${(n / 1024 / 1024).toFixed(1)} MB`;
-	return `${(n / 1024 / 1024 / 1024).toFixed(2)} GB`;
-}
 export { statsCommand };