@getvitops/utils 2.0.0 → 2.1.0

package/CHANGELOG.md

@@ -1,5 +1,119 @@
 # @getvitops/utils
 
+## 2.1.0
+
+### Minor Changes
+
+- 20e518e: Add `vitops indexing` — tell search engines about a deploy, instead of opening Search Console by hand.
+
+  Configure it in your site config under `seo.indexing`, then run it after deploying:
+
+  ```jsonc
+  "seo": {
+    "indexing": {
+      "indexNow": { "key": "…" },
+      "searchConsole": { "siteUrl": "sc-domain:acme.ca" },
+      "priorityUrls": ["https://acme.ca/", "https://acme.ca/services"]
+    }
+  }
+  ```
+
+  ```
+  vitops indexing --dry     # print the plan, make no requests
+  vitops indexing           # submit
+  vitops indexing --check   # a day or two later: did Google actually index them?
+  ```
+
+  It reads your sitemap, diffs it against the previous run, and submits only what changed —
+  pinging **IndexNow** and re-submitting your sitemap through the **Search Console API**.
+  `--check` inspects `priorityUrls` and exits non-zero on a page Google hasn't indexed, so a
+  scheduled CI job can catch a page that quietly fell out of the index.
+
+  **Be clear-eyed about what this can do.** Google exposes no API that requests indexing — the
+  button in Search Console isn't available anywhere, URL Inspection is read-only, and the sitemap
+  ping endpoint was removed in 2023. IndexNow reaches Bing, Yandex, Naver, Seznam and Yep; Google
+  doesn't participate. So this automates every sanctioned step and then verifies the outcome; it
+  does not make Google re-index on demand, and nothing can. Google's Indexing API is deliberately
+  not wired: it's scoped to job postings and livestreams, and using it for ordinary pages violates
+  its terms.
+
+  Also new, and worth wiring at the same time — **`gitLastmod()` for real sitemap dates**:
+
+  ```js
+  import vitops, { gitLastmod } from '@getvitops/astro';
+  vitops({ sitemap: { serialize: await gitLastmod() } });
+  ```
+
+  `@astrojs/sitemap` emits no `<lastmod>` by default, which means a crawler is told your pages
+  exist but never that one changed — and it's what lets `vitops indexing` submit a handful of URLs instead
+  of all of them. `gitLastmod()` derives each date from the source file's last commit, and leaves a
+  page alone rather than guessing (dynamic routes, ambiguous slugs, shallow clones): an inaccurate
+  `lastmod` is worse than none, because Google stops trusting the field site-wide.
+
+  Requires `fetch-depth: 0` in CI — the default shallow clone has no history to read, and it warns
+  when that's the case.
+
+  **Credentials.** IndexNow's key is public by design (it's served at `/<key>.txt` as the ownership
+  proof), so it lives in your config, and the Astro integration writes the file into `public/` for
+  you — `vitops indexing --new-key` generates one, `--write-key <dir>` writes it for non-Astro stacks.
+  Search Console needs a service account in `VITOPS_GSC_SERVICE_ACCOUNT` or
+  `GOOGLE_APPLICATION_CREDENTIALS`, added as an owner of the property; it's never read from the
+  config file.
+
+  Persist `.vitops/` between runs (a CI cache) — that's the changed-URL state, and without it every
+  run submits everything.
+
+  An environment whose `robots` policy says `noindex` is refused outright, so pointing this at
+  staging can't publish it to a search engine.
+
+- 9bf975a: Add `vitops media` — encode raw video into web-ready outputs, instead of hand-rolling an ffmpeg
+  script per project.
+
+  Keep unprocessed video in a `raw/` directory and run:
+
+  ```
+  vitops media --raw raw --out src/assets/processed
+  ```
+
+  Each source becomes three files: **VP9/WebM**, an **H.264/MP4** fallback, and a **JPG poster**.
+  Import them like any other asset, so your bundler content-hashes them:
+
+  ```astro
+  ---
+  import hero from '../assets/processed/hero.webm';
+  import poster from '../assets/processed/hero.jpg';
+  ---
+  <video poster={poster.src} autoplay muted loop playsinline>
+    <source src={hero} type="video/webm" />
+  </video>
+  ```
+
+  In Astro it's an integration option — `vitops({ css, media: { raw: 'raw', out: 'src/assets/processed' } })`
+  — and it runs in the same pass that generates your CSS. `@getvitops/vite` gains a matching `media`
+  option, and `@getvitops/utils/media` exports `processMedia()` for anything else.
+
+  Defaults: capped at 1920px wide, CRF 32, audio dropped (the common case is a muted autoplay loop),
+  poster from frame 0. All of them are flags. `--dry` prints exactly what a run would do.
+
+  **Runs are cached**, on source content plus encode settings, in `.vitops/media-manifest.json` — a
+  24 MB clip that took 88 seconds the first time takes 0.14 seconds the second. A missing output
+  re-encodes; a corrupt manifest re-encodes everything. Neither ever reads as "already done", because
+  that failure is silent and no rebuild would fix it.
+
+  **Commit the outputs and the manifest.** A fresh CI clone has neither and would re-encode from
+  scratch; committing both means CI never needs ffmpeg. It also keeps your history clean — ffmpeg
+  output isn't byte-reproducible across versions, so a CI re-encode would rewrite every video on any
+  toolchain bump. Use `--force` when you mean to re-encode.
+
+  **`ffmpeg` is an external tool, not an npm dependency** — install it yourself (`brew install
+ffmpeg`, `apt install ffmpeg`, `winget install Gyan.FFmpeg`). The command fails without it rather
+  than skipping: a page referencing a video that was never encoded is broken, not degraded.
+
+  Two defaults worth knowing about. The MP4 exists because older iOS and the in-app webviews inside
+  social apps still don't decode VP9, and it's written with `+faststart` — without which a browser
+  downloads the whole file before showing frame one. And a poster taken from frame 0 is often black
+  on a clip that fades in; that's `--poster-time`, not a bug.
+
 ## 2.0.0
 
 ### Minor Changes

