seo 0.17.2 → 0.17.3

package/dist/mcp.js

@@ -1,5 +1,5 @@
 import { createRequire as __seoCreateRequire } from 'node:module'; const require = __seoCreateRequire(import.meta.url);
-import { i as __toESM, n as version, r as __commonJSMin, t as load } from "./esm-BR8_7rhM.js";
+import { i as __toESM, n as version, r as __commonJSMin, t as load } from "./esm-HKeFfXOD.js";
 import { createHash, randomUUID, sign } from "node:crypto";
 import { ZodOptional, z } from "zod";
 import { arch, homedir, platform, tmpdir, totalmem } from "node:os";
@@ -48041,6 +48041,46 @@ async function saveResearch(store, key, saved) {
 	if (!store) return;
 	await store.put(key, JSON.stringify(saved), RESEARCH_TTL_SECONDS).catch(() => void 0);
 }
+// packages/core/dist/commands/research-installed.js
+async function installedSerpResearch(provider, input, serp) {
+	if (!serp) throw new CommandError("INVALID_INPUT", `${provider} is not a built-in provider. Here the providers are dataforseo and ahrefs; installed provider packages run only in the seo CLI and the local MCP server (seo mcp serve).`);
+	if (input.keywords.length === 0) throw new CommandError("INVALID_INPUT", "serp needs keywords.");
+	const keywords = input.keywords.slice(0, serpKeywords(input));
+	const language = dataForSeoMarket(input.country, null).language_code;
+	const missed = [];
+	const warnings = [];
+	let costMicros = 0;
+	let partial = false;
+	let depth = serpDepth(input);
+	const rows = await eachKeyword(keywords, missed, async (keyword) => {
+		const got = await serp({
+			provider,
+			keyword,
+			country: input.country,
+			language,
+			device: input.device ?? "desktop",
+			depth: serpDepth(input)
+		});
+		depth = Math.min(depth, got.depth);
+		costMicros = costMicros === null || got.costMicros === null ? null : costMicros + got.costMicros;
+		partial ||= got.partial;
+		warnings.push(...got.warnings.map((warning) => `${keyword}: ${warning}`));
+		return got.rows.map((row) => ({
+			keyword,
+			...row
+		}));
+	});
+	const answered = new Set(rows.map((row) => row.keyword));
+	if (depth < serpDepth(input)) warnings.unshift(`The package reads at most ${depth} results a keyword, so this read ${depth} of the ${serpDepth(input)} asked for.`);
+	return {
+		rows,
+		costUsd: costMicros === null ? null : Number((costMicros / 1e6).toFixed(6)),
+		partial,
+		missed,
+		noData: keywords.filter((keyword) => !missed.includes(keyword) && !answered.has(keyword)),
+		warnings
+	};
+}
 // packages/core/dist/commands/research.js
 const RESEARCH_ACTIONS = [
 	"keyword_metrics",
@@ -48057,7 +48097,7 @@ const RESEARCH_ACTIONS = [
 	"index_check"
 ];
 const RESEARCH_PROVIDERS = ["dataforseo", "ahrefs"];
-const RESEARCH_HELP = `provider is optional: without it the call uses the saved key, DataForSEO when both are saved. The target is a domain (the whole site), a path ending in / such as example.com/blog/ (every URL under it), or one page; scope overrides that. keyword_metrics (keywords: volume, difficulty, CPC), keyword_ideas (up to 5 seed keywords: searches that contain each seed, by volume), ranked_keywords (target: keywords a site, subfolder or page ranks for, with the provider's traffic total for the whole target), top_pages (target: the pages with the most estimated organic traffic), serp (keywords, up to 5: the ranking pages with their organic position beside DataForSEO's rank_absolute, which also counts AI Overviews and other blocks, plus the AI Overview's sources; device desktop or mobile, DataForSEO only; each with its domain's authority: DataForSEO domain_rank 0 to 100, Ahrefs domain_rating; depth sets results per keyword, default 20; rows run position by position across the keywords), index_check (DataForSEO only; target: one page URL; keywords: up to 2 exact phrases from the page, default its H1 or title. Searches Google for site:<url> and each "<phrase>" on desktop and mobile, retries failed searches, treats Google's fallback to unrelated sites as no match, and says indexed, not found or unknown with each search's evidence; about $0.01 a page), serp_overlap (2 to 10 keywords: for each pair, how many of their top 10 pages and sites are the same, to decide one page or several; results without a real page are counted, not compared), competitors (target: domains that share keywords), backlinks (target: referring domains), pages_by_backlinks (target: the pages with the most referring domains), link_gap (target and 2 to 5 competitors: referring domains that link to two or more competitors and not the target, highest authority first, from each site's top 1,000 referring domains; costs one backlinks call per site), ai_answers (DataForSEO only; target: the site. Without keywords it takes the site’s top 10 chat-style and long questions from Search Console’s AI-shaped queries itself. With up to 10 questions in keywords it asks those instead, and the target can be any domain, such as a competitor's. Each answer row also lists the other sites it cites, and the notes rank them. Answers come from DataForSEO's queue: answers not ready after about 40 seconds are returned as tasks, already paid for; call again with the same target and those tasks to read them at no cost. It asks ChatGPT search, Google AI Mode and Google AI Overviews each one and says whether the answer cites or mentions the site. DataForSEO’s queue prices are about $0.0072 a question across the three engines, so about $0.07 a run: tell the person before running it). Rows with a domain, and the target, get a free Ahrefs domain_rating column. Numbers are provider estimates, not Search Console data.`;
+const RESEARCH_HELP = `provider is optional: without it the call uses the saved key, DataForSEO when both are saved. In the CLI and the local MCP server, serp can also use a provider package installed on this machine that supplies live search results: pass its id as provider. The target is a domain (the whole site), a path ending in / such as example.com/blog/ (every URL under it), or one page; scope overrides that. keyword_metrics (keywords: volume, difficulty, CPC), keyword_ideas (up to 5 seed keywords: searches that contain each seed, by volume), ranked_keywords (target: keywords a site, subfolder or page ranks for, with the provider's traffic total for the whole target), top_pages (target: the pages with the most estimated organic traffic), serp (keywords, up to 5: the ranking pages with their organic position beside DataForSEO's rank_absolute, which also counts AI Overviews and other blocks, plus the AI Overview's sources; device desktop or mobile, DataForSEO only; each with its domain's authority: DataForSEO domain_rank 0 to 100, Ahrefs domain_rating; depth sets results per keyword, default 20; rows run position by position across the keywords), index_check (DataForSEO only; target: one page URL; keywords: up to 2 exact phrases from the page, default its H1 or title. Searches Google for site:<url> and each "<phrase>" on desktop and mobile, retries failed searches, treats Google's fallback to unrelated sites as no match, and says indexed, not found or unknown with each search's evidence; about $0.01 a page), serp_overlap (2 to 10 keywords: for each pair, how many of their top 10 pages and sites are the same, to decide one page or several; results without a real page are counted, not compared), competitors (target: domains that share keywords), backlinks (target: referring domains), pages_by_backlinks (target: the pages with the most referring domains), link_gap (target and 2 to 5 competitors: referring domains that link to two or more competitors and not the target, highest authority first, from each site's top 1,000 referring domains; costs one backlinks call per site), ai_answers (DataForSEO only; target: the site. Without keywords it takes the site’s top 10 chat-style and long questions from Search Console’s AI-shaped queries itself. With up to 10 questions in keywords it asks those instead, and the target can be any domain, such as a competitor's. Each answer row also lists the other sites it cites, and the notes rank them. Answers come from DataForSEO's queue: answers not ready after about 40 seconds are returned as tasks, already paid for; call again with the same target and those tasks to read them at no cost. It asks ChatGPT search, Google AI Mode and Google AI Overviews each one and says whether the answer cites or mentions the site. DataForSEO’s queue prices are about $0.0072 a question across the three engines, so about $0.07 a run: tell the person before running it). Rows with a domain, and the target, get a free Ahrefs domain_rating column. Numbers are provider estimates, not Search Console data.`;
 const GENERIC_PLATFORMS = [
 	"youtube.com",
 	"facebook.com",
@@ -48119,6 +48159,8 @@ async function runResearch(input, keys, options) {
 	const offset = input.offset ?? 0;
 	if (input.action === "ai_answers") throw new CommandError("INVALID_INPUT", "ai_answers runs on its own.");
 	const provider = chooseProvider(input.provider, keys);
+	const builtIn = RESEARCH_PROVIDERS.includes(provider) ? provider : null;
+	if (!builtIn && input.action !== "serp") throw new CommandError("INVALID_INPUT", `An installed provider answers serp only; ${input.action} needs a built-in provider.`);
 	if (input.action === "index_check") {
 		if (provider === "ahrefs") throw new CommandError("INVALID_INPUT", "index_check uses DataForSEO: it runs live Google searches, which Ahrefs does not offer.");
 		return runIndexCheck({
@@ -48151,20 +48193,23 @@ async function runResearch(input, keys, options) {
 	const store = options.store ?? workersResearchStore();
 	const key = await researchKey([
 		provider,
-		provider === "dataforseo" ? keys.get("x-dataforseo-login") : keys.get("x-ahrefs-key"),
+		builtIn ? keys.get(KEY_HEADER[builtIn]) : null,
 		request
 	]);
 	const saved = await readResearch(store, key, limit);
-	const result = saved?.result ?? await research(provider, keys, {
+	const result = saved?.result ?? (builtIn ? await research(builtIn, keys, {
 		...request,
 		limit
-	});
+	}) : await installedSerpResearch(provider, {
+		...request,
+		limit
+	}, options.installedSerp));
 	if (!saved) await saveResearch(store, key, {
 		limit,
 		savedAt: (/* @__PURE__ */ new Date()).toISOString(),
 		result
 	});
-	const { rows: fetched, costUsd: paid, partial, missed, noData, floor, leftOut, available, siteTotal, rankFailed, compared, aiOverviews } = result;
+	const { rows: fetched, costUsd: paid, partial, missed, noData, floor, leftOut, available, siteTotal, rankFailed, compared, aiOverviews, warnings } = result;
 	const costUsd = saved ? 0 : paid;
 	const order = new Map(request.keywords.map((word, index) => [word, index]));
 	const found = input.action === "serp" && request.keywords.length > 1 ? [...fetched].sort((a, b) => Number(a.position ?? 0) - Number(b.position ?? 0) || (order.get(String(a.keyword)) ?? 0) - (order.get(String(b.keyword)) ?? 0)) : fetched;
@@ -48193,18 +48238,19 @@ async function runResearch(input, keys, options) {
 			notes: [
 				`${provider} estimates, in the provider’s own units.`,
 				...compared ? [`Compared: ${compared.withPage} of ${compared.results} top results had a real page, so shared_pages counts only those; ${compared.results - compared.withPage} came back as Google redirect links and could not be compared by page. ${compared.withSite} had a known site for shared_sites. Unique pages and sites are counted per keyword.${compared.withPage < compared.results / 2 && provider === "dataforseo" ? " With this few pages, shared_pages cannot settle one page or several; provider ahrefs returns real pages." : ""}`] : [],
-				...VOLUME_ACTIONS.includes(input.action) ? [`Volume model: ${VOLUME_MODEL[provider]} ${VOLUMES_DIFFER}`] : [],
+				...VOLUME_ACTIONS.includes(input.action) && builtIn ? [`Volume model: ${VOLUME_MODEL[builtIn]} ${VOLUMES_DIFFER}`] : [],
 				...input.action === "serp" || input.action === "ranked_keywords" ? [positionNote(provider)] : [],
 				...aiOverviews?.length ? [aiOverviewNote(aiOverviews, request.keywords.length)] : input.action === "serp" && provider === "dataforseo" && rows.length ? ["No AI Overview on these results pages."] : [],
 				...perKeyword ? [`Results per keyword: ${Object.entries(perKeyword).map(([word, count]) => `${word} ${count}`).join(", ")}. Rows run position by position across the keywords.`] : [],
-				...siteTotal ? [siteTotalNote(provider, siteTotal, rows.length)] : [],
+				...siteTotal && builtIn ? [siteTotalNote(builtIn, siteTotal, rows.length)] : [],
 				...available !== void 0 && available > found.length ? [`Capped: ${provider} has ${available.toLocaleString("en-US")} rows for this; this read the first ${found.length.toLocaleString("en-US")} in its order.`] : [],
 				...!found.length && scope ? [emptyNote(provider, input.action)] : [],
 				...input.action === "serp" && provider === "dataforseo" ? [rankFailed ? "domain_rank is missing: the DataForSEO rank call failed, so it is unknown, not zero." : "domain_rank is DataForSEO's own authority score for the domain, 0 to 100. It is not Ahrefs' Domain Rating."] : [],
 				...input.action === "serp" && !drKey && provider === "dataforseo" ? ["No domain_rating column: Domain Rating by Ahrefs needs an Ahrefs key (or the hosted MCP at https://seoskill.dev/mcp, which adds it)."] : [],
 				...store && rated.rows.length > 50 ? ["The result is kept for a day, so the next pages, and the same rows in full, cost nothing more."] : [],
-				...saved ? [`Read from the result saved at ${saved.savedAt}, at no new cost${paid ? ` (it cost $${paid} then)` : ""}. Results are kept for a day.`] : costUsd !== null ? [`DataForSEO cost: $${costUsd}.`] : [],
-				...partial ? ["Partial: DataForSEO could not fetch some pages of results, so rows may be missing."] : [],
+				...saved ? [`Read from the result saved at ${saved.savedAt}, at no new cost${paid ? ` (it cost $${paid} then)` : ""}. Results are kept for a day.`] : costUsd !== null ? [builtIn ? `DataForSEO cost: $${costUsd}.` : `Cost the ${provider} package reports: $${costUsd}.`] : [],
+				...partial ? [`Partial: ${builtIn ? "DataForSEO" : provider} could not fetch some pages of results, so rows may be missing.`] : [],
+				...warnings?.length ? [`${provider} warnings: ${warnings.join(" ")}`] : [],
 				...missed.length ? [`Partial: ${provider} failed for ${missed.join(", ")}, so those keywords have no rows. Ask for them again.`] : [],
 				...noData.length ? [noDataNote(provider, input.action, noData)] : [],
 				...byDr ? [rows.length > GAP_RATED ? `Sorted by Domain Rating for the top ${GAP_RATED} rows by DataForSEO rank; the ${rows.length - GAP_RATED} rows after them follow by rank, with no Domain Rating.` : "Sorted by Domain Rating, then DataForSEO rank."] : [],
@@ -48222,9 +48268,9 @@ async function runResearch(input, keys, options) {
 			action: input.action,
 			target: target || null,
 			scope,
-			siteTotal: siteTotal ? {
+			siteTotal: siteTotal && builtIn ? {
 				...siteTotal,
-				model: TRAFFIC_MODEL[provider]
+				model: TRAFFIC_MODEL[builtIn]
 			} : null,
 			available: available ?? null,
 			country,
@@ -48239,6 +48285,7 @@ async function runResearch(input, keys, options) {
 			partial,
 			missedKeywords: missed,
 			noDataKeywords: noData,
+			...warnings?.length ? { warnings } : {},
 			...input.action === "link_gap" ? {
 				competitors: input.competitors ?? [],
 				cutAt: floor ?? null,
@@ -48255,6 +48302,7 @@ async function runResearch(input, keys, options) {
 	};
 }
 function positionNote(provider) {
+	if (provider !== "dataforseo" && provider !== "ahrefs") return `position is the organic position the ${provider} package reports (its rankGroup); rank_absolute is its rank among every block on the page, and type is featured_snippet for a featured snippet, which has no organic position.`;
 	return provider === "dataforseo" ? "position is the organic position: the nth organic link (DataForSEO rank_group). rank_absolute counts every block on the page from the top, AI Overviews, People Also Ask, videos and images included, so it is higher. A featured snippet has type featured_snippet and no organic position." : "position is the organic position: the nth row Ahrefs marks organic. ahrefs_position is Ahrefs' own position field, and type lists what each row is.";
 }
 function aiOverviewNote(overviews, keywords) {
@@ -49271,7 +49319,7 @@ const SHARED_TOOLS = [
 		title: "Keyword, competitor, backlink and AI answer data",
 		description: `Data from the person’s own DataForSEO or Ahrefs account, which costs them credits. It uses the key the person saved on their seoskill.dev account (or on this machine for the CLI). Actions: ${RESEARCH_HELP}`,
 		input: z.object({
-			provider: z.enum(RESEARCH_PROVIDERS).optional().describe("Optional. Without it, the saved key; DataForSEO when both are saved."),
+			provider: z.string().max(64).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/).optional().describe(`${RESEARCH_PROVIDERS.join(" or ")}. Optional: without it, the saved key; DataForSEO when both are saved. For serp in the CLI and the local MCP server it can also be the id of an installed provider package with live search results.`),
 			action: z.enum(RESEARCH_ACTIONS),
 			keywords: z.array(z.string().min(1)).max(100).default([]),
 			target: z.string().default("").describe("Domain (the whole site), a path ending in / for every URL under it, such as example.com/blog/, or one page."),
@@ -49288,7 +49336,7 @@ const SHARED_TOOLS = [
 		run: async (surface, input) => {
 			const more = (offset) => `seo_research with the same input, detail "rows", offset ${offset}`;
 			if (input.action === "ai_answers") {
-				if (input.provider === "ahrefs") throw new CommandError("INVALID_INPUT", "ai_answers uses dataforseo.");
+				if (input.provider && input.provider !== "dataforseo") throw new CommandError("INVALID_INPUT", "ai_answers uses dataforseo.");
 				return runAiAnswers({
 					site: input.keywords.length || input.tasks.length ? input.target : await surface.resolveSite(input.target),
 					country: input.country,
@@ -49303,6 +49351,7 @@ const SHARED_TOOLS = [
 			return runResearch(input, await surface.keys(), {
 				drKey: surface.drKey,
 				store: surface.researchStore,
+				installedSerp: surface.installedSerp,
 				call: more
 			});
 		}
@@ -50265,6 +50314,133 @@ z.object({ packages: z.record(z.string(), z.object({
 	version: providerExactVersionSchema.optional(),
 	integrity: providerIntegritySchema.optional()
 }).passthrough()) }).passthrough();
+// packages/core/dist/provider-extensions/serp.js
+const nullableText = z.string().max(5e4).nullable();
+const serpSnapshotResultSchema = z.object({
+	observedAt: z.string().max(100),
+	effectiveKeyword: z.string().trim().min(1).max(1e3),
+	searchEngineDomain: z.string().max(253).nullable(),
+	checkUrl: z.url().max(8192).nullable(),
+	resultCount: z.number().int().nonnegative().safe().nullable(),
+	pagesCount: z.number().int().nonnegative().max(100).safe().nullable(),
+	features: z.array(z.string().trim().min(1).max(100)).max(100),
+	organicResults: z.array(z.object({
+		rankGroup: z.number().int().positive().safe(),
+		rankAbsolute: z.number().int().positive().safe(),
+		page: z.number().int().positive().max(100).safe(),
+		domain: z.string().trim().min(1).max(253),
+		url: z.url().max(8192),
+		title: z.string().max(1e4).nullable(),
+		description: nullableText,
+		isFeaturedSnippet: z.boolean().nullable()
+	}).strict()).max(100),
+	localPack: z.object({
+		present: z.boolean(),
+		returnedRows: z.number().int().nonnegative().max(100).safe(),
+		retainedRows: z.number().int().nonnegative().max(100).safe(),
+		invalidRows: z.number().int().nonnegative().max(100).safe(),
+		results: z.array(z.unknown()).max(100)
+	}).strict(),
+	coverage: z.object({
+		returnedRows: z.number().int().nonnegative().max(1e4).safe(),
+		retainedRows: z.number().int().nonnegative().max(100).safe(),
+		invalidRows: z.number().int().nonnegative().max(1e4).safe(),
+		providerTotalRows: z.number().int().nonnegative().safe().nullable(),
+		completeness: z.enum([
+			"complete",
+			"partial",
+			"capped"
+		]),
+		nextCursor: z.string().max(500).nullable()
+	}).strict(),
+	request: z.object({
+		endpoint: z.string().trim().min(1).max(500),
+		filters: z.record(z.string().min(1).max(100), z.union([
+			z.string().max(1e3),
+			z.number().finite(),
+			z.boolean()
+		])),
+		sort: z.array(z.string().min(1).max(200)).max(20)
+	}).strict(),
+	cost: z.object({
+		estimatedMicros: z.number().int().nonnegative().safe().nullable(),
+		actualMicros: z.number().int().nonnegative().safe().nullable(),
+		taskIds: z.array(z.string().min(1).max(500)).max(20),
+		native: z.object({
+			unit: z.string().trim().min(1).max(100),
+			estimatedUnits: z.number().finite().nonnegative().nullable(),
+			actualUnits: z.number().finite().nonnegative().nullable(),
+			remainingBefore: z.number().finite().nonnegative().nullable()
+		}).strict().optional()
+	}).strict(),
+	qualityWarnings: z.array(z.object({
+		code: z.string().trim().min(1).max(100),
+		message: z.string().trim().min(1).max(500),
+		field: z.string().max(200).optional(),
+		row: z.number().int().positive().safe().optional()
+	}).strict()).max(50)
+}).strict();
+const same = (list, value) => !list || list.some((item) => item.toLowerCase() === value.toLowerCase());
+function supports(capability, market) {
+	return capability.markets.some((entry) => same(entry.searchEngines, market.searchEngine) && same(entry.countryCodes, market.countryCode) && same(entry.languageCodes, market.languageCode) && same(entry.devices, market.device ?? "desktop"));
+}
+const installedProviderSerp = async (input) => {
+	const loaded = await loadProviderExtensions();
+	const provider = loaded.registry.get(input.provider);
+	if (!provider) throw new CommandError("INVALID_INPUT", `No provider ${input.provider} is installed. The built-in providers are dataforseo and ahrefs; \`seo providers list\` shows installed packages.`);
+	const capability = loaded.registry.capability(provider.id, "serp-snapshot");
+	if (!capability) throw new CommandError("INVALID_INPUT", `${provider.displayName} has no live search results (serp-snapshot), so it cannot answer serp. \`seo providers describe ${provider.id}\` lists its own actions.`);
+	const market = {
+		searchEngine: "google",
+		countryCode: input.country.toUpperCase(),
+		languageCode: input.language,
+		device: input.device
+	};
+	if (!supports(capability, market)) throw new CommandError("INVALID_INPUT", `${provider.displayName} has no ${input.device} Google results for country ${input.country} in language ${input.language}.`);
+	let account;
+	let credentials;
+	try {
+		account = normalizeProviderExtensionAccount(provider, readProviderExtensionAccount(provider.id));
+		credentials = await readProviderExtensionCredentials({
+			providerId: provider.id,
+			account,
+			fields: provider.connection.fields
+		});
+	} catch (error) {
+		throw new CommandError("NO_KEY", `${error instanceof Error ? error.message : String(error)} Connect it with \`seo providers connect ${provider.id}\`.`);
+	}
+	const depth = Math.min(input.depth, capability.maxDepth);
+	let raw;
+	try {
+		raw = await capability.run({
+			account,
+			credentials,
+			keyword: input.keyword,
+			market,
+			depth
+		}, runtimeForProvider(provider.id, { maxRequests: capability.maxRequests }));
+	} catch (error) {
+		throw new CommandError("PROVIDER_ERROR", safeProviderAdapterError(provider.id, error, credentials).message);
+	}
+	const parsed = serpSnapshotResultSchema.safeParse(raw);
+	if (!parsed.success) throw new CommandError("PROVIDER_ERROR", `${provider.displayName} returned a results page that does not match the serp-snapshot shape.`);
+	const result = parsed.data;
+	const warnings = result.qualityWarnings.map((warning) => warning.message);
+	return {
+		rows: [...result.organicResults].sort((a, b) => a.rankAbsolute - b.rankAbsolute || (a.url < b.url ? -1 : 1)).map((item) => ({
+			position: item.isFeaturedSnippet ? null : item.rankGroup,
+			rank_absolute: item.rankAbsolute,
+			type: item.isFeaturedSnippet ? "featured_snippet" : "organic",
+			url: item.url,
+			domain: item.domain,
+			title: item.title
+		})),
+		costMicros: result.cost.actualMicros,
+		partial: result.coverage.completeness === "partial",
+		warnings,
+		depth
+	};
+};
 z.object({ limits_and_usage: z.object({
 	api_key_expiration_date: z.string().trim().min(1).max(100),
 	subscription: z.string().trim().min(1).max(200),
@@ -53054,6 +53230,7 @@ function registerSharedTools(server, options = {}) {
 		refreshClicky: localRefreshClicky,
 		drKey: null,
 		researchStore: localResearchStore(),
+		installedSerp: installedProviderSerp,
 		accounts: localAccounts,
 		signIn: LOCAL_SIGN_IN.signIn,
 		connect: "run `seo login` to use your seoskill.dev account (Google, Bing and keys in one place), or `seo auth login`, `seo providers bing connect` and `seo providers dataforseo connect` or `seo providers ahrefs connect` on this machine only.",