@gscdump/cli 0.37.3 → 0.37.5

package/dist/_chunks/auth2.mjs

@@ -0,0 +1,293 @@
+import { loadConfig, saveConfig } from "./config.mjs";
+import { OUTPUT_ARGS, applyOutputMode, logger, noSubcommandSelected } from "./utils.mjs";
+import { adoptCurrentConfigAsProfile, profileNameFromEmail, resolveActiveProfile } from "./profile.mjs";
+import { authenticate, clearTokens, formatAuthProvenance, getAuth, getAuthCredentials, loadServiceAccount, loadTokens, resolveBYOK, saveTokens } from "./auth.mjs";
+import { runSmokeTest } from "./init.mjs";
+import process from "node:process";
+import { defineCommand } from "citty";
+import path from "node:path";
+import { hasGscWriteScope, hasIndexingScope } from "gscdump/api";
+import { ofetch } from "ofetch";
+const AUTH_SUBCOMMANDS = [
+	"status",
+	"login",
+	"logout",
+	"refresh",
+	"scopes"
+];
+const REQUIRED_SCOPES = [
+	"https://www.googleapis.com/auth/webmasters",
+	"https://www.googleapis.com/auth/indexing",
+	"https://www.googleapis.com/auth/siteverification"
+];
+function hasGoogleScope(scopes, scope) {
+	const suffix = scope.replace("https://www.googleapis.com/auth/", "");
+	return scopes.includes(scope) || scopes.includes(suffix);
+}
+function missingRequiredScopes(scopes) {
+	return REQUIRED_SCOPES.filter((scope) => {
+		if (scope.endsWith("/webmasters")) return !hasGscWriteScope(scopes);
+		if (scope.endsWith("/indexing")) return !hasIndexingScope(scopes);
+		return !hasGoogleScope(scopes, scope);
+	});
+}
+async function fetchTokenInfo(accessToken) {
+	return ofetch("https://oauth2.googleapis.com/tokeninfo", { query: { access_token: accessToken } }).catch(() => null);
+}
+async function resolveLiveAuthState() {
+	const tokens = await loadTokens();
+	const byok = resolveBYOK();
+	let liveToken = null;
+	if (typeof byok === "string") liveToken = byok;
+	else if (byok && "getAccessToken" in byok) liveToken = await byok.getAccessToken().then((r) => r.token ?? null).catch(() => null);
+	else if (tokens?.access_token) liveToken = tokens.access_token;
+	const tokenInfo = liveToken ? await fetchTokenInfo(liveToken) : null;
+	const scopes = tokenInfo?.scope ? tokenInfo.scope.split(/\s+/).filter(Boolean) : [];
+	const missing = missingRequiredScopes(scopes);
+	return {
+		byok,
+		tokens,
+		liveToken,
+		tokenInfo,
+		scopes,
+		missing
+	};
+}
+async function runStatus(args) {
+	const { json } = applyOutputMode(args);
+	const { byok, tokens, tokenInfo, scopes, missing } = await resolveLiveAuthState();
+	const byokKind = byok ? typeof byok === "string" ? "access-token" : "refresh-token" : null;
+	if (json) {
+		console.log(JSON.stringify({
+			authenticated: !!tokens || !!byok,
+			source: byok ? "byok" : tokens ? "saved-tokens" : null,
+			byokKind,
+			scopes,
+			tokenAccount: tokenInfo?.email ?? null,
+			tokens: tokens ? {
+				hasAccessToken: !!tokens.access_token,
+				hasRefreshToken: !!tokens.refresh_token,
+				expiry: tokens.expiry_date ? new Date(tokens.expiry_date).toISOString() : null,
+				expired: tokens.expiry_date ? tokens.expiry_date < Date.now() : null
+			} : null
+		}, null, 2));
+		return;
+	}
+	const reportScopes = () => {
+		if (scopes.length === 0) return;
+		console.log(`  Scopes:`);
+		for (const s of scopes) console.log(`    \x1B[90m└─\x1B[0m ${s}`);
+		if (missing.length > 0) {
+			console.log(`  \x1B[33mMissing scopes:\x1B[0m`);
+			for (const s of missing) console.log(`    \x1B[90m└─\x1B[0m ${s}`);
+			console.log(`  \x1B[90mRun \`gscdump auth login --force\` to re-consent.\x1B[0m`);
+		}
+	};
+	if (byok) {
+		logger.success(`Authenticated via BYOK (${byokKind})`);
+		if (tokenInfo?.email) console.log(`  Account:       ${tokenInfo.email}`);
+		reportScopes();
+		return;
+	}
+	if (!tokens) {
+		logger.warn("Not authenticated");
+		logger.info("Run `gscdump init` (full setup) or `gscdump auth login` (OAuth only)");
+		logger.info("Or set GSC_ACCESS_TOKEN / GSC_CLIENT_ID + GSC_CLIENT_SECRET + GSC_REFRESH_TOKEN env vars");
+		return;
+	}
+	const hasAccess = !!tokens.access_token;
+	const hasRefresh = !!tokens.refresh_token;
+	const expiry = tokens.expiry_date ? new Date(tokens.expiry_date) : null;
+	const isExpired = expiry && expiry < /* @__PURE__ */ new Date();
+	if (isExpired && hasRefresh) logger.warn("Token expired; refresh available. Run `gscdump auth refresh`, or any live command will auto-refresh.");
+	else if (isExpired) logger.error("Token expired and no refresh token present. Run `gscdump auth login`.");
+	else logger.success("Authenticated (saved tokens)");
+	console.log();
+	console.log(`  Access token:  ${hasAccess ? "\x1B[32mpresent\x1B[0m" : "\x1B[31mmissing\x1B[0m"}`);
+	console.log(`  Refresh token: ${hasRefresh ? "\x1B[32mpresent\x1B[0m" : "\x1B[31mmissing\x1B[0m"}`);
+	if (expiry) {
+		const status = isExpired ? "\x1B[33mexpired\x1B[0m" : "\x1B[32mvalid\x1B[0m";
+		console.log(`  Expires:       ${expiry.toISOString()} (${status})`);
+	}
+	if (tokenInfo?.email) console.log(`  Account:       ${tokenInfo.email}`);
+	reportScopes();
+	if (isExpired && !hasRefresh) process.exit(1);
+}
+const statusCommand = defineCommand({
+	meta: {
+		name: "status",
+		description: "Show current authentication status"
+	},
+	args: { ...OUTPUT_ARGS },
+	async run({ args }) {
+		await runStatus(args);
+	}
+});
+const refreshCommand = defineCommand({
+	meta: {
+		name: "refresh",
+		description: "Force-refresh saved OAuth tokens (no-op for BYOK)"
+	},
+	args: { ...OUTPUT_ARGS },
+	async run({ args }) {
+		applyOutputMode(args);
+		if (resolveBYOK()) {
+			logger.info("BYOK detected; refresh handled per-call by the SDK");
+			return;
+		}
+		const tokens = await loadTokens();
+		if (!tokens?.refresh_token) {
+			logger.error("No saved refresh token. Run `gscdump auth login`.");
+			process.exit(1);
+		}
+		const credentials = await getAuthCredentials(false).catch((e) => {
+			logger.error(`Cannot resolve credentials: ${e.message}`);
+			process.exit(1);
+		});
+		await saveTokens({
+			...tokens,
+			expiry_date: 1
+		});
+		if ((await authenticate(credentials, false).catch((e) => {
+			logger.error(`Refresh failed: ${e.message}`);
+			process.exit(1);
+		})).credentials?.access_token) logger.success("Token refreshed");
+		else logger.warn("Refresh completed but no new access token returned");
+	}
+});
+const loginCommand = defineCommand({
+	meta: {
+		name: "login",
+		description: "Run OAuth flow and persist tokens (skip if BYOK env vars set)"
+	},
+	args: {
+		...OUTPUT_ARGS,
+		"force": {
+			type: "boolean",
+			alias: "f",
+			default: false,
+			description: "Re-run OAuth even if tokens already exist"
+		},
+		"browser": {
+			type: "boolean",
+			default: true,
+			description: "Use loopback browser flow. Pass --no-browser for device-code (headless)."
+		},
+		"service-account": {
+			type: "string",
+			description: "Path to a service-account JSON key (skips OAuth)"
+		}
+	},
+	async run({ args }) {
+		applyOutputMode(args);
+		if (resolveBYOK() && !args.force) {
+			logger.info("BYOK env vars detected, no login needed (--force to override)");
+			return;
+		}
+		if (args["service-account"]) {
+			const saPath = path.resolve(String(args["service-account"]));
+			const jwt = await loadServiceAccount(saPath).catch((e) => {
+				logger.error(`Service-account load failed: ${e.message}`);
+				process.exit(1);
+			});
+			await jwt.authorize().catch((e) => {
+				logger.error(`Service-account auth failed: ${e.message}`);
+				process.exit(1);
+			});
+			const config = await loadConfig();
+			config.serviceAccountPath = saPath;
+			await saveConfig(config);
+			logger.success(`Service-account verified: ${jwt.email ?? "OK"}`);
+			logger.info(`Saved path to config: ${saPath}`);
+			return;
+		}
+		if (args.force) await clearTokens();
+		const oauth = await getAuth({
+			interactive: true,
+			noBrowser: args.browser === false,
+			force: Boolean(args.force)
+		}).catch((e) => {
+			logger.error(`Login failed: ${e.message}`);
+			process.exit(1);
+		});
+		logger.success("Logged in");
+		await runSmokeTest(oauth);
+		if (!resolveActiveProfile()) {
+			const tokens = await loadTokens();
+			const info = tokens?.access_token ? await fetchTokenInfo(tokens.access_token) : null;
+			if (info?.email) {
+				const name = profileNameFromEmail(info.email);
+				if (await adoptCurrentConfigAsProfile(name).catch((error) => {
+					const message = error instanceof Error ? error.message : String(error);
+					logger.warn(`Login succeeded, but the config could not be moved into profile "${name}": ${message}`);
+					return null;
+				})) logger.success(`Saved as profile "${name}" (active)`);
+			}
+		}
+		if (resolveBYOK()) {
+			console.log();
+			console.log(await formatAuthProvenance());
+		}
+	}
+});
+const logoutCommand = defineCommand({
+	meta: {
+		name: "logout",
+		description: "Clear stored OAuth tokens"
+	},
+	args: { ...OUTPUT_ARGS },
+	async run({ args }) {
+		applyOutputMode(args);
+		await clearTokens();
+		const config = await loadConfig();
+		if (config.serviceAccountPath) {
+			delete config.serviceAccountPath;
+			await saveConfig(config);
+			logger.info("Cleared saved service-account path");
+		}
+	}
+});
+const scopesCommand = defineCommand({
+	meta: {
+		name: "scopes",
+		description: "Print granted OAuth scopes (one per line); exits 1 if any required scope is missing"
+	},
+	args: { ...OUTPUT_ARGS },
+	async run({ args }) {
+		const { json } = applyOutputMode(args);
+		const { liveToken, scopes, missing } = await resolveLiveAuthState();
+		if (!liveToken) {
+			if (json) console.log(JSON.stringify({
+				scopes: [],
+				missing: null
+			}, null, 2));
+			else logger.error("Not authenticated");
+			process.exit(1);
+		}
+		if (json) console.log(JSON.stringify({
+			scopes,
+			missing
+		}, null, 2));
+		else for (const s of scopes) console.log(s);
+		if (missing.length > 0) process.exit(1);
+	}
+});
+const authCommand = defineCommand({
+	meta: {
+		name: "auth",
+		description: "Manage authentication"
+	},
+	args: { ...OUTPUT_ARGS },
+	subCommands: {
+		status: statusCommand,
+		login: loginCommand,
+		logout: logoutCommand,
+		refresh: refreshCommand,
+		scopes: scopesCommand
+	},
+	async run({ args }) {
+		if (!noSubcommandSelected("auth", AUTH_SUBCOMMANDS)) return;
+		await runStatus(args);
+	}
+});
+export { authCommand, loginCommand, logoutCommand, statusCommand };

