@gscdump/cli 3.5.0 → 3.6.1

package/dist/commands/auth.mjs

@@ -1,13 +1,17 @@
+import { useCliRuntime } from "../runtime.mjs";
+import { clearAuthentication, getCloudAccount, parseAuthMode, parseAuthentication, resolveAuthentication, saveAuthentication } from "../auth-state.mjs";
 import { authCommandMeta } from "../command-meta.mjs";
 import { loadConfig, saveConfig } from "../config.mjs";
 import { OUTPUT_ARGS, applyOutputMode, logger, noSubcommandSelected } from "../utils.mjs";
 import { authenticate, clearTokens, formatAuthProvenance, getAuth, getAuthCredentials, loadServiceAccount, loadTokens, resolveBYOK, saveTokens } from "../auth.mjs";
 import { missingRequiredScopes } from "../auth-scopes.mjs";
+import { clearBingCredentials, getBingClient, inspectBingCredentials } from "../bing-auth.mjs";
 import { runSmokeTest } from "./init.mjs";
 import { adoptCurrentConfigAsProfile, profileNameFromEmail, resolveActiveProfile } from "./profile.mjs";
 import process from "node:process";
 import { defineCommand } from "citty";
 import path from "node:path";
+import { isCancel, password } from "@clack/prompts";
 import { ofetch } from "ofetch";
 const AUTH_SUBCOMMANDS = [
 	"status",
@@ -16,6 +20,38 @@ const AUTH_SUBCOMMANDS = [
 	"refresh",
 	"scopes"
 ];
+const MODE_ARG = {
+	type: "string",
+	description: "Authentication mode: cloud or local"
+};
+function applyAuthMode(args) {
+	const mode = parseAuthMode(args.mode);
+	if (mode) useCliRuntime().authModeOverride = mode;
+}
+async function requireLocalAuth(args) {
+	applyAuthMode(args);
+	if ((await resolveAuthentication())._tag === "Cloud") throw new Error("Cloud authentication uses an API key. OAuth scopes and token refresh require --mode local.");
+}
+async function loginCloud(args) {
+	const env = useCliRuntime().environment;
+	let apiKey = String(args["api-key"] ?? env.GSCDUMP_API_KEY ?? "");
+	if (!apiKey) {
+		if (!process.stdin.isTTY) throw new Error("Cloud login requires --api-key or GSCDUMP_API_KEY.");
+		const answer = await password({ message: "gscdump user API key" });
+		if (isCancel(answer) || typeof answer !== "string") throw new Error("Login cancelled.");
+		apiKey = answer;
+	}
+	const state = parseAuthentication({
+		_tag: "Cloud",
+		apiKey,
+		apiRoot: String(args["api-root"] ?? env.GSCDUMP_API_ROOT ?? "https://gscdump.com/api")
+	});
+	if (state._tag !== "Cloud") throw new Error("Cloud login requires a gscdump user API key.");
+	const account = await getCloudAccount(state);
+	await saveAuthentication(state);
+	logger.success(`Cloud authentication saved for ${account.user.email}`);
+	logger.info("Google and Bing commands use connections saved on gscdump.com.");
+}
 async function fetchTokenInfo(accessToken) {
 	return ofetch("https://oauth2.googleapis.com/tokeninfo", { query: { access_token: accessToken } }).catch(() => null);
 }
@@ -40,11 +76,90 @@ async function resolveLiveAuthState() {
 }
 async function runStatus(args) {
 	const { json } = applyOutputMode(args);
+	applyAuthMode(args);
+	const authentication = await resolveAuthentication();
+	if (authentication._tag === "Cloud") {
+		const capabilities = {
+			google: [
+				"sites",
+				"query",
+				"sync",
+				"inspect",
+				"sitemaps",
+				"analyze",
+				"report"
+			],
+			bing: [
+				"sites",
+				"dump",
+				"inspect",
+				"login",
+				"status",
+				"verify"
+			],
+			cloud: [
+				"sitemaps current",
+				"sitemaps history",
+				"sitemaps membership",
+				"sitemaps lastmod",
+				"sitemaps export"
+			],
+			local: ["indexing", "sites verification"]
+		};
+		const account = await getCloudAccount(authentication).then((value) => ({
+			_tag: "Ok",
+			value
+		}), (error) => ({
+			_tag: "Err",
+			detail: error instanceof Error ? error.message : "Hosted authentication failed."
+		}));
+		if (account._tag === "Err") {
+			if (json) console.log(JSON.stringify({
+				authenticated: false,
+				mode: "cloud",
+				apiRoot: authentication.apiRoot,
+				error: account.detail
+			}, null, 2));
+			else {
+				logger.warn(`Cloud status check failed: ${account.detail}`);
+				logger.info(`API: ${authentication.apiRoot}`);
+				logger.info("Fix connectivity or the API key, then run `gscdump auth status` again.");
+			}
+			return;
+		}
+		if (json) console.log(JSON.stringify({
+			authenticated: true,
+			mode: "cloud",
+			account: account.value.user.email,
+			apiRoot: authentication.apiRoot,
+			sites: account.value.sites,
+			capabilities
+		}, null, 2));
+		else {
+			logger.success(`Authenticated with cloud: ${account.value.user.email}`);
+			console.log(`  API: ${authentication.apiRoot}`);
+			console.log(`  Sites: ${account.value.sites.length}`);
+			console.log("  Google and Bing use connections saved on gscdump.com.");
+			console.log(`  Cloud commands: ${capabilities.cloud.join(", ")}`);
+			console.log("  Google indexing and Site Verification require --mode local.");
+		}
+		return;
+	}
 	const { byok, tokens, tokenInfo, scopes, missing } = await resolveLiveAuthState();
+	const bingCredentials = await inspectBingCredentials();
+	const bingResult = bingCredentials._tag === "Missing" ? null : await getBingClient().then((client) => client.getUserSites({ signal: AbortSignal.timeout(1e4) })).catch(() => null);
+	const bing = {
+		configured: bingCredentials._tag !== "Missing",
+		authenticated: bingResult?.ok === true,
+		source: bingCredentials._tag === "Missing" ? null : bingCredentials._tag
+	};
 	const byokKind = byok ? typeof byok === "string" ? "access-token" : "refresh-token" : null;
 	if (json) {
 		console.log(JSON.stringify({
-			authenticated: !!tokens || !!byok,
+			authenticated: !!tokens || !!byok || bing.authenticated,
+			mode: "local",
+			googleAuthenticated: !!tokens || !!byok,
+			bing,
 			source: byok ? "byok" : tokens ? "saved-tokens" : null,
 			byokKind,
 			scopes,
@@ -58,6 +173,8 @@ async function runStatus(args) {
 		}, null, 2));
 		return;
 	}
+	if (bing.authenticated) logger.success(`Bing authenticated locally (${bing.source})`);
+	else if (bing.configured) logger.warn("Bing credentials failed verification. Run `gscdump bing login` again.");
 	const reportScopes = () => {
 		if (scopes.length === 0) return;
 		console.log(`  Scopes:`);
@@ -75,6 +192,10 @@ async function runStatus(args) {
 		return;
 	}
 	if (!tokens) {
+		if (bing.authenticated) {
+			logger.info("Google credentials are missing. Run `gscdump auth login --mode local` to connect Google.");
+			return;
+		}
 		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");
@@ -100,7 +221,10 @@ async function runStatus(args) {
 }
 const statusCommand = defineCommand({
 	meta: authCommandMeta.status,
-	args: { ...OUTPUT_ARGS },
+	args: {
+		...OUTPUT_ARGS,
+		mode: MODE_ARG
+	},
 	async run({ args }) {
 		await runStatus(args);
 	}
@@ -110,9 +234,13 @@ const refreshCommand = defineCommand({
 		name: "refresh",
 		description: "Force-refresh saved OAuth tokens (no-op for BYOK)"
 	},
-	args: { ...OUTPUT_ARGS },
+	args: {
+		...OUTPUT_ARGS,
+		mode: MODE_ARG
+	},
 	async run({ args }) {
 		applyOutputMode(args);
+		await requireLocalAuth(args);
 		if (resolveBYOK()) {
 			logger.info("BYOK detected; refresh handled per-call by the SDK");
 			return;
@@ -141,6 +269,15 @@ const loginCommand = defineCommand({
 	meta: authCommandMeta.login,
 	args: {
 		...OUTPUT_ARGS,
+		"mode": MODE_ARG,
+		"api-key": {
+			type: "string",
+			description: "gscdump user API key; defaults to GSCDUMP_API_KEY"
+		},
+		"api-root": {
+			type: "string",
+			description: "Cloud API root; defaults to GSCDUMP_API_ROOT or https://gscdump.com/api"
+		},
 		"force": {
 			type: "boolean",
 			alias: "f",
@@ -150,7 +287,7 @@ const loginCommand = defineCommand({
 		"browser": {
 			type: "boolean",
 			default: true,
-			description: "Use loopback browser flow. Pass --no-browser for device-code (headless)."
+			description: "Open the authorization URL automatically. Pass --no-browser to open it yourself."
 		},
 		"service-account": {
 			type: "string",
@@ -159,7 +296,14 @@ const loginCommand = defineCommand({
 	},
 	async run({ args }) {
 		applyOutputMode(args);
+		const runtime = useCliRuntime();
+		const requestedMode = parseAuthMode(args.mode) ?? runtime.authModeOverride ?? parseAuthMode(runtime.environment.GSCDUMP_AUTH_MODE);
+		if (requestedMode === "cloud" || !requestedMode && (args["api-key"] || (await resolveAuthentication())._tag === "Cloud")) {
+			await loginCloud(args);
+			return;
+		}
 		if (resolveBYOK() && !args.force) {
+			await saveAuthentication({ _tag: "Local" });
 			logger.info("BYOK env vars detected, no login needed (--force to override)");
 			return;
 		}
@@ -176,11 +320,11 @@ const loginCommand = defineCommand({
 			const config = await loadConfig();
 			config.serviceAccountPath = saPath;
 			await saveConfig(config);
+			await saveAuthentication({ _tag: "Local" });
 			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,
@@ -191,6 +335,7 @@ const loginCommand = defineCommand({
 		});
 		logger.success("Logged in");
 		await runSmokeTest(oauth);
+		await saveAuthentication({ _tag: "Local" });
 		if (!resolveActiveProfile()) {
 			const tokens = await loadTokens();
 			const info = tokens?.access_token ? await fetchTokenInfo(tokens.access_token) : null;
@@ -215,6 +360,8 @@ const logoutCommand = defineCommand({
 	async run({ args }) {
 		applyOutputMode(args);
 		await clearTokens();
+		await clearBingCredentials();
+		await clearAuthentication();
 		const config = await loadConfig();
 		if (config.serviceAccountPath) {
 			delete config.serviceAccountPath;
@@ -228,9 +375,13 @@ const scopesCommand = defineCommand({
 		name: "scopes",
 		description: "Print granted OAuth scopes (one per line); exits 1 if any required scope is missing"
 	},
-	args: { ...OUTPUT_ARGS },
+	args: {
+		...OUTPUT_ARGS,
+		mode: MODE_ARG
+	},
 	async run({ args }) {
 		const { json } = applyOutputMode(args);
+		await requireLocalAuth(args);
 		const { liveToken, scopes, missing } = await resolveLiveAuthState();
 		if (!liveToken) {
 			if (json) console.log(JSON.stringify({
@@ -250,7 +401,10 @@ const scopesCommand = defineCommand({
 });
 const authCommand = defineCommand({
 	meta: authCommandMeta.auth,
-	args: { ...OUTPUT_ARGS },
+	args: {
+		...OUTPUT_ARGS,
+		mode: MODE_ARG
+	},
 	subCommands: {
 		status: statusCommand,
 		login: loginCommand,

package/dist/commands/bing.mjs

@@ -0,0 +1,337 @@
+import { useCliRuntime } from "../runtime.mjs";
+import { resolveAuthentication, saveAuthentication } from "../auth-state.mjs";
+import { bingCommandMeta } from "../command-meta.mjs";
+import { OUTPUT_ARGS, applyOutputMode, logger } from "../utils.mjs";
+import { BING_REDIRECT_URI, clearBingCredentials, getBingClient, loginBingOAuth, saveBingCredentials } from "../bing-auth.mjs";
+import { BING_DATASETS, dumpBingSite, parseBingDumpOptions, resolveBingSites, unwrapBing } from "../bing-data.mjs";
+import { dumpHostedBingSite, hostedBingClient, inspectHostedBingUrl, listHostedBingSites, resolveHostedBingSites } from "../bing-hosted.mjs";
+import process from "node:process";
+import { defineCommand } from "citty";
+import { isCancel, password } from "@clack/prompts";
+import open from "open";
+import { bingWebmaster } from "gscdump/bing";
+const siteArg = {
+	type: "string",
+	alias: "s",
+	description: "Site ID or URL from `gscdump bing sites`"
+};
+const bingCommand = defineCommand({
+	meta: bingCommandMeta,
+	subCommands: {
+		login: defineCommand({
+			meta: {
+				name: "login",
+				description: "Save a Bing API key or authorize with browser OAuth"
+			},
+			args: {
+				"site": siteArg,
+				"api-key": {
+					type: "string",
+					description: "Bing Webmaster API key. Defaults to BING_API_KEY or a password prompt"
+				},
+				"oauth": {
+					type: "boolean",
+					description: "Use a registered Bing OAuth client"
+				},
+				"client-id": {
+					type: "string",
+					description: "Bing OAuth client ID. Defaults to BING_CLIENT_ID"
+				},
+				"client-secret": {
+					type: "string",
+					description: "Bing OAuth client secret. Defaults to BING_CLIENT_SECRET"
+				},
+				"redirect-uri": {
+					type: "string",
+					description: `Registered loopback callback. Defaults to BING_REDIRECT_URI or ${BING_REDIRECT_URI}`
+				},
+				"browser": {
+					type: "boolean",
+					default: true,
+					description: "Open the browser. Use --no-browser to print the login URL"
+				},
+				...OUTPUT_ARGS
+			},
+			async run({ args }) {
+				const { json } = applyOutputMode(args);
+				const env = useCliRuntime().environment;
+				const authentication = await resolveAuthentication();
+				if (authentication._tag === "Cloud") {
+					if (args.oauth || args["api-key"] || args["client-id"] || args["client-secret"] || args["redirect-uri"]) throw new Error("Local Bing credentials require --mode local. Hosted login uses `gscdump auth login --mode cloud`.");
+					if (!args.site) throw new Error("Choose --site SITE_ID from `gscdump bing sites` to connect Bing.");
+					const [site] = await resolveHostedBingSites(authentication, {
+						site: args.site,
+						requireConnected: false
+					});
+					if (site.connection._tag === "connected") {
+						console.log(JSON.stringify({
+							searchEngine: "bing",
+							connection: site.connection
+						}, null, 2));
+						return;
+					}
+					const url = new URL("/auth/bing", authentication.apiRoot);
+					url.searchParams.set("siteId", site.siteId);
+					process.stderr.write(`Open this URL to connect Bing:\n${url}\n`);
+					if (args.browser) await open(url.toString()).catch(() => {
+						logger.warn("The browser could not open. Use the printed login URL.");
+					});
+					if (json) console.log(JSON.stringify({
+						searchEngine: "bing",
+						connection: site.connection,
+						authorizationUrl: url.toString()
+					}));
+					else logger.info("Complete Bing authorization in your browser. Then run `gscdump bing status --site SITE_ID`.");
+					return;
+				}
+				if (args.oauth) {
+					if (args["api-key"]) throw new Error("Choose --oauth or --api-key.");
+					await loginBingOAuth({
+						clientId: args["client-id"] ?? env.BING_CLIENT_ID ?? "",
+						clientSecret: args["client-secret"] ?? env.BING_CLIENT_SECRET ?? "",
+						redirectUri: args["redirect-uri"] ?? env.BING_REDIRECT_URI ?? "http://127.0.0.1:53683/oauth/bing",
+						async openUrl(url) {
+							process.stderr.write(`Open this URL to authorize Bing:\n${url}\n`);
+							if (args.browser) await open(url).catch(() => {
+								logger.warn("The browser could not open. Use the printed login URL.");
+							});
+						}
+					});
+				} else {
+					if (args["client-id"] || args["client-secret"] || args["redirect-uri"]) throw new Error("If you use OAuth client options, add --oauth.");
+					let apiKey = (args["api-key"] ?? env.BING_API_KEY)?.trim();
+					if (!apiKey && process.stdin.isTTY && !json) {
+						const value = await password({ message: "Bing Webmaster API key" });
+						if (isCancel(value) || typeof value !== "string") throw new Error("Bing login cancelled.");
+						apiKey = value.trim();
+					}
+					if (!apiKey) throw new Error("Set BING_API_KEY or use --oauth with BING_CLIENT_ID and BING_CLIENT_SECRET.");
+					unwrapBing(await bingWebmaster({ apiKey }).getUserSites({ signal: AbortSignal.timeout(3e4) }));
+					await saveBingCredentials({
+						_tag: "ApiKey",
+						apiKey
+					});
+				}
+				await saveAuthentication({ _tag: "Local" });
+				if (json) console.log(JSON.stringify({
+					searchEngine: "bing",
+					authenticated: true
+				}));
+				else logger.success("Bing credentials saved. Run `gscdump bing sites`.");
+			}
+		}),
+		logout: defineCommand({
+			meta: {
+				name: "logout",
+				description: "Remove saved Bing credentials from the current profile"
+			},
+			args: OUTPUT_ARGS,
+			async run({ args }) {
+				const { json } = applyOutputMode(args);
+				if ((await resolveAuthentication())._tag === "Cloud") throw new Error("Hosted authentication is shared with Google. Use `gscdump auth logout` to remove it.");
+				await clearBingCredentials();
+				const env = useCliRuntime().environment;
+				const environmentCredentials = Boolean(env.BING_API_KEY?.trim() || env.BING_ACCESS_TOKEN?.trim());
+				if (json) console.log(JSON.stringify({
+					searchEngine: "bing",
+					savedCredentialsRemoved: true,
+					environmentCredentials
+				}));
+				else logger.success(`Saved Bing credentials removed.${environmentCredentials ? " Unset BING_API_KEY and BING_ACCESS_TOKEN to stop environment authentication." : ""}`);
+			}
+		}),
+		status: defineCommand({
+			meta: {
+				name: "status",
+				description: "Check Bing authentication against the live API"
+			},
+			args: {
+				site: siteArg,
+				...OUTPUT_ARGS
+			},
+			async run({ args }) {
+				const { json } = applyOutputMode(args);
+				const authentication = await resolveAuthentication();
+				if (authentication._tag === "Cloud") {
+					const sites = args.site ? await resolveHostedBingSites(authentication, {
+						site: args.site,
+						requireConnected: false
+					}) : await listHostedBingSites(authentication);
+					console.log(JSON.stringify({
+						searchEngine: "bing",
+						mode: "cloud",
+						sites
+					}, null, 2));
+					return;
+				}
+				const client = await getBingClient();
+				const sites = unwrapBing(await client.getUserSites({ signal: AbortSignal.timeout(3e4) }));
+				if (json) console.log(JSON.stringify({
+					searchEngine: "bing",
+					authenticated: true,
+					verifiedSites: sites.filter((site) => site.isVerified).length
+				}));
+				else logger.success(`Bing authenticated. ${sites.filter((site) => site.isVerified).length} verified sites.`);
+			}
+		}),
+		sites: defineCommand({
+			meta: {
+				name: "sites",
+				description: "List Bing sites and verification details"
+			},
+			args: OUTPUT_ARGS,
+			async run({ args }) {
+				applyOutputMode(args);
+				const authentication = await resolveAuthentication();
+				if (authentication._tag === "Cloud") {
+					console.log(JSON.stringify({
+						searchEngine: "bing",
+						sites: await listHostedBingSites(authentication)
+					}, null, 2));
+					return;
+				}
+				const client = await getBingClient();
+				const sites = unwrapBing(await client.getUserSites({ signal: AbortSignal.timeout(3e4) }));
+				console.log(JSON.stringify({
+					searchEngine: "bing",
+					sites
+				}, null, 2));
+			}
+		}),
+		dump: defineCommand({
+			meta: {
+				name: "dump",
+				description: "Download Bing traffic, pages, keywords, and crawl data"
+			},
+			args: {
+				"site": siteArg,
+				"all-sites": {
+					type: "boolean",
+					description: "Dump every verified Bing site"
+				},
+				"out": {
+					type: "string",
+					alias: "o",
+					default: "./bing-export",
+					description: "Output directory, with one directory per site"
+				},
+				"format": {
+					type: "string",
+					alias: "F",
+					default: "json",
+					description: "File format: json, ndjson, csv"
+				},
+				"datasets": {
+					type: "string",
+					description: `Comma-separated datasets: ${BING_DATASETS.join(", ")}. Default: all except crawl-issues`
+				},
+				"start": {
+					type: "string",
+					description: "Keep returned dates on or after YYYY-MM-DD"
+				},
+				"end": {
+					type: "string",
+					description: "Keep returned dates on or before YYYY-MM-DD"
+				},
+				...OUTPUT_ARGS
+			},
+			async run({ args }) {
+				const { json } = applyOutputMode(args);
+				const options = parseBingDumpOptions(args);
+				const authentication = await resolveAuthentication();
+				if (authentication._tag === "Cloud") {
+					if (options.datasets.includes("crawl-issues")) throw new Error("Bing crawl issues require local authentication. Use --mode local.");
+					if (options.start && options.end && Date.parse(options.end) - Date.parse(options.start) > 316224e5) throw new Error("Hosted Bing exports support at most 366 days. Use a shorter --start and --end range.");
+					const sites = await resolveHostedBingSites(authentication, {
+						site: args.site,
+						allSites: args["all-sites"]
+					});
+					const summaries = [];
+					for (const site of sites) {
+						const summary = await dumpHostedBingSite(authentication, site, args.out, options);
+						summaries.push(summary);
+						if (!json) logger.success(`Bing ${site.siteUrl}: ${summary.files.length} files exported to ${args.out}.`);
+					}
+					if (json) console.log(JSON.stringify(args["all-sites"] ? {
+						searchEngine: "bing",
+						sites: summaries
+					} : summaries[0], null, 2));
+					return;
+				}
+				const client = await getBingClient();
+				const sites = await resolveBingSites(client, {
+					site: args.site,
+					allSites: args["all-sites"]
+				});
+				const summaries = [];
+				for (const site of sites) {
+					const summary = await dumpBingSite(client, site, args.out, options);
+					summaries.push(summary);
+					if (!json) logger.success(`Bing ${site}: ${summary.files.length} files exported to ${args.out}.`);
+				}
+				if (json) console.log(JSON.stringify(args["all-sites"] ? {
+					searchEngine: "bing",
+					sites: summaries
+				} : summaries[0], null, 2));
+			}
+		}),
+		inspect: defineCommand({
+			meta: {
+				name: "inspect",
+				description: "Read Bing Indexing Evidence for one URL"
+			},
+			args: {
+				url: {
+					type: "positional",
+					required: true,
+					description: "Page URL to inspect"
+				},
+				site: {
+					...siteArg,
+					required: true
+				},
+				...OUTPUT_ARGS
+			},
+			async run({ args }) {
+				applyOutputMode(args);
+				const url = URL.parse(args.url);
+				if (!url || !["http:", "https:"].includes(url.protocol)) throw new Error("Use a full HTTP or HTTPS page URL.");
+				const authentication = await resolveAuthentication();
+				if (authentication._tag === "Cloud") {
+					const [site] = await resolveHostedBingSites(authentication, { site: args.site });
+					console.log(JSON.stringify(await inspectHostedBingUrl(authentication, site.siteId, args.url), null, 2));
+					return;
+				}
+				const client = await getBingClient();
+				const [site] = await resolveBingSites(client, { site: args.site });
+				const evidence = unwrapBing(await client.getIndexingEvidence(site, args.url, { signal: AbortSignal.timeout(3e4) }));
+				console.log(JSON.stringify(evidence, null, 2));
+			}
+		}),
+		verify: defineCommand({
+			meta: {
+				name: "verify",
+				description: "Check Bing site verification and activate a hosted connection"
+			},
+			args: {
+				site: {
+					...siteArg,
+					required: true
+				},
+				...OUTPUT_ARGS
+			},
+			async run({ args }) {
+				applyOutputMode(args);
+				const authentication = await resolveAuthentication();
+				if (authentication._tag !== "Cloud") throw new Error("Hosted Bing connection verification requires --mode cloud.");
+				const [site] = await resolveHostedBingSites(authentication, {
+					site: args.site,
+					requireConnected: false
+				});
+				const result = await hostedBingClient(authentication).verifySiteBingConnection({ params: { siteId: site.siteId } });
+				console.log(JSON.stringify(result.data, null, 2));
+			}
+		})
+	}
+});
+export { bingCommand };