package/README.md

@@ -25,6 +25,39 @@ await generateFavicons({
 Also available via the CLI (`vitops favicon -i logo.svg -o public`) and the Vite plugin's
 `favicon` option.
 
+## Video encoding (`@getvitops/utils/media`)
+
+Encode a directory of raw video into VP9/WebM + an H.264/MP4 fallback + a JPG poster frame.
+
+```ts
+import { processMedia } from '@getvitops/utils/media';
+
+const { written, skipped } = await processMedia({
+  raw: 'raw',
+  out: 'src/assets/processed',
+  config: { maxWidth: 1920, crf: 32 },
+});
+```
+
+Its own subpath, like `./indexing`: it shells out to **`ffmpeg`**, which must be on `PATH`, and
+it throws rather than skipping when it isn't.
+
+Runs are cached in `.vitops/media-manifest.json` on source content and encode settings, so a
+second run costs a hash per file. `planMedia` decides all of it and touches no filesystem, which
+is what makes `dry: true` a complete account of a run rather than an approximation — the same
+split `./indexing` makes.
+
+Also available via the CLI (`vitops media`), the Vite plugin's `media` option, and
+`getvitops({ media })` in Astro. See the [CLI readme](https://www.npmjs.com/package/@getvitops/cli)
+for why the outputs are meant to be committed.
+
+## Search-engine notification (`@getvitops/utils/indexing`)
+
+The engine behind `vitops indexing`: sitemap parsing, the changed-URL diff against the previous
+run's snapshot, IndexNow submission, and the Search Console API calls (sitemap resubmit + read-only
+URL inspection). `plan()` is pure — no network, no filesystem, no clock — and `indexnow.ts` /
+`gsc.ts` execute a plan without deciding anything.
+
 ## Changelog
 
 This package's history: [`CHANGELOG.md`](./CHANGELOG.md) (shipped in the npm tarball, so it

package/dist/indexing/index.d.mts

@@ -0,0 +1,277 @@
+//#region src/indexing/types.d.ts
+/**
+ * The indexing module's own option surface.
+ *
+ * Deliberately structural rather than `SiteConfig['seo']['indexing']` imported
+ * from `@getvitops/generator`: the generator already depends on this package, so
+ * importing back would be a cycle. The vocabulary mirrors that block field for
+ * field, so the CLI's adapter is a flat map — the same arrangement, and for the
+ * same reason, as `GetvitopsSeoOptions` in `@getvitops/astro`.
+ */
+/** IndexNow submission settings. The key is public by design — see `key`. */
+interface IndexNowConfig {
+  /**
+   * The IndexNow key. **Not a secret**: the engine fetches it back from
+   * `keyLocation` to prove you control the host, so it is published either way.
+   */
+  key: string;
+  /** Absolute URL of the key file. Defaults to `<canonical>/<key>.txt`. */
+  keyLocation?: string | undefined;
+  /** Endpoint (default `https://api.indexnow.org/indexnow`). */
+  endpoint?: string | undefined;
+}
+/** Google Search Console property settings. The credential never lives here. */
+interface SearchConsoleConfig {
+  /** `sc-domain:acme.ca`, or the URL-prefix form `https://acme.ca/`. */
+  siteUrl: string;
+  /** Re-submit the sitemap on each run (default true). */
+  resubmitSitemap?: boolean | undefined;
+}
+/** Everything `plan()` needs to decide what to do. */
+interface IndexingConfig {
+  /** `domains.canonical` — the origin every default is derived from. */
+  canonical?: string | undefined;
+  /** Overrides the derived `<canonical>/sitemap-index.xml`. */
+  sitemapUrl?: string | undefined;
+  indexNow?: IndexNowConfig | undefined;
+  searchConsole?: SearchConsoleConfig | undefined;
+  /** Pages `--check` verifies. Explicit because URL Inspection is quota-bound. */
+  priorityUrls?: string[] | undefined;
+  /**
+   * The resolved environment's robots policy. A value containing `noindex` blocks
+   * the entire run — see `plan()`.
+   */
+  robots?: string | undefined;
+}
+/** One `<url>` (or `<sitemap>`) entry. */
+interface SitemapEntry {
+  loc: string;
+  lastmod?: string;
+}
+/** The previous run's sitemap state, as written by `writeSnapshot`. */
+interface Snapshot {
+  version: 1;
+  sitemapUrl: string;
+  takenAt: string;
+  /** `loc` → `lastmod`, or `''` when the entry carried none. */
+  entries: Record<string, string>;
+}
+//#endregion
+//#region src/indexing/plan.d.ts
+declare const INDEXNOW_ENDPOINT = "https://api.indexnow.org/indexnow";
+/**
+ * IndexNow's own cap per submission. Batches larger than this are split rather
+ * than truncated — a silently dropped tail is the failure mode this command is
+ * meant to eliminate, not reproduce.
+ */
+declare const INDEXNOW_BATCH = 10000;
+/** Why the URL set is what it is. */
+type UrlReason = 'explicit' | 'all' | 'cold' | 'diff';
+/** A channel's decision: on, or off with a stated reason. */
+interface ChannelPlan {
+  enabled: boolean;
+  /** Why it's off. Present iff `enabled` is false. */
+  skip?: string;
+}
+interface IndexNowPlan extends ChannelPlan {
+  endpoint: string;
+  keyLocation?: string | undefined;
+  key?: string | undefined;
+  host?: string | undefined;
+  /** URL batches, each within `INDEXNOW_BATCH`. */
+  batches: string[][];
+}
+interface SearchConsolePlan extends ChannelPlan {
+  siteUrl?: string | undefined;
+}
+interface IndexingPlan {
+  /** Set when the whole run is refused. Nothing is submitted. */
+  blocked?: string;
+  /** Always computed; `undefined` when nothing in the config resolves to one. */
+  sitemapUrl: string | undefined;
+  /** URLs that changed and should be submitted. */
+  urls: string[];
+  reason: UrlReason;
+  /** No usable previous snapshot — `urls` is everything. */
+  cold: boolean;
+  indexNow: IndexNowPlan;
+  searchConsole: SearchConsolePlan;
+  /** URLs `--check` will inspect. */
+  check: string[];
+  /** Things the operator needs to read. Printed by `--dry` and by a real run. */
+  notes: string[];
+}
+interface PlanInput {
+  config: IndexingConfig;
+  /** The sitemap as it stands now. */
+  current: SitemapEntry[];
+  /** The previous run's state, if any. */
+  previous?: Snapshot | undefined;
+  /** `--urls`: submit exactly these, skipping the diff. */
+  explicitUrls?: string[] | undefined;
+  /** `--all`: submit every URL in the sitemap. */
+  all?: boolean | undefined;
+}
+/**
+ * Resolve the sitemap URL.
+ *
+ * `sitemap-index.xml` is @astrojs/sitemap's default filename and is what
+ * `vitops({ sitemap })` registers, so it is the right default here. It resolves to
+ * a flat `<urlset>` on a small site, which `parseSitemap` handles by reading the
+ * root element rather than the name.
+ */
+declare function resolveSitemapUrl(config: IndexingConfig): string | undefined;
+/** Resolve the IndexNow key file URL. */
+declare function resolveKeyLocation(config: IndexingConfig): string | undefined;
+/**
+ * Decide what this run should do.
+ *
+ * Ordering of the URL-selection rules matters and is not arbitrary: an explicit
+ * `--urls` is an operator overriding the tool, `--all` is an operator overriding
+ * the diff, a cold snapshot is the tool having no basis to narrow, and the diff is
+ * the normal path. Each is reported in `reason` so `--dry` explains itself.
+ */
+declare function plan(input: PlanInput): IndexingPlan;
+/** Render a plan as the human-readable block `--dry` prints. */
+declare function formatPlan(p: IndexingPlan): string;
+//#endregion
+//#region src/indexing/sitemap.d.ts
+/** What a sitemap document turned out to be. */
+interface ParsedSitemap {
+  /** `<url>` entries, when this was a `<urlset>`. */
+  entries: SitemapEntry[];
+  /** Child sitemap URLs, when this was a `<sitemapindex>`. */
+  sitemaps: string[];
+}
+/**
+ * Parse a sitemap or sitemap index.
+ *
+ * Which one it is comes from the root element, not from the filename — an
+ * `sitemap-index.xml` that is actually a flat `<urlset>` is common enough
+ * (@astrojs/sitemap emits an index only past `entryLimit`) that keying on the name
+ * would misread the single-file case as "no URLs".
+ */
+declare function parseSitemap(xml: string): ParsedSitemap;
+/** Reads a sitemap from a URL or a local path. */
+type SitemapReader = (source: string) => Promise<string>;
+/**
+ * Resolve a sitemap to its full entry list, following an index one level down.
+ *
+ * One level is the whole spec — the sitemaps protocol forbids an index pointing at
+ * another index — so recursing further would only chase a malformed document.
+ * Child fetches run sequentially: a large site's index can list dozens of files,
+ * and hammering the consumer's own origin to save a second is a poor trade.
+ */
+declare function collectEntries(source: string, read: SitemapReader): Promise<{
+  entries: SitemapEntry[];
+  sources: string[];
+}>;
+//#endregion
+//#region src/indexing/snapshot.d.ts
+/** Default location, relative to the consumer's project root. */
+declare const SNAPSHOT_PATH = ".vitops/sitemap-snapshot.json";
+/**
+ * Read a snapshot, or `undefined` when there isn't a usable one.
+ *
+ * A corrupt or wrong-version file reads as absent, not as empty. The distinction
+ * matters: "absent" submits everything, whereas an empty entry map would look like
+ * a site that legitimately has no URLs and submit nothing — the silent-success
+ * failure this whole command exists to remove.
+ */
+declare function readSnapshot(path: string): Snapshot | undefined;
+/** Build a snapshot from the entries just read. */
+declare function toSnapshot(sitemapUrl: string, entries: SitemapEntry[], takenAt: string): Snapshot;
+/**
+ * Write the snapshot, creating its directory.
+ *
+ * Call this only after a submission actually succeeded. Writing it eagerly would
+ * record URLs as notified that never were, and because the next run diffs against
+ * it, those URLs would never be submitted again — a single transient 503 would
+ * silently drop a page from every future run.
+ */
+declare function writeSnapshot(path: string, snapshot: Snapshot): void;
+//#endregion
+//#region src/indexing/indexnow.d.ts
+/** Generate a key. 32 hex characters, the conventional shape. */
+declare function newKey(): string;
+/** The body of the key file served at `keyLocation`: the key, and nothing else. */
+declare const keyFileContents: (key: string) => string;
+interface SubmitResult {
+  ok: boolean;
+  status: number;
+  urls: number;
+  /** The endpoint's own explanation, when it gave one. */
+  message?: string;
+}
+/**
+ * Verify the key file is live and correct before submitting.
+ *
+ * Worth a request of its own because of how IndexNow fails: a submission with an
+ * unreachable key file returns `403`, but one with a *reachable* key file whose
+ * contents are stale is accepted with `202` and then silently discarded. Checking
+ * first is the only way to tell "submitted" from "submitted and ignored".
+ */
+declare function verifyKeyFile(keyLocation: string, key: string, fetchImpl?: typeof fetch): Promise<{
+  ok: boolean;
+  reason?: string;
+}>;
+/**
+ * Submit one batch. Callers iterate `plan.batches` — the split is the planner's
+ * job, so that what gets sent is decided in the pure layer and visible in `--dry`.
+ */
+declare function submitBatch(plan: IndexNowPlan, urls: string[], fetchImpl?: typeof fetch): Promise<SubmitResult>;
+//#endregion
+//#region src/indexing/gsc.d.ts
+/** The fields this module needs from a service-account JSON key. */
+interface ServiceAccount {
+  client_email: string;
+  private_key: string;
+}
+/**
+ * Parse a service-account credential from its two supported sources.
+ *
+ * `VITOPS_GSC_SERVICE_ACCOUNT` holds the JSON inline (what a CI secret store
+ * gives you); `GOOGLE_APPLICATION_CREDENTIALS` holds a path (Google's own
+ * convention, and what a local `gcloud` setup already has). Supporting both means
+ * neither environment has to be reshaped to fit the tool.
+ */
+declare function parseServiceAccount(raw: string): ServiceAccount;
+/**
+ * Exchange a service-account key for an access token (RS256 JWT bearer flow).
+ *
+ * `now` is a parameter so this is testable without mocking the clock.
+ */
+declare function getAccessToken(account: ServiceAccount, fetchImpl?: typeof fetch, now?: number): Promise<string>;
+/**
+ * Re-submit a sitemap — the automated form of the manual resubmit in the UI.
+ *
+ * A `403` here almost always means `siteUrl` doesn't match the property exactly
+ * (`sc-domain:acme.ca` vs `https://acme.ca/`) or the service account isn't an
+ * owner of it, rather than that the sitemap is bad.
+ */
+declare function submitSitemap(token: string, siteUrl: string, sitemapUrl: string, fetchImpl?: typeof fetch): Promise<{
+  ok: boolean;
+  status: number;
+  message?: string;
+}>;
+/** What the URL Inspection API said about one page. */
+interface InspectionResult {
+  url: string;
+  /** Google's verdict, e.g. `PASS`, `NEUTRAL`, `FAIL`. */
+  verdict?: string;
+  /** e.g. `INDEXING_ALLOWED`, `BLOCKED_BY_ROBOTS_TXT`. */
+  coverageState?: string;
+  lastCrawlTime?: string;
+  /** True when Google reports the page as indexed. */
+  indexed: boolean;
+  error?: string;
+}
+/**
+ * Inspect one URL. **Read-only** — this reports what Google did, it cannot ask for
+ * anything. Quota is 2000 queries/day per property, which is why the caller works
+ * from an explicit `priorityUrls` list rather than the whole sitemap.
+ */
+declare function inspectUrl(token: string, siteUrl: string, inspectionUrl: string, fetchImpl?: typeof fetch): Promise<InspectionResult>;
+//#endregion
+export { type ChannelPlan, INDEXNOW_BATCH, INDEXNOW_ENDPOINT, type IndexNowConfig, type IndexNowPlan, type IndexingConfig, type IndexingPlan, type InspectionResult, type ParsedSitemap, type PlanInput, SNAPSHOT_PATH, type SearchConsoleConfig, type SearchConsolePlan, type ServiceAccount, type SitemapEntry, type SitemapReader, type Snapshot, type SubmitResult, type UrlReason, collectEntries, formatPlan, getAccessToken, inspectUrl, keyFileContents, newKey, parseServiceAccount, parseSitemap, plan, readSnapshot, resolveKeyLocation, resolveSitemapUrl, submitBatch, submitSitemap, toSnapshot, verifyKeyFile, writeSnapshot };
+//# sourceMappingURL=index.d.mts.map

package/dist/indexing/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/indexing/types.ts","../../src/indexing/plan.ts","../../src/indexing/sitemap.ts","../../src/indexing/snapshot.ts","../../src/indexing/indexnow.ts","../../src/indexing/gsc.ts"],"mappings":"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"}