package/dist/_chunks/config.mjs

@@ -0,0 +1,93 @@
+import process from "node:process";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createConsola } from "consola";
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+const runtimeStorage = new AsyncLocalStorage();
+let fallbackRuntime;
+function createCliRuntime(opts = {}) {
+	const stderr = opts.stderr ?? process.stderr;
+	const baseLogger = createConsola({
+		stdout: stderr,
+		stderr
+	});
+	return {
+		activeProfileOverride: null,
+		colorEnabled: true,
+		configDir: opts.configDir ?? path.join(os.homedir(), ".config", "gscdump"),
+		configDirOverridden: false,
+		environment: opts.environment ?? process.env,
+		logger: baseLogger.withTag("gscdump"),
+		quiet: false,
+		rawArgs: [...opts.rawArgs ?? process.argv.slice(2)]
+	};
+}
+function useCliRuntime() {
+	const active = runtimeStorage.getStore();
+	if (active) return active;
+	fallbackRuntime ??= createCliRuntime();
+	return fallbackRuntime;
+}
+function runWithCliRuntime(runtime, run) {
+	return runtimeStorage.run(runtime, run);
+}
+var config_exports = /* @__PURE__ */ __exportAll({
+	defaultDataDir: () => defaultDataDir,
+	getConfigDir: () => getConfigDir,
+	getConfigPath: () => getConfigPath,
+	loadConfig: () => loadConfig,
+	loadResolvedConfig: () => loadResolvedConfig,
+	resolveDataDir: () => resolveDataDir,
+	saveConfig: () => saveConfig,
+	setConfigDir: () => setConfigDir
+});
+function setConfigDir(dir) {
+	useCliRuntime().configDir = dir;
+}
+function getConfigDir() {
+	return useCliRuntime().configDir;
+}
+function defaultDataDir() {
+	return path.join(os.homedir(), ".gscdump", "data");
+}
+function resolveDataDir(config) {
+	return expandTilde(config.dataDir ?? defaultDataDir());
+}
+function expandTilde(p) {
+	if (p === "~") return os.homedir();
+	if (p.startsWith("~/")) return path.join(os.homedir(), p.slice(2));
+	return p;
+}
+async function loadConfig() {
+	return fs.readFile(path.join(getConfigDir(), "config.json"), "utf-8").then((data) => JSON.parse(data)).catch(() => ({}));
+}
+async function loadResolvedConfig() {
+	const config = await loadConfig();
+	return {
+		config,
+		dataDir: resolveDataDir(config)
+	};
+}
+async function saveConfig(config) {
+	const configDir = getConfigDir();
+	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(getConfigDir(), "config.json");
+}
+export { __exportAll, config_exports, createCliRuntime, defaultDataDir, getConfigDir, getConfigPath, loadConfig, loadResolvedConfig, runWithCliRuntime, saveConfig, setConfigDir, useCliRuntime };

