@getvitops/cli 2.0.0 → 3.0.0

package/dist/cli.mjs

@@ -4,8 +4,10 @@ import { parseArgs } from "node:util";
 import { existsSync, lstatSync, mkdirSync, readFileSync, readlinkSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { dirname, join, parse, relative, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
-import { NUMERIC_STEPS, SCHEMA_URL, buildIconSprite, defaultConfig, enabledDocs, expandPalette, functionalRole, generate, generateDocs, generateLegal, isSiteConfig, resolveInput, resolveSiteConfig, resolveTheme, roleColorUtilities, roleHue, roleKind, validate } from "@getvitops/generator";
+import { NUMERIC_STEPS, SCHEMA_URL, buildIconSprite, defaultConfig, enabledDocs, expandPalette, functionalRole, generate, generateDocs, generateLegal, isConfig, resolveConfig, resolveInput, resolveTheme, roleColorUtilities, roleHue, roleKind, validate } from "@getvitops/generator";
 import { collectIconRefs, generateFavicons, generateIconInclude, resolveIcon, scanFiles } from "@getvitops/utils";
+import { SNAPSHOT_PATH, collectEntries, formatPlan, getAccessToken, inspectUrl, keyFileContents, newKey, parseServiceAccount, plan, readSnapshot, resolveKeyLocation, resolveSitemapUrl, submitBatch, submitSitemap, toSnapshot, verifyKeyFile, writeSnapshot } from "@getvitops/utils/indexing";
+import { MEDIA_MANIFEST_PATH, formatPlan as formatPlan$1, processMedia } from "@getvitops/utils/media";
 
 //#region src/agents.ts
 /**
@@ -28,6 +30,10 @@ const TOPICS = {
 		path: "authoring.md",
 		summary: "every design-system.json field, rendered from the JSON Schema"
 	},
+	config: {
+		path: "config.md",
+		summary: "every field of the three-section config (designSystem / organization / site), rendered from the JSON Schema"
+	},
 	formats: {
 		path: "formats.md",
 		summary: "tailwind vs css vs bricks: what's emitted vs what the platform provides"
@@ -530,6 +536,8 @@ function lintSource(files, v, format) {
 *   vitops docs      [topic] [--input <json>] [--all]
 *   vitops lint      [--input <json>] [--format <fmt>] [--src <dir>]
 *   vitops legal     [--input <site.json>] [--doc <name>] [--format <md|html|portable-text>] [--out <dir>]
+*   vitops indexing  [--input <site.json>] [--dry] [--all] [--check]
+*   vitops media     [--raw <dir>] [--out <dir>] [--force] [--dry]
 *
 * Thin wrapper over @getvitops/generator (generation) and @getvitops/utils (favicons).
 * Every client brings their own consumer-editable design-system.json.
@@ -572,6 +580,8 @@ Usage:
   vitops lint [options]         Report framework classes in your source that resolve to nothing
   vitops legal [options]        Render legal documents from a site config
   vitops icons [options]        Report which icons your source uses, and build the sprite
+  vitops indexing [options]    Tell search engines about a deploy (sitemap + IndexNow)
+  vitops media [options]       Encode raw video into web-ready WebM + MP4 + poster
 
 Generate options:
   -i, --input <path>    design-system.json or site config (default: ./design-system.json)
@@ -644,6 +654,56 @@ Legal options:
   Generated from your config — a starting point, not legal advice. Review before
   publishing, and make sure the config describes what your site actually does.
 
+Indexing options:
+  -i, --input <path>    Site config carrying seo.indexing (default: ./site.json)
+      --site-env <env>  Environment to notify for (default: production). An
+                        environment whose robots policy says noindex is refused.
+      --sitemap <src>   Sitemap URL or local path (default: from the config)
+      --urls <list>     Comma-separated URLs to submit, skipping the diff
+      --all             Submit every URL in the sitemap, not just what changed
+      --dry             Print the plan and exit. Makes no requests.
+      --check           Read-only: ask Google whether seo.indexing.priorityUrls
+                        are indexed. Exits non-zero if one is not.
+      --new-key         Print a fresh IndexNow key and exit
+      --write-key <dir> Write the IndexNow key file into <dir> (for stacks with
+                        no Astro integration to do it — Bricks, WordPress)
+      --snapshot <path> Changed-URL state file (default: .vitops/sitemap-snapshot.json).
+                        Persist it between runs (a CI cache) or every run submits
+                        everything.
+
+  What this can and cannot do: Google exposes no "request indexing" API, and its
+  sitemap ping endpoint was removed in 2023 — so it resubmits your sitemap
+  through the Search Console API and verifies the result with --check. IndexNow
+  reaches Bing, Yandex, Naver, Seznam and Yep; Google does not participate.
+  Search Console needs a service account in VITOPS_GSC_SERVICE_ACCOUNT (inline
+  JSON) or GOOGLE_APPLICATION_CREDENTIALS (a path), added as an owner of the
+  property.
+
+Media options:
+      --raw <dir>       Directory of unprocessed video, walked recursively
+                        (default: ./raw)
+  -o, --out <dir>       Where the encoded outputs go (default: ./src/assets/processed).
+                        Subdirectories under --raw are preserved.
+      --max-width <px>  Cap the output width, keeping aspect ratio (default: 1920;
+                        0 disables scaling)
+      --crf <n>         Quality on VP9's scale, 0-63, lower is better (default: 32).
+                        The MP4 fallback uses the equivalent on H.264's scale.
+      --max-bitrate <r> Optional ceiling, e.g. 2M or 800k (default: none, which is
+                        constant quality rather than constrained)
+      --audio           Keep the audio track (default: dropped — the common case is
+                        a muted autoplay loop)
+      --poster-time <s> Timestamp the poster frame is taken from (default: 0, which
+                        is often black on a clip that fades in)
+      --outputs <list>  Comma-separated: webm | mp4 | poster (default: all three)
+      --manifest <path> Cache file (default: .vitops/media-manifest.json)
+      --force           Re-encode everything, ignoring the cache
+      --dry             Print the plan and exit. Encodes nothing.
+
+  Needs ffmpeg on PATH — it is an external tool, not an npm dependency, and this
+  command fails rather than quietly skipping. Commit the outputs and the manifest:
+  ffmpeg output is not reproducible across versions, so re-encoding in CI churns
+  the diff on every toolchain bump. Use --force when you mean to re-encode.
+
 Common:
   -h, --help            Show this help
 `;
@@ -748,10 +808,10 @@ function cmdValidate(argv) {
 	} catch (err) {
 		fail(`could not parse JSON: ${err.message}`);
 	}
-	if (isSiteConfig(raw)) {
+	if (isConfig(raw)) {
 		let site;
 		try {
-			site = resolveSiteConfig(raw, values["site-env"]);
+			site = resolveConfig(raw, values["site-env"]);
 		} catch (err) {
 			console.error(`✖ ${path} is invalid as a site config:`);
 			console.error(err.message.replace(/^Invalid site config:\n/, ""));
@@ -815,6 +875,99 @@ async function cmdFavicon(argv) {
 		fail(err.message);
 	}
 }
+const OUTPUT_KINDS = new Set([
+	"webm",
+	"mp4",
+	"poster"
+]);
+/**
+* `vitops media` — encode a directory of raw video into web-ready outputs.
+*
+* Flags only, with no config file, following `favicon`: `site.favicon` exists in
+* the schema and `cmdFavicon` still doesn't read it. The same reasoning applies
+* more strongly here — `legal`, `icons` and `indexing` are anchored to a
+* `Config` because what they emit *describes the site*, and an encoder setting
+* describes a build step.
+*/
+async function cmdMedia(argv) {
+	const { values } = parseArgs({
+		args: argv,
+		options: {
+			raw: {
+				type: "string",
+				default: "raw"
+			},
+			out: {
+				type: "string",
+				short: "o",
+				default: "src/assets/processed"
+			},
+			"max-width": { type: "string" },
+			crf: { type: "string" },
+			"max-bitrate": { type: "string" },
+			audio: {
+				type: "boolean",
+				default: false
+			},
+			"poster-time": { type: "string" },
+			outputs: { type: "string" },
+			manifest: {
+				type: "string",
+				default: MEDIA_MANIFEST_PATH
+			},
+			force: {
+				type: "boolean",
+				default: false
+			},
+			dry: {
+				type: "boolean",
+				default: false
+			}
+		},
+		allowPositionals: false
+	});
+	const num = (flag, raw) => {
+		if (raw === void 0) return void 0;
+		const n = Number(raw);
+		if (!Number.isFinite(n) || n < 0) fail(`media: --${flag} must be a non-negative number`);
+		return n;
+	};
+	let outputs;
+	if (values.outputs) {
+		outputs = values.outputs.split(",").map((s) => s.trim());
+		for (const kind of outputs) if (!OUTPUT_KINDS.has(kind)) fail(`media: unknown output "${kind}" (expected: webm | mp4 | poster)`);
+	}
+	const maxWidth = num("max-width", values["max-width"]);
+	const crf = num("crf", values.crf);
+	const posterTime = num("poster-time", values["poster-time"]);
+	const config = {
+		...maxWidth !== void 0 ? { maxWidth } : {},
+		...crf !== void 0 ? { crf } : {},
+		...values["max-bitrate"] ? { maxBitrate: values["max-bitrate"] } : {},
+		...values.audio ? { audio: true } : {},
+		...posterTime !== void 0 ? { posterTime } : {},
+		...outputs ? { outputs } : {}
+	};
+	try {
+		const result = await processMedia({
+			raw: values.raw,
+			out: values.out,
+			config,
+			manifest: values.manifest,
+			force: values.force,
+			dry: values.dry,
+			onProgress: (message) => console.error(`  … ${message}`)
+		});
+		if (values.dry) {
+			console.log(formatPlan$1(result.plan));
+			return;
+		}
+		console.log(`✓ media → ${values.out} (${result.written.length} written, ${result.skipped} unchanged)`);
+		for (const note of result.plan.notes) console.error(`  ! ${note}`);
+	} catch (err) {
+		fail(err.message);
+	}
+}
 /**
 * Read + parse + validate the design system at `path`, or exit with a message.
 *
@@ -824,7 +977,7 @@ async function cmdFavicon(argv) {
 * `company.json` doesn't have to maintain a second file for the tooling's sake.
 * `resolveInput` tells them apart by shape and resolves the theme.
 */
-function loadConfig(path, theme) {
+function loadDesignSystem(path, theme) {
 	if (!existsSync(path)) fail(`config not found: ${path}`);
 	let raw;
 	try {
@@ -852,11 +1005,11 @@ function loadConfig(path, theme) {
 * Read + resolve a site config, or exit with a message.
 *
 * Accepts JSON, or a JS/TS module with a default export — deliberately not YAML,
-* which would mean a parser dependency for one command. `resolveSiteConfig` is
+* which would mean a parser dependency for one command. `resolveConfig` is
 * documented as taking an already-parsed object precisely so the loader is the
 * consumer's choice; anyone on YAML can convert it or export from a module.
 */
-async function loadSiteConfig(path, siteEnv) {
+async function loadConfig(path, siteEnv) {
 	if (!existsSync(path)) fail(`site config not found: ${path}`);
 	let raw;
 	if (/\.(json)$/.test(path)) try {
@@ -873,7 +1026,7 @@ async function loadSiteConfig(path, siteEnv) {
 		if (raw == null) fail(`${path} has no default export`);
 	}
 	try {
-		return resolveSiteConfig(raw, siteEnv);
+		return resolveConfig(raw, siteEnv);
 	} catch (err) {
 		fail(err.message);
 	}
@@ -891,7 +1044,7 @@ async function loadSiteConfig(path, siteEnv) {
 * sprite from it.
 *
 * A sibling of `legal` rather than a widening of `lint`: `lint` judges classes
-* against a design-system.json, whereas icons are anchored to a SiteConfig.
+* against a design-system.json, whereas icons are anchored to a Config.
 *
 * Exit codes carry the same distinction the Astro integration makes. A name the
 * config DECLARES but that doesn't resolve is a config error and fails the
@@ -933,7 +1086,7 @@ async function cmdIcons(argv) {
 		allowPositionals: false
 	});
 	const sitePath = resolve(values.site);
-	const icons = existsSync(sitePath) ? (await loadSiteConfig(sitePath, values["site-env"])).icons ?? {} : {};
+	const icons = existsSync(sitePath) ? (await loadConfig(sitePath, values["site-env"])).site.icons ?? {} : {};
 	const ui = icons.ui ?? "fa7-solid";
 	const brand = icons.brand ?? "simple-icons";
 	const weight = icons.weight;
@@ -1042,9 +1195,9 @@ async function cmdLegal(argv) {
 	if (!LEGAL_OUTPUTS.has(output)) fail(`unknown format "${output}" (expected: ${[...LEGAL_OUTPUTS].join(" | ")})`);
 	const requested = values.doc ?? [];
 	for (const d of requested) if (!LEGAL_DOCS.has(d)) fail(`unknown doc "${d}" (expected: ${[...LEGAL_DOCS].join(" | ")})`);
-	const site = await loadSiteConfig(resolve(values.input), values["site-env"]);
+	const site = await loadConfig(resolve(values.input), values["site-env"]);
 	const docs = requested.length ? requested : enabledDocs(site);
-	if (docs.length === 0) fail("no legal documents are enabled — set legal.privacyPolicy.enabled (or termsOfService / cookieConsent) in your site config, or name one with --doc");
+	if (docs.length === 0) fail("no legal documents are enabled — set site.legal.privacyPolicy.enabled (or termsOfService / cookieConsent) in your config, or name one with --doc");
 	const files = generateLegal(site, {
 		docs,
 		output
@@ -1059,6 +1212,210 @@ async function cmdLegal(argv) {
 	console.log(`✓ legal → ${outDir} (${Object.keys(files).length} files)`);
 	console.log("  These are generated from your config and are not legal advice — review them before publishing.");
 }
+/**
+* Adapt a `Config` to the indexing module's own option shape.
+*
+* A flat field map, as intended: `@getvitops/utils` cannot import from the
+* generator (the generator already depends on it), so `IndexingConfig` mirrors the
+* `seo.indexing` block rather than being it. The one piece of judgment here is the
+* origin — see below.
+*/
+function toIndexingConfig(cfg, siteEnv) {
+	const site = cfg.site;
+	const indexing = site.seo?.indexing ?? {};
+	const env = site.environments?.[siteEnv];
+	const canonical = env?.url ?? site.domains?.canonical;
+	return {
+		...canonical ? { canonical } : {},
+		...indexing.sitemapUrl ? { sitemapUrl: indexing.sitemapUrl } : {},
+		...indexing.indexNow ? { indexNow: indexing.indexNow } : {},
+		...indexing.searchConsole ? { searchConsole: indexing.searchConsole } : {},
+		...indexing.priorityUrls ? { priorityUrls: indexing.priorityUrls } : {},
+		...env?.robots ?? site.seo?.robots ? { robots: env?.robots ?? site.seo?.robots } : {}
+	};
+}
+/**
+* The Search Console credential, from either supported source.
+*
+* Never from the config file: it is the one genuine secret in this command, and a
+* `site.json` is committed. Returns `undefined` rather than failing, so a site
+* running IndexNow alone doesn't need a GCP project at all.
+*/
+function loadServiceAccount() {
+	const inline = process.env.VITOPS_GSC_SERVICE_ACCOUNT;
+	const path = process.env.GOOGLE_APPLICATION_CREDENTIALS;
+	const raw = inline ?? (path && existsSync(path) ? readFileSync(path, "utf8") : void 0);
+	if (!raw) return void 0;
+	try {
+		return parseServiceAccount(raw);
+	} catch (err) {
+		fail(`${inline ? "VITOPS_GSC_SERVICE_ACCOUNT" : `GOOGLE_APPLICATION_CREDENTIALS (${path})`}: ${err.message}`);
+	}
+}
+/** Read a sitemap from a URL or a local path. */
+const readSitemap = async (source) => {
+	if (/^https?:\/\//i.test(source)) {
+		const res = await fetch(source);
+		if (!res.ok) fail(`could not fetch ${source}: ${res.status}`);
+		return res.text();
+	}
+	if (!existsSync(source)) fail(`sitemap not found: ${source}`);
+	return readFileSync(source, "utf8");
+};
+/**
+* Tell search engines a deploy happened.
+*
+* Worth being precise about what this is, because the obvious expectation is
+* wrong: **Google has no API that requests indexing.** The Search Console button
+* is not exposed anywhere, URL Inspection is read-only, and the sitemap ping
+* endpoint was removed in 2023. So the Google half of this command resubmits the
+* sitemap and then *verifies* the outcome with `--check`; the immediate-push half
+* is IndexNow, which Google does not participate in.
+*
+* The Indexing API is deliberately absent — see `@getvitops/utils/indexing`'s
+* `gsc.ts`.
+*/
+async function cmdIndexing(argv) {
+	const { values } = parseArgs({
+		args: argv,
+		options: {
+			input: {
+				type: "string",
+				short: "i",
+				default: "site.json"
+			},
+			"site-env": {
+				type: "string",
+				default: "production"
+			},
+			sitemap: { type: "string" },
+			urls: { type: "string" },
+			all: {
+				type: "boolean",
+				default: false
+			},
+			dry: {
+				type: "boolean",
+				default: false
+			},
+			check: {
+				type: "boolean",
+				default: false
+			},
+			"new-key": {
+				type: "boolean",
+				default: false
+			},
+			"write-key": { type: "string" },
+			snapshot: {
+				type: "string",
+				default: SNAPSHOT_PATH
+			}
+		},
+		allowPositionals: false
+	});
+	if (values["new-key"]) {
+		const key = newKey();
+		console.log(key);
+		console.log(`\n  Add to your site config:\n    "seo": { "indexing": { "indexNow": { "key": "${key}" } } }`);
+		console.log(`  Then serve it at /${key}.txt — \`vitops indexing --write-key public\`.`);
+		return;
+	}
+	const config = toIndexingConfig(await loadConfig(resolve(values.input), values["site-env"]), values["site-env"]);
+	if (values["write-key"] !== void 0) {
+		const key = config.indexNow?.key;
+		if (!key) fail("no site.seo.indexing.indexNow.key in the config — generate one with --new-key");
+		const dir = resolve(values["write-key"]);
+		mkdirSync(dir, { recursive: true });
+		const file = join(dir, `${key}.txt`);
+		writeFileSync(file, keyFileContents(key));
+		console.log(`✓ IndexNow key file → ${file}`);
+		console.log(`  It must be served at ${resolveKeyLocation(config) ?? `/${key}.txt`}`);
+		return;
+	}
+	const sitemapUrl = values.sitemap ?? resolveSitemapUrl(config);
+	if (!sitemapUrl) fail("no sitemap to read — set seo.indexing.sitemapUrl or domains.canonical, or pass --sitemap");
+	const explicitUrls = values.urls ? values.urls.split(",").map((u) => u.trim()).filter(Boolean) : void 0;
+	const current = explicitUrls?.length && !values.check ? [] : (await collectEntries(sitemapUrl, readSitemap)).entries;
+	const snapshotPath = resolve(values.snapshot);
+	const p = plan({
+		config: {
+			...config,
+			sitemapUrl
+		},
+		current,
+		previous: readSnapshot(snapshotPath),
+		explicitUrls,
+		all: values.all
+	});
+	console.log(formatPlan(p));
+	if (p.blocked) return;
+	if (values.dry) {
+		console.log("\n(--dry: nothing was submitted)");
+		return;
+	}
+	const account = loadServiceAccount();
+	let failed = false;
+	if (values.check) {
+		if (!p.searchConsole.siteUrl) fail("--check needs seo.indexing.searchConsole.siteUrl (the Search Console property)");
+		if (!account) fail("--check needs a Search Console service account in VITOPS_GSC_SERVICE_ACCOUNT or GOOGLE_APPLICATION_CREDENTIALS");
+		if (p.check.length === 0) fail("--check needs seo.indexing.priorityUrls — the pages whose indexing matters");
+		const token = await getAccessToken(account);
+		console.log(`\nInspecting ${p.check.length} priority URL(s):`);
+		for (const url of p.check) {
+			const r = await inspectUrl(token, p.searchConsole.siteUrl, url);
+			if (r.error) {
+				console.log(`  ? ${url} — ${r.error}`);
+				failed = true;
+			} else {
+				console.log(`  ${r.indexed ? "✓" : "✗"} ${url} — ${r.coverageState ?? r.verdict ?? "unknown"}`);
+				if (!r.indexed) failed = true;
+			}
+		}
+		if (failed) {
+			console.error("\n✖ one or more priority URLs are not indexed");
+			process.exit(1);
+		}
+		console.log("\n✓ every priority URL is indexed");
+		return;
+	}
+	if (p.indexNow.enabled) {
+		const { key, keyLocation } = p.indexNow;
+		const check = await verifyKeyFile(keyLocation, key);
+		if (!check.ok) {
+			console.error(`✖ IndexNow key file check failed — ${check.reason}`);
+			console.error(`  Write it with: vitops indexing --write-key <public dir>`);
+			failed = true;
+		} else {
+			let sent = 0;
+			for (const batch of p.indexNow.batches) {
+				const r = await submitBatch(p.indexNow, batch);
+				if (!r.ok) {
+					console.error(`✖ IndexNow: ${r.message ?? r.status}`);
+					failed = true;
+					break;
+				}
+				sent += r.urls;
+			}
+			if (!failed) console.log(`✓ IndexNow: ${sent} URL(s) submitted`);
+		}
+	}
+	if (p.searchConsole.enabled) if (!account) console.log("· Search Console: skipped — no VITOPS_GSC_SERVICE_ACCOUNT / GOOGLE_APPLICATION_CREDENTIALS");
+	else {
+		const r = await submitSitemap(await getAccessToken(account), p.searchConsole.siteUrl, sitemapUrl);
+		if (r.ok) console.log(`✓ Search Console: sitemap resubmitted`);
+		else {
+			console.error(`✖ Search Console: ${r.message}`);
+			failed = true;
+		}
+	}
+	if (failed) process.exit(1);
+	if (current.length > 0) {
+		writeSnapshot(snapshotPath, toSnapshot(sitemapUrl, current, (/* @__PURE__ */ new Date()).toISOString()));
+		console.log(`  state → ${relative(process.cwd(), snapshotPath)}`);
+	}
+	if (p.check.length > 0) console.log(`\n  Indexing is not instant. Run \`vitops indexing --check\` in a day or two to see what Google actually did.`);
+}
 function cliVersion() {
 	try {
 		return JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version ?? "0.0.0";
@@ -1096,7 +1453,7 @@ function cmdDocs(argv) {
 		return;
 	}
 	if (topic && !TOPICS[topic]) fail(`unknown topic "${topic}". Valid topics:\n${topicList()}`);
-	const docs = generateDocs(loadConfig(resolve(values.input), values.theme), generatorAssetsDir());
+	const docs = generateDocs(loadDesignSystem(resolve(values.input), values.theme), generatorAssetsDir());
 	const paths = values.all ? Object.values(TOPICS).map((t) => t.path) : [TOPICS[topic].path];
 	process.stdout.write(paths.map((p) => docs[p]).join("\n"));
 }
@@ -1129,7 +1486,7 @@ function cmdLint(argv) {
 	});
 	const format = values.format;
 	if (!LINT_FORMATS.has(format)) fail(`unknown format "${format}" (expected: bricks | css | tailwind)`);
-	const ds = loadConfig(resolve(values.input), values.theme);
+	const ds = loadDesignSystem(resolve(values.input), values.theme);
 	const srcDir = resolve(values.src);
 	if (!existsSync(srcDir)) fail(`source directory not found: ${srcDir}`);
 	const palette = expandPalette(ds.colors.palette);
@@ -1182,7 +1539,7 @@ function cmdAgents(argv) {
 	});
 	const inputRel = values.input;
 	let ds = null;
-	if (existsSync(resolve(inputRel))) ds = loadConfig(resolve(inputRel), values.theme);
+	if (existsSync(resolve(inputRel))) ds = loadDesignSystem(resolve(inputRel), values.theme);
 	else console.warn(`  ⚠ ${inputRel} not found — run \`vitops init\` to scaffold one`);
 	const legacyDocsDir = values["docs-dir"];
 	let summary;
@@ -1284,7 +1641,9 @@ async function main() {
 		case "lint": return cmdLint(rest);
 		case "legal": return cmdLegal(rest);
 		case "icons": return cmdIcons(rest);
-		default: fail(`unknown command "${command}" (expected: generate | init | validate | favicon | agents | docs | lint | legal | icons). Try: vitops --help`);
+		case "indexing": return cmdIndexing(rest);
+		case "media": return cmdMedia(rest);
+		default: fail(`unknown command "${command}" (expected: generate | init | validate | favicon | agents | docs | lint | legal | icons | indexing | media). Try: vitops --help`);
 	}
 }
 main().catch((err) => fail(err.message));