@gscdump/cli 3.8.0 → 4.0.1

package/dist/commands/dump.mjs

@@ -1,26 +1,28 @@
 import { dumpCommandMeta } from "../command-meta.mjs";
-import { ALL_SEARCH_TYPES, OUTPUT_ARGS, applyOutputMode, displayPath, logger, parseSearchType, runWithConcurrency, toCSV } from "../utils.mjs";
+import { ALL_SEARCH_TYPES, OUTPUT_ARGS, applyOutputMode, displayPath, logger, parseNameList, parseSearchType } from "../utils.mjs";
 import { allTables } from "../local-store.mjs";
+import { readSiteMap, siteUrlForId } from "../store-sites.mjs";
 import { createCommandContext } from "../context.mjs";
-import { readParquetRows } from "../native-duckdb.mjs";
+import { ENTITY_DATASETS, readEntityDatasets } from "../local-entities.mjs";
+import "../sync-plan.mjs";
+import { nextCommand, readStoreCoverage, renderCoverage } from "../coverage.mjs";
+import { isProcessAlive, readSyncRun, syncRunStatus } from "../sync-run.mjs";
+import { dumpBing } from "../dump-bing.mjs";
+import { groupTableSources } from "../table-sources.mjs";
+import { DUMP_FORMATS, isDumpFormat, openDumpSink } from "../dump-writers.mjs";
 import process from "node:process";
 import { defineCommand } from "citty";
 import fs from "node:fs/promises";
 import path from "node:path";
+import { Buffer } from "node:buffer";
 const DEFAULT_OUT = "./gscdump-export";