package/dist/_chunks/config2.mjs

@@ -0,0 +1,232 @@
+import { getConfigPath, loadConfig, saveConfig } from "./config.mjs";
+import { OUTPUT_ARGS, applyOutputMode, displayPath, logger, noSubcommandSelected } from "./utils.mjs";
+import process from "node:process";
+import { defineCommand } from "citty";
+const showCommand = defineCommand({
+	meta: {
+		name: "show",
+		description: "Show current config"
+	},
+	args: { ...OUTPUT_ARGS },
+	async run({ args }) {
+		const { json } = applyOutputMode(args);
+		const config = await loadConfig();
+		const configPath = getConfigPath();
+		if (json) {
+			console.log(JSON.stringify({
+				path: configPath,
+				config
+			}, null, 2));
+			return;
+		}
+		logger.info(`Config: ${displayPath(configPath)}`);
+		console.log();
+		if (Object.keys(config).length === 0) {
+			logger.warn("No config set");
+			return;
+		}
+		console.log(JSON.stringify(config, null, 2));
+	}
+});
+const VALID_KEYS = [
+	"defaultSite",
+	"defaultPeriod",
+	"defaultFormat",
+	"defaultDb",
+	"dataDir",
+	"defaultLimit",
+	"defaultSearchType",
+	"defaultDataState",
+	"serviceAccountPath"
+];
+const NUMERIC_KEYS = /* @__PURE__ */ new Set(["defaultLimit"]);
+const configCommand = defineCommand({
+	meta: {
+		name: "config",
+		description: "Manage configuration"
+	},
+	subCommands: {
+		show: showCommand,
+		set: defineCommand({
+			meta: {
+				name: "set",
+				description: "Set a config value"
+			},
+			args: {
+				key: {
+					type: "positional",
+					description: `Config key (${VALID_KEYS.join(", ")})`,
+					required: true
+				},
+				value: {
+					type: "positional",
+					description: "Value to set",
+					required: true
+				},
+				...OUTPUT_ARGS
+			},
+			async run({ args }) {
+				applyOutputMode(args);
+				if (!VALID_KEYS.includes(args.key)) {
+					logger.error(`Invalid key: ${args.key}`);
+					logger.info(`Valid keys: ${VALID_KEYS.join(", ")}`);
+					process.exit(1);
+				}
+				const config = await loadConfig();
+				const value = NUMERIC_KEYS.has(args.key) ? Number(args.value) : args.value;
+				if (NUMERIC_KEYS.has(args.key) && !Number.isFinite(value)) {
+					logger.error(`Invalid numeric value for ${args.key}: ${args.value}`);
+					process.exit(1);
+				}
+				config[args.key] = value;
+				await saveConfig(config);
+				logger.success(`Set ${args.key} = ${value}`);
+			}
+		}),
+		unset: defineCommand({
+			meta: {
+				name: "unset",
+				description: "Remove a config value"
+			},
+			args: {
+				key: {
+					type: "positional",
+					description: `Config key to remove (${VALID_KEYS.join(", ")})`,
+					required: true
+				},
+				...OUTPUT_ARGS
+			},
+			async run({ args }) {
+				applyOutputMode(args);
+				if (!VALID_KEYS.includes(args.key)) {
+					logger.error(`Invalid key: ${args.key}`);
+					logger.info(`Valid keys: ${VALID_KEYS.join(", ")}`);
+					process.exit(1);
+				}
+				const config = await loadConfig();
+				delete config[args.key];
+				await saveConfig(config);
+				logger.success(`Removed ${args.key}`);
+			}
+		}),
+		path: defineCommand({
+			meta: {
+				name: "path",
+				description: "Show config file path"
+			},
+			run() {
+				console.log(getConfigPath());
+			}
+		}),
+		validate: defineCommand({
+			meta: {
+				name: "validate",
+				description: "Validate the saved config (defaultSite is verified, dataDir exists/writable)"
+			},
+			args: { ...OUTPUT_ARGS },
+			async run({ args }) {
+				const { json } = applyOutputMode(args);
+				const { resolveDataDir } = await import("./config.mjs").then((n) => n.config_exports);
+				const fs = await import("node:fs/promises");
+				const config = await loadConfig();
+				const issues = [];
+				const dataDir = resolveDataDir(config);
+				const dataDirDisplay = displayPath(dataDir);
+				const stat = await fs.stat(dataDir).catch(() => null);
+				if (stat && !stat.isDirectory()) issues.push({
+					key: "dataDir",
+					level: "fail",
+					message: `${dataDirDisplay} is not a directory`
+				});
+				else if (stat) {
+					const probe = `${dataDir}/.gscdump-config-probe`;
+					if (!await fs.writeFile(probe, "").then(() => fs.rm(probe)).then(() => true).catch(() => false)) issues.push({
+						key: "dataDir",
+						level: "fail",
+						message: `${dataDirDisplay} not writable`
+					});
+				} else issues.push({
+					key: "dataDir",
+					level: "warn",
+					message: `${dataDirDisplay} does not exist (will be created on first sync)`
+				});
+				if (config.defaultSite) if (!!config.clientId && !!config.clientSecret) {
+					const { createCommandContext } = await import("./context.mjs").then((n) => n.context_exports);
+					const ctx = await createCommandContext({ needsAuth: true }).catch(() => null);
+					if (ctx) {
+						const sites = await ctx.loadSites().catch(() => null);
+						if (sites && !sites.some((s) => s.siteUrl === config.defaultSite || s.siteUrl.includes(String(config.defaultSite)))) issues.push({
+							key: "defaultSite",
+							level: "fail",
+							message: `${config.defaultSite} is not in the verified site list`
+						});
+					}
+				} else issues.push({
+					key: "defaultSite",
+					level: "warn",
+					message: "set, but auth not configured — skipping verification"
+				});
+				if (config.defaultFormat && !["json", "csv"].includes(config.defaultFormat)) issues.push({
+					key: "defaultFormat",
+					level: "fail",
+					message: `unknown format: ${config.defaultFormat}`
+				});
+				const { SearchTypes } = await import("gscdump/query");
+				const allowedSearchTypes = Object.values(SearchTypes);
+				if (config.defaultSearchType && !allowedSearchTypes.includes(config.defaultSearchType)) issues.push({
+					key: "defaultSearchType",
+					level: "fail",
+					message: `unknown search type: ${config.defaultSearchType} (allowed: ${allowedSearchTypes.join(", ")})`
+				});
+				const allowedDataStates = [
+					"all",
+					"final",
+					"hourly_all"
+				];
+				if (config.defaultDataState && !allowedDataStates.includes(config.defaultDataState)) issues.push({
+					key: "defaultDataState",
+					level: "fail",
+					message: `unknown data state: ${config.defaultDataState} (allowed: ${allowedDataStates.join(", ")})`
+				});
+				if (config.serviceAccountPath) {
+					if (!await fs.stat(config.serviceAccountPath).catch(() => null)) issues.push({
+						key: "serviceAccountPath",
+						level: "fail",
+						message: `${displayPath(config.serviceAccountPath)} does not exist`
+					});
+				}
+				if (json) {
+					console.log(JSON.stringify({
+						ok: !issues.some((i) => i.level === "fail"),
+						issues
+					}, null, 2));
+					return;
+				}
+				if (issues.length === 0) {
+					logger.success("Config OK");
+					return;
+				}
+				for (const i of issues) {
+					const prefix = i.level === "fail" ? "\x1B[31m✗\x1B[0m" : "\x1B[33m!\x1B[0m";
+					console.log(`  ${prefix} ${i.key}: ${i.message}`);
+				}
+				if (issues.some((i) => i.level === "fail")) process.exit(1);
+			}
+		})
+	},
+	async run({ args }) {
+		if (!noSubcommandSelected("config", [
+			"show",
+			"set",
+			"unset",
+			"path",
+			"validate"
+		])) return;
+		await showCommand.run?.({
+			args,
+			cmd: showCommand,
+			rawArgs: []
+		});
+	}
+});
+export { configCommand };