-const FORMATS = [
-	"parquet",
-	"json",
-	"ndjson",
-	"csv"
-];
 const dumpCommand = defineCommand({
 	meta: dumpCommandMeta,
 	args: {
 		"site": {
 			type: "string",
 			alias: "s",
-			description: "Site URL (e.g., sc-domain:example.com); ignored with --all-sites"
+			description: "Site, for example example.com; ignored with --all-sites"
 		},
 		"out": {
 			type: "string",
@@ -32,12 +34,16 @@ const dumpCommand = defineCommand({
 			type: "string",
 			alias: "F",
 			default: "parquet",
-			description: `Output format: ${FORMATS.join(", ")} (default: parquet copies raw files)`
+			description: `Output format: ${DUMP_FORMATS.join(", ")} (default: parquet). sqlite and duckdb write one database file`
 		},
 		"tables": {
 			type: "string",
 			alias: "t",
-			description: `Comma-separated table list (default: all). Known: ${allTables().join(", ")}`
+			description: `Comma-separated tables and datasets (default: all). Known: ${[
+				...allTables(),
+				...ENTITY_DATASETS,
+				"bing"
+			].join(", ")}`
 		},
 		"all-sites": {
 			type: "boolean",
@@ -49,6 +55,12 @@ const dumpCommand = defineCommand({
 			default: false,
 			description: "Compact every closed month into a single file before exporting"
 		},
+		"bing": {
+			type: "boolean",
+			default: true,
+			description: "Also export Bing data for matching sites when a Bing login exists",
+			negativeDescription: "Skip Bing"
+		},
 		"search-type": {
 			type: "string",
 			description: `Restrict dump to a single GSC search-type slice (${ALL_SEARCH_TYPES.join(", ")}). Default: all slices.`
@@ -58,26 +70,28 @@ const dumpCommand = defineCommand({
 	async run({ args }) {
 		const { json, quiet } = applyOutputMode(args);
 		const format = String(args.format);
-		if (!FORMATS.includes(format)) {
-			logger.error(`Invalid --format: ${format}. Allowed: ${FORMATS.join(", ")}`);
+		if (!isDumpFormat(format)) {
+			logger.error(`Invalid --format: ${format}. Allowed: ${DUMP_FORMATS.join(", ")}`);
 			process.exit(1);
 		}
-		const tablesFilter = args.tables ? new Set(String(args.tables).split(",").map((t) => t.trim()).filter(Boolean)) : null;
+		const tablesFilter = args.tables ? new Set(parseNameList(args.tables, [
+			...allTables(),
+			...ENTITY_DATASETS,
+			"bing"
+		], "--tables")) : null;
 		const searchType = parseSearchType(args["search-type"]);
-		const ctx = await createCommandContext({
-			needsAuth: !args["all-sites"],
-			needsStore: true
-		});
+		const ctx = await createCommandContext({ needsStore: true });
 		const store = ctx.store;
 		const outDir = path.resolve(String(args.out));
+		const siteMap = await readSiteMap(store.dataDir, store.userId);
 		let preloadedEntries = args["all-sites"] ? await store.engine.listLive({
 			userId: store.userId,
 			...searchType !== void 0 ? { searchType } : {}
 		}) : void 0;
 		const targets = args["all-sites"] ? [...new Set(preloadedEntries.flatMap((entry) => entry.siteId ? [entry.siteId] : []))].map((siteId) => ({
-			site: siteId,
+			site: siteUrlForId(siteMap, siteId),
 			siteId
-		})) : await ctx.resolveSite(args.site ? String(args.site) : void 0).then((site) => [{
+		})) : await ctx.resolveSite(args.site ? String(args.site) : void 0, { scope: "store" }).then((site) => [{
 			site,
 			siteId: store.siteIdFor(site)
 		}]);
@@ -92,105 +106,189 @@ const dumpCommand = defineCommand({
 				...searchType !== void 0 ? { searchType } : {}
 			});
 		}
-		const summary = [];
-		for (const target of targets) {
-			const entries = (preloadedEntries ? preloadedEntries.filter((entry) => entry.siteId === target.siteId) : await listLiveEntries(store, target.siteId, searchType)).filter((e) => !tablesFilter || tablesFilter.has(e.table));
-			if (entries.length === 0) {
-				if (!quiet) logger.warn(`No data for ${target.site}; skipping`);
-				continue;
-			}
-			if (format === "parquet") {
-				const written = await dumpParquet(store, entries, outDir);
-				summary.push({
-					site: target.site,
-					files: written,
-					rows: 0,
-					format,
-					outPath: outDir
-				});
-			} else {
-				const written = await dumpRowFormat(store, entries, outDir, target.site, format);
-				summary.push({
-					site: target.site,
-					files: written.files,
-					rows: written.rows,
-					format,
-					outPath: outDir
-				});
-			}
-		}
+		const bing = args.bing === false || tablesFilter && !tablesFilter.has("bing") ? { _tag: "disabled" } : await dumpBing({
+			googleSites: args["all-sites"] ? "all" : targets.map((target) => target.site),
+			outDir,
+			format
+		}).catch((error) => ({
+			_tag: "failed",
+			reason: error instanceof Error ? error.message : String(error)
+		}));
+		const result = await dumpSites({
+			store,
+			targets,
+			outDir,
+			format,
+			...tablesFilter ? { tables: tablesFilter } : {},
+			...searchType !== void 0 ? { searchType } : {},
+			...preloadedEntries ? { entries: preloadedEntries } : {},
+			bing
+		});
 		if (json) {
 			console.log(JSON.stringify({
-				outDir,
-				sites: summary
+				...result,
+				bing
 			}, null, 2));
 			return;
 		}
-		for (const s of summary) {
-			const rows = s.rows ? `, ${s.rows.toLocaleString()} rows` : "";
-			logger.success(`[${s.site}] ${s.files} ${s.format} file(s)${rows} → ${displayPath(s.outPath)}`);
+		const bytesByPath = new Map(result.files.map((file) => [file.path, file.bytes]));
+		const database = format === "sqlite" || format === "duckdb";
+		if (database && result.sites.some((site) => site.datasets.length > 0)) {
+			const file = result.files[0];
+			logger.success(`Wrote ${displayPath(file.path)} (${formatBytes(file.bytes)})`);
+		}
+		for (const site of result.sites) {
+			if (site.datasets.length === 0) {
+				if (!quiet) logger.warn(`No data for ${site.site}; skipping`);
+				continue;
+			}
+			logger.success(`[${site.site}] ${site.totals.datasets} dataset(s), ${site.totals.rows.toLocaleString()} rows`);
+			if (quiet) continue;
+			for (const dataset of site.datasets) {
+				const label = database ? `${dataset.dataset}${dataset.searchType ? ` (search_type = ${dataset.searchType})` : ""}` : `${path.relative(outDir, dataset.path)}  ${formatBytes(bytesByPath.get(dataset.path) ?? 0)}`;
+				console.log(`  ${label}  ${dataset.rows.toLocaleString()} rows`);
+			}
+			for (const skip of site.skipped) console.log(`  \x1B[90m${skip.dataset}: no rows yet; skipped\x1B[0m`);
+			for (const line of renderCoverage(site.coverage)) console.log(`  ${line}`);
+			for (const job of site.coverage.analytics) if (job.coverage.kind === "partial" && job.coverage.failed > 0) logger.warn(`${site.site} ${job.table} (${job.searchType}): ${job.coverage.failed} failed date(s). Run ${nextCommand(site.coverage)} to retry them.`);
 		}
+		if (bing._tag === "dumped") {
+			for (const site of bing.sites) {
+				const bytes = site.files.reduce((sum, file) => sum + file.bytes, 0);
+				logger.success(`[Bing ${site.siteUrl}] ${site.files.length} file(s), ${formatBytes(bytes)}`);
+				if (!quiet) for (const file of site.files) console.log(`  ${path.relative(outDir, file.path)}  ${formatBytes(file.bytes)}  ${file.rows.toLocaleString()} rows`);
+			}
+			for (const failure of bing.failures) logger.warn(`Bing ${failure.siteUrl} not exported: ${failure.error}`);
+		} else if (bing._tag === "failed") logger.warn(`Bing not exported: ${bing.reason}`);
+		else if (bing._tag === "skipped" && !quiet) logger.info(`Bing skipped: ${bing.reason}`);
+		if (!quiet) for (const file of result.metadataFiles) console.log(`  ${path.relative(outDir, file.path)}  ${formatBytes(file.bytes)}`);
 	}
 });
-async function listLiveEntries(store, siteId, searchType) {
-	return store.engine.listLive({
-		userId: store.userId,
-		siteId,
-		...searchType !== void 0 ? { searchType } : {}
-	});
-}
-async function dumpParquet(store, entries, outDir) {
-	await fs.mkdir(outDir, { recursive: true });
-	const readyDirectories = /* @__PURE__ */ new Map();
-	async function ensureDirectory(dir) {
-		let ready = readyDirectories.get(dir);
-		if (!ready) {
-			ready = fs.mkdir(dir, { recursive: true }).then(() => void 0);
-			readyDirectories.set(dir, ready);
-			ready.catch(() => readyDirectories.delete(dir));
-		}
-		await ready;
+function formatBytes(bytes) {
+	if (bytes < 1024) return `${bytes} B`;
+	const units = [
+		"KB",
+		"MB",
+		"GB",
+		"TB"
+	];
+	let value = bytes / 1024;
+	let unit = 0;
+	while (value >= 1024 && unit < units.length - 1) {
+		value /= 1024;
+		unit++;
 	}
-	let copied = 0;
-	await runWithConcurrency(entries, 8, async (entry) => {
-		const bytes = await store.engine.readObject(entry.objectKey);
-		const target = path.join(outDir, entry.objectKey);
-		await ensureDirectory(path.dirname(target));
-		await fs.writeFile(target, bytes);
-		copied++;
+	return `${value.toFixed(value >= 100 ? 0 : 1)} ${units[unit]}`;
+}
+async function dumpSites(opts) {
+	const { outDir, format } = opts;
+	const sink = await openDumpSink(outDir, format);
+	const summary = await dumpEachSite(sink, opts).catch(async (error) => {
+		await sink.close();
+		throw error;
 	});
-	return copied;
+	const files = await sink.close();
+	const metadataFiles = [];
+	const sites = opts.targets.map((target) => ({
+		siteUrl: target.site,
+		siteId: target.siteId
+	}));
+	metadataFiles.push(await writeJsonFile(path.join(outDir, "sites.json"), { sites }));
+	metadataFiles.push(await writeJsonFile(path.join(outDir, "manifest.json"), {
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		format,
+		files: files.map((file) => ({
+			...file,
+			path: path.relative(outDir, file.path)
+		})),
+		sites: summary.map((site) => ({
+			...site,
+			datasets: site.datasets.map((dataset) => ({
+				...dataset,
+				path: path.relative(outDir, dataset.path)
+			}))
+		})),
+		...opts.bing ? { bing: manifestBing(opts.bing, outDir) } : {}
+	}));
+	return {
+		outDir,
+		format,
+		files,
+		metadataFiles,
+		sites: summary
+	};
 }
-async function dumpRowFormat(store, entries, outDir, siteUrl, format) {
-	const byTable = /* @__PURE__ */ new Map();
-	for (const e of entries) {
-		const arr = byTable.get(e.table) ?? [];
-		arr.push(e);
-		byTable.set(e.table, arr);
-	}
-	const safeSite = siteUrl.replace(/[^a-z0-9]+/gi, "_");
-	const siteDir = path.join(outDir, safeSite);
-	await fs.mkdir(siteDir, { recursive: true });
-	let files = 0;
-	let totalRows = 0;
-	for (const [table, tableEntries] of byTable) {
-		const filePaths = tableEntries.map((e) => path.join(store.dataDir, e.objectKey));
-		const rows = await readParquetRows(filePaths, table);
-		const ext = format === "csv" ? "csv" : format === "ndjson" ? "ndjson" : "json";
-		const target = path.join(siteDir, `${table}.${ext}`);
-		let body;
-		if (format === "json") body = JSON.stringify(rows, null, 2);
-		else if (format === "ndjson") body = rows.map((r) => JSON.stringify(r)).join("\n");
-		else body = rows.length > 0 ? toCSV(rows, Object.keys(rows[0])) : "";
-		await fs.writeFile(target, body);
-		files++;
-		totalRows += rows.length;
+async function dumpEachSite(sink, opts) {
+	const { store, tables } = opts;
+	const wantedEntities = ENTITY_DATASETS.filter((dataset) => !tables || tables.has(dataset));
+	const summary = [];
+	for (const target of opts.targets) {
+		const entries = (opts.entries ? opts.entries.filter((entry) => entry.siteId === target.siteId) : await listLiveEntries(store, target.siteId, opts.searchType)).filter((e) => !tables || tables.has(e.table));
+		const datasets = [];
+		for (const source of groupTableSources(entries, store.dataDir, { [target.siteId]: target.site })) datasets.push(await sink.writeTable(source));
+		const skipped = [];
+		for (const dataset of await readEntityDatasets(store.dataSource, {
+			userId: store.userId,
+			siteId: target.siteId
+		}, wantedEntities)) if (dataset.rows.length === 0) skipped.push({
+			dataset: dataset.dataset,
+			reason: "empty"
+		});
+		else datasets.push(await sink.writeEntity(target.site, dataset));
+		summary.push({
+			site: target.site,
+			siteId: target.siteId,
+			coverage: await readDumpCoverage(store, target.site),
+			datasets,
+			skipped,
+			totals: {
+				datasets: datasets.length,
+				rows: datasets.reduce((sum, dataset) => sum + dataset.rows, 0)
+			}
+		});
 	}
+	return summary;
+}
+function manifestBing(step, outDir) {
+	if (step._tag !== "dumped") return step;
 	return {
-		files,
-		rows: totalRows
+		...step,
+		sites: step.sites.map((site) => ({
+			siteUrl: site.siteUrl,
+			files: site.files.map((file) => ({
+				...file,
+				path: path.relative(outDir, file.path)
+			}))
+		}))
+	};
+}
+async function writeJsonFile(target, value) {
+	const body = `${JSON.stringify(value, null, 2)}\n`;
+	await fs.writeFile(target, body);
+	return {
+		path: target,
+		bytes: Buffer.byteLength(body)
 	};
 }
+async function readDumpCoverage(store, site) {
+	const run = syncRunStatus(await readSyncRun(store.dataDir), {
+		now: Date.now(),
+		isAlive: isProcessAlive
+	});
+	return readStoreCoverage({
+		store,
+		site,
+		inspectLimit: 50,
+		run
+	});
+}
+async function listLiveEntries(store, siteId, searchType) {
+	return store.engine.listLive({
+		userId: store.userId,
+		siteId,
+		...searchType !== void 0 ? { searchType } : {}
+	});
+}
 async function compactClosedMonths(store, siteId, quiet) {
 	for (const table of allTables()) {
 		if (!quiet) logger.info(`Compacting ${table} (raw→d7→d30→d90)`);
@@ -201,4 +299,4 @@ async function compactClosedMonths(store, siteId, quiet) {
 		});
 	}
 }
-export { dumpCommand };
+export { dumpCommand, dumpSites, formatBytes };

package/dist/commands/entities.mjs

@@ -1,12 +1,12 @@
 import { entitiesCommandMeta } from "../command-meta.mjs";
 import { OUTPUT_ARGS, applyOutputMode, logger, parseIntegerOption, progressBar, runWithConcurrency } from "../utils.mjs";
+import { formatSiteIdCollision, recordStoreSite } from "../store-sites.mjs";
 import { createCommandContext } from "../context.mjs";
 import process from "node:process";
 import { defineCommand } from "citty";
 import { readFile } from "node:fs/promises";
 import { Buffer } from "node:buffer";
 import { createIndexingMetadataStore, createInspectionStore } from "@gscdump/engine/entities";
-const INSPECTION_QPD_PER_PROPERTY = 2e3;
 const INDEXING_NOT_FOUND_RE = /\b404\b|NOT_FOUND/i;
 const INSPECTION_HISTORY_LOOKBACK_MONTHS = 24;
 async function findLatestInspection(inspector, ctx, url) {
@@ -28,110 +28,6 @@ async function readUrlList(opts) {
 	for await (const chunk of process.stdin) chunks.push(chunk);
 	return Buffer.concat(chunks).toString("utf8").split("\n").map((l) => l.trim()).filter(Boolean);
 }
-const inspectSubCommand = defineCommand({
-	meta: {
-		name: "inspect",
-		description: "Run URL Inspection for a list of URLs and persist results to the local entity store"
-	},
-	args: {
-		site: {
-			type: "string",
-			alias: "s",
-			description: "Site URL (e.g., sc-domain:example.com); defaults to config.defaultSite or prompt"
-		},
-		file: {
-			type: "string",
-			alias: "f",
-			description: "Path to a file with one URL per line. If omitted, reads from stdin."
-		},
-		limit: {
-			type: "string",
-			description: `Max URLs to inspect this run (default: ${INSPECTION_QPD_PER_PROPERTY}, the per-property GSC daily quota)`
-		},
-		concurrency: {
-			type: "string",
-			alias: "c",
-			default: "4",
-			description: "Concurrent in-flight inspect calls (default: 4)"
-		},
-		...OUTPUT_ARGS
-	},
-	async run({ args }) {
-		const { json, quiet } = applyOutputMode(args);
-		const limit = parseIntegerOption(args.limit, "--limit") ?? INSPECTION_QPD_PER_PROPERTY;
-		const concurrency = parseIntegerOption(args.concurrency, "--concurrency") ?? 4;
-		const ctx = await createCommandContext({
-			needsAuth: true,
-			needsStore: true
-		});
-		const client = ctx.client;
-		const store = ctx.store;
-		const siteUrl = await ctx.resolveSite(args.site ? String(args.site) : void 0);
-		const urls = (await readUrlList({ file: args.file ? String(args.file) : void 0 })).slice(0, limit);
-		if (urls.length === 0) {
-			logger.warn("No URLs to inspect.");
-			return;
-		}
-		if (urls.length === limit && limit < INSPECTION_QPD_PER_PROPERTY) logger.info(`Capping at --limit ${limit}`);
-		if (urls.length === INSPECTION_QPD_PER_PROPERTY) logger.info(`Hit per-property daily inspection quota (${INSPECTION_QPD_PER_PROPERTY}); remaining URLs will be queued for tomorrow.`);
-		const inspector = createInspectionStore({ dataSource: store.dataSource });
-		let completed = 0;
-		let failed = 0;
-		const records = [];
-		const failures = [];
-		await runWithConcurrency(urls, concurrency, async (url) => {
-			const result = await client.inspect(siteUrl, url).catch((err) => err);
-			if (result instanceof Error) {
-				failed++;
-				failures.push({
-					url,
-					error: result.message
-				});
-			} else {
-				const ix = result.inspectionResult;
-				const indexStatus = ix?.indexStatusResult;
-				records.push({
-					url,
-					inspectedAt: (/* @__PURE__ */ new Date()).toISOString(),
-					indexStatus: indexStatus?.verdict ?? void 0,
-					lastCrawlTime: indexStatus?.lastCrawlTime ?? void 0,
-					googleCanonical: indexStatus?.googleCanonical ?? void 0,
-					userCanonical: indexStatus?.userCanonical ?? void 0,
-					coverageState: indexStatus?.coverageState ?? void 0,
-					robotsTxtState: indexStatus?.robotsTxtState ?? void 0,
-					indexingState: indexStatus?.indexingState ?? void 0,
-					pageFetchState: indexStatus?.pageFetchState ?? void 0,
-					mobileUsabilityVerdict: ix?.mobileUsabilityResult?.verdict ?? void 0,
-					richResultsVerdict: ix?.richResultsResult?.verdict ?? void 0,
-					raw: ix
-				});
-			}
-			completed++;
-			if (!quiet) process.stdout.write(`\r${progressBar(completed, urls.length, `${url.slice(0, 60)}`)}`);
-		});
-		if (!quiet) process.stdout.write("\n");
-		await inspector.appendHistory({
-			userId: store.userId,
-			siteId: store.siteIdFor(siteUrl)
-		}, records);
-		if (json) console.log(JSON.stringify({
-			site: siteUrl,
-			inspected: records.length,
-			failed,
-			failures,
-			records
-		}, null, 2));
-		else if (!quiet) {
-			logger.success(`Inspected ${records.length}/${urls.length} URL(s)`);
-			if (failed > 0) {
-				logger.warn(`${failed} failed:`);
-				for (const f of failures.slice(0, 5)) console.log(`  ${f.url}: ${f.error}`);
-				if (failures.length > 5) console.log(`  ... and ${failures.length - 5} more`);
-			}
-		}
-		if (failed > 0) process.exit(1);
-	}
-});
 const showSubCommand = defineCommand({
 	meta: {
 		name: "show",
@@ -142,7 +38,7 @@ const showSubCommand = defineCommand({
 		site: {
 			type: "string",
 			alias: "s",
-			description: "Site URL (defaults to config.defaultSite or prompt)"
+			description: "Site, for example example.com; defaults to config.defaultSite or a prompt"
 		},
 		url: {
 			type: "positional",
@@ -152,12 +48,9 @@ const showSubCommand = defineCommand({
 	},
 	async run({ args }) {
 		const { json } = applyOutputMode(args);
-		const ctx = await createCommandContext({
-			needsAuth: true,
-			needsStore: true
-		});
+		const ctx = await createCommandContext({ needsStore: true });
 		const store = ctx.store;
-		const siteUrl = await ctx.resolveSite(args.site ? String(args.site) : void 0);
+		const siteUrl = await ctx.resolveSite(args.site ? String(args.site) : void 0, { scope: "store" });
 		const record = await findLatestInspection(createInspectionStore({ dataSource: store.dataSource }), {
 			userId: store.userId,
 			siteId: store.siteIdFor(siteUrl)
@@ -190,7 +83,7 @@ const indexingSnapshotSubCommand = defineCommand({
 		site: {
 			type: "string",
 			alias: "s",
-			description: "Site URL (e.g., sc-domain:example.com); defaults to config.defaultSite or prompt"
+			description: "Site, for example example.com; defaults to config.defaultSite or a prompt"
 		},
 		file: {
 			type: "string",
@@ -220,6 +113,11 @@ const indexingSnapshotSubCommand = defineCommand({
 			logger.warn("No URLs to fetch metadata for.");
 			return;
 		}
+		const claim = await recordStoreSite(store.dataDir, siteUrl, { userId: store.userId });
+		if (!claim.ok) {
+			logger.error(formatSiteIdCollision(claim.error));
+			process.exit(1);
+		}
 		const records = [];
 		const failures = [];
 		let completed = 0;
@@ -270,7 +168,6 @@ const indexingSubCommand = defineCommand({
 const entitiesCommand = defineCommand({
 	meta: entitiesCommandMeta,
 	subCommands: {
-		inspect: inspectSubCommand,
 		show: showSubCommand,
 		indexing: indexingSubCommand
 	}

package/dist/commands/gc.mjs

@@ -16,7 +16,7 @@ const gcCommand = defineCommand({
 		"site": {
 			type: "string",
 			alias: "s",
-			description: "Restrict to a single site (default: all sites)"
+			description: "Restrict to one Site, for example example.com (default: every Site)"
 		},
 		"dry-run": {
 			type: "boolean",
@@ -27,8 +27,9 @@ const gcCommand = defineCommand({
 	},
 	async run({ args }) {
 		const { json } = applyOutputMode(args);
-		const store = (await createCommandContext({ needsStore: true })).store;
-		const siteId = args.site ? store.siteIdFor(String(args.site)) : void 0;
+		const ctx = await createCommandContext({ needsStore: true });
+		const store = ctx.store;
+		const siteId = args.site ? store.siteIdFor(await ctx.resolveSite(String(args.site), { scope: "store" })) : void 0;
 		const graceMs = Number(args["grace-hours"]) * 36e5;
 		if (args["dry-run"]) {
 			const cutoff = Date.now() - graceMs;