package/dist/_chunks/context.mjs

@@ -0,0 +1,69 @@
+import { __exportAll, loadResolvedConfig } from "./config.mjs";
+import { logger } from "./utils.mjs";
+import { resolveAuth } from "./auth.mjs";
+import process from "node:process";
+import { cancel, isCancel, select } from "@clack/prompts";
+import { googleSearchConsole } from "gscdump/api";
+import { createNodeHarness } from "@gscdump/engine/node";
+import { TABLE_DIMS, transformGscRow } from "@gscdump/engine/ingest";
+import { allTables, inferTable } from "@gscdump/engine/schema";
+function createLocalStore(opts) {
+	return createNodeHarness(opts);
+}
+var context_exports = /* @__PURE__ */ __exportAll({ createCommandContext: () => createCommandContext });
+async function createCommandContext(opts = {}) {
+	const { needsAuth = false, needsStore = false, interactive = false, byok, fetchOptions } = opts;
+	const { config, dataDir } = await loadResolvedConfig();
+	const auth = needsAuth ? await resolveAuth({
+		interactive,
+		config,
+		byok
+	}) : null;
+	const client = auth ? googleSearchConsole(auth, { fetchOptions }) : null;
+	const store = needsStore ? createLocalStore({ dataDir }) : null;
+	const loadSites = async () => {
+		if (!client) throw new Error("loadSites requires needsAuth: true");
+		return (await client.sites().catch((e) => {
+			logger.error(`Failed to fetch sites: ${e.message}`);
+			process.exit(1);
+		})).filter((s) => s.siteUrl && s.permissionLevel !== "siteUnverifiedUser").map((s) => ({
+			siteUrl: s.siteUrl,
+			permissionLevel: s.permissionLevel || "unknown"
+		}));
+	};
+	const resolveSite = async (target) => {
+		const hint = target ?? config.defaultSite;
+		const sites = await loadSites();
+		if (sites.length === 0) {
+			logger.error("No verified sites found");
+			process.exit(1);
+		}
+		if (hint) {
+			const match = sites.find((s) => s.siteUrl === hint || s.siteUrl.includes(hint));
+			if (match) return match.siteUrl;
+		}
+		if (sites.length === 1) return sites[0].siteUrl;
+		const selected = await select({
+			message: "Select a site",
+			options: sites.map((s) => ({
+				value: s.siteUrl,
+				label: s.siteUrl
+			}))
+		});
+		if (isCancel(selected)) {
+			cancel("Cancelled");
+			process.exit(0);
+		}
+		return selected;
+	};
+	return {
+		config,
+		dataDir,
+		auth,
+		client,
+		store,
+		loadSites,
+		resolveSite
+	};
+}
+export { TABLE_DIMS, allTables, context_exports, createCommandContext, createLocalStore, inferTable, transformGscRow };