@zenalexa/unicli 0.225.2 → 0.225.3

package/src/adapters/cnki/search.ts

@@ -0,0 +1,357 @@
+/**
+ * @owner       src::adapters::cnki::search
+ * @does        Registers CNKI Scholar title search against the current public KNS criteria endpoint.
+ * @needs       scholar.cnki.net KNS criteria API, node:crypto, src/registry.ts, src/types/scholarly.ts
+ * @feeds       `unicli cnki search`, src/commands/scholar.ts via scholar.search, scholar doctor live probes
+ * @breaks      CNKI token/request-shape drift surfaces as upstream_error; access-controlled PDF/order URLs are exposed as relation hints, not as a scholar.pdf guarantee.
+ * @invariants  Search uses CNKI's current all-database class id; rows must carry source-local id/title/source_adapter/retrieved_at; no stale API fallback is kept.
+ * @side-effects HTTPS egress to scholar.cnki.net only
+ * @perf        O(limit) JSON mapping after one POST request.
+ * @concurrency safe
+ * @test        tests/unit/adapters/scholar-sources.test.ts; live smoke via `unicli cnki search <query>` and `unicli scholar doctor --sources cnki --live`
+ * @stability   experimental
+ * @since       2026-06-27
+ */
+
+import { createCipheriv } from "node:crypto";
+
+import { cli, Strategy } from "../../registry.js";
+import type { ScholarlyWorkRecord } from "../../types/scholarly.js";
+
+const CNKI_QUERY_API =
+  "https://scholar.cnki.net/restapi/kns8s-api/v2/criteria/query";
+const CNKI_TOKEN_SECRET = "cf4e8f25360248f89248af06a55d21ea";
+const CNKI_CLIENT_ID = "c5fd4ef0-d314-4888-b0a7-f6190eaefaf0";
+const CNKI_ALL_DATABASE_CLASS_ID = "WD0FTY92";
+const CNKI_REFERER = "https://scholar.cnki.net/";
+const MAX_LIMIT = 50;
+
+interface CnkiMetadataEntry {
+  name?: unknown;
+  value?: unknown;
+}
+
+interface CnkiRelation {
+  scope?: unknown;
+  url?: unknown;
+}
+
+interface CnkiAuthor {
+  title?: unknown;
+}
+
+interface CnkiSource {
+  title?: unknown;
+  type?: unknown;
+  year?: unknown;
+  relations?: CnkiRelation[];
+}
+
+export interface CnkiSearchRow {
+  metadata?: CnkiMetadataEntry[];
+  relations?: CnkiRelation[];
+  authors?: CnkiAuthor[];
+  source?: CnkiSource;
+}
+
+interface CnkiSearchResponse {
+  code?: unknown;
+  message?: unknown;
+  data?: {
+    total?: unknown;
+    data?: CnkiSearchRow[];
+  };
+}
+
+interface CnkiSearchPayload {
+  Resource: string;
+  Classid: string;
+  Products: string;
+  KuaKuCode: string;
+  QNode: {
+    QGroup: Array<{
+      Key: string;
+      Title: string;
+      Logic: number;
+      Items: unknown[];
+      ChildItems: Array<{
+        Key: string;
+        Title: string;
+        Logic: number;
+        Items: Array<{
+          Key: string;
+          Title: string;
+          Logic: number;
+          Field: string;
+          Operator: string;
+          Value: string;
+        }>;
+        ChildItems: unknown[];
+      }>;
+    }>;
+  };
+  ExScope: string;
+  SearchType: number;
+  SearchFrom: number;
+  Rlang: string;
+  sort: string;
+  sortType: string;
+  pageNum: number;
+  pageSize: number;
+}
+
+type ActionableError = Error & {
+  code?: string;
+  suggestion?: string;
+  retryable?: boolean;
+};
+
+function str(value: unknown): string {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function stripHtml(value: unknown): string {
+  return str(value)
+    .replace(/<[^>]*>/g, "")
+    .replace(/&nbsp;/g, " ")
+    .replace(/&amp;/g, "&")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function metadataValue(row: CnkiSearchRow, name: string): string {
+  const entry = row.metadata?.find(
+    (candidate) => str(candidate.name).toUpperCase() === name,
+  );
+  return stripHtml(entry?.value);
+}
+
+function relationUrl(
+  relations: CnkiRelation[] | undefined,
+  scope: string,
+): string {
+  const found = relations?.find(
+    (relation) => str(relation.scope).toUpperCase() === scope,
+  );
+  return str(found?.url);
+}
+
+function firstRelationUrl(row: CnkiSearchRow, scopes: string[]): string {
+  for (const scope of scopes) {
+    const rowUrl = relationUrl(row.relations, scope);
+    if (rowUrl) return rowUrl;
+    const sourceUrl = relationUrl(row.source?.relations, scope);
+    if (sourceUrl) return sourceUrl;
+  }
+  return "";
+}
+
+function parseYear(value: string): number | undefined {
+  const year = Number(value.match(/(?:19|20)\d{2}/)?.[0]);
+  return Number.isInteger(year) ? year : undefined;
+}
+
+function splitMetadataAuthors(value: string): string[] {
+  return value
+    .split(/[;；]/)
+    .map((author) => author.trim())
+    .filter(Boolean);
+}
+
+function cnkiError(message: string, code = "upstream_error"): ActionableError {
+  const error = new Error(message) as ActionableError;
+  error.code = code;
+  error.suggestion =
+    "CNKI changed or rejected the public KNS criteria query. Run `unicli describe cnki search`, then inspect scholar.cnki.net's current search request before changing the adapter.";
+  error.retryable = false;
+  return error;
+}
+
+export function createCnkiVvToken(timestamp = Date.now()): string {
+  const cipher = createCipheriv(
+    "aes-256-ecb",
+    Buffer.from(CNKI_TOKEN_SECRET, "utf8"),
+    null,
+  );
+  cipher.setAutoPadding(true);
+  return Buffer.concat([
+    cipher.update(JSON.stringify({ timestamp }), "utf8"),
+    cipher.final(),
+  ]).toString("hex");
+}
+
+export function buildCnkiSearchPayload(
+  query: string,
+  limit: number,
+): CnkiSearchPayload {
+  return {
+    Resource: "",
+    Classid: CNKI_ALL_DATABASE_CLASS_ID,
+    Products: "",
+    KuaKuCode: "",
+    QNode: {
+      QGroup: [
+        {
+          Key: "",
+          Title: "",
+          Logic: 0,
+          Items: [],
+          ChildItems: [
+            {
+              Key: "subject",
+              Title: "",
+              Logic: 0,
+              Items: [
+                {
+                  Key: "",
+                  Title: "题名",
+                  Logic: 0,
+                  Field: "TI",
+                  Operator: "FUZZY",
+                  Value: query,
+                },
+              ],
+              ChildItems: [],
+            },
+          ],
+        },
+      ],
+    },
+    ExScope: "1",
+    SearchType: 2,
+    SearchFrom: 1,
+    Rlang: "",
+    sort: "PT",
+    sortType: "DESC",
+    pageNum: 1,
+    pageSize: limit,
+  };
+}
+
+export function mapCnkiSearchRow(
+  row: CnkiSearchRow,
+  rank: number,
+): ScholarlyWorkRecord & { rank: number; pdf_url?: string } {
+  const title = metadataValue(row, "TI") || metadataValue(row, "ENTI");
+  const doi = metadataValue(row, "DOI").replace(/^doi:/i, "");
+  const date = metadataValue(row, "PT");
+  const source = metadataValue(row, "LY") || stripHtml(row.source?.title);
+  const authorNames =
+    row.authors?.map((author) => stripHtml(author.title)).filter(Boolean) ?? [];
+  const authors = authorNames.length
+    ? authorNames
+    : splitMetadataAuthors(metadataValue(row, "AU"));
+  const sourceUrl = firstRelationUrl(row, ["ABSTRACT", "PUBLICATION"]);
+  const pdfUrl = firstRelationUrl(row, ["PDF"]);
+  const id =
+    metadataValue(row, "ID") ||
+    metadataValue(row, "FN") ||
+    doi ||
+    sourceUrl ||
+    title;
+  if (!id || !title) {
+    throw cnkiError("CNKI returned a row without a stable id or title.");
+  }
+  const citedByCount = Number(metadataValue(row, "CF"));
+  return {
+    id,
+    rank,
+    title,
+    authors,
+    year: parseYear(date) ?? parseYear(str(row.source?.year)),
+    date: date || undefined,
+    venue: source || undefined,
+    type: metadataValue(row, "DB") || stripHtml(row.source?.type) || undefined,
+    abstract: metadataValue(row, "AB") || undefined,
+    doi: doi || undefined,
+    cited_by_count: Number.isFinite(citedByCount) ? citedByCount : undefined,
+    pdf_url: pdfUrl || undefined,
+    landing_url: sourceUrl || undefined,
+    source_adapter: "cnki",
+    source_url: sourceUrl || undefined,
+    retrieved_at: new Date().toISOString(),
+  };
+}
+
+async function fetchCnkiSearch(
+  payload: CnkiSearchPayload,
+): Promise<CnkiSearchResponse> {
+  const url = new URL(CNKI_QUERY_API);
+  url.searchParams.set("vv", createCnkiVvToken());
+  url.searchParams.set("clientId", CNKI_CLIENT_ID);
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      Accept: "application/json, text/plain, */*",
+      "Content-Type": "application/json;charset=UTF-8",
+      Origin: "https://scholar.cnki.net",
+      Referer: CNKI_REFERER,
+      "User-Agent":
+        "Mozilla/5.0 (compatible; Uni-CLI/1.0; +https://github.com/olo-dot-io/Uni-CLI)",
+      Version: "",
+    },
+    body: JSON.stringify(payload),
+  });
+  if (!response.ok) {
+    throw cnkiError(`CNKI search returned HTTP ${response.status}.`);
+  }
+  const json = (await response.json()) as CnkiSearchResponse;
+  const code = Number(json.code);
+  if (code !== 0) {
+    throw cnkiError(
+      `CNKI search returned code ${String(json.code)}: ${str(json.message)}`,
+    );
+  }
+  return json;
+}
+
+cli({
+  site: "cnki",
+  name: "search",
+  description: "Search CNKI academic papers by title",
+  domain: "scholar.cnki.net",
+  strategy: Strategy.PUBLIC,
+  adapter_path: "src/adapters/cnki/search.ts",
+  args: [
+    { name: "query", type: "str", required: true, positional: true },
+    { name: "limit", type: "int", default: 20 },
+  ],
+  columns: [
+    "rank",
+    "id",
+    "title",
+    "authors",
+    "venue",
+    "year",
+    "doi",
+    "cited_by_count",
+    "pdf_url",
+    "source_url",
+  ],
+  capabilities: ["http.fetch", "scholar.search"],
+  func: async (_page, kwargs) => {
+    const query = str(kwargs.query);
+    if (!query) {
+      const error = new Error(
+        "cnki search query cannot be empty.",
+      ) as ActionableError;
+      error.code = "invalid_input";
+      error.suggestion =
+        "Pass a CNKI title keyword, for example `unicli cnki search 人工智能`.";
+      error.retryable = false;
+      throw error;
+    }
+    const requestedLimit = Number(kwargs.limit ?? 20);
+    const limit = Number.isFinite(requestedLimit)
+      ? Math.min(Math.max(Math.trunc(requestedLimit), 1), MAX_LIMIT)
+      : 20;
+    const payload = buildCnkiSearchPayload(query, limit);
+    const response = await fetchCnkiSearch(payload);
+    const rows = Array.isArray(response.data?.data) ? response.data.data : [];
+    return rows.map((row, index) => mapCnkiSearchRow(row, index + 1));
+  },
+});

package/src/adapters/cvf/papers.ts

@@ -1,12 +1,12 @@
 /**
  * @owner       src::adapters::cvf::papers
- * @does        Registers CVF OpenAccess conference paper search for CVPR/ICCV/ECCV-style proceedings pages.
- * @needs       openaccess.thecvf.com static proceedings HTML, src/registry.ts
- * @feeds       src/commands/scholar.ts via scholar.search, scholar.pdf, and scholar.venue
- * @breaks      CVF markup drift surfaces as empty/parse errors rather than non-CVF fallbacks.
- * @invariants  Venue/year map to explicit CVF event pages; PDF URLs are absolutized against openaccess.thecvf.com.
- * @side-effects HTTPS egress to openaccess.thecvf.com only
- * @perf        O(N) over one proceedings HTML page
+ * @does        Registers CVF OpenAccess conference paper search, detail retrieval, and PDF text reading for CVPR/ICCV/ECCV-style proceedings pages.
+ * @needs       openaccess.thecvf.com static proceedings HTML/PDFs, src/adapters/scholar-artifacts/pdf-read.ts, src/registry.ts
+ * @feeds       src/commands/scholar.ts via scholar.search, scholar.get, scholar.pdf, scholar.fulltext, and scholar.venue
+ * @breaks      CVF markup/PDF drift, denied downloads, or missing pdftotext surface as explicit adapter errors rather than non-CVF fallbacks.
+ * @invariants  Venue/year map to explicit CVF event pages; paper detail prefers citation_* metadata over scraped display blocks.
+ * @side-effects HTTPS egress to openaccess.thecvf.com; read writes one PDF artifact and executes pdftotext.
+ * @perf        O(N) over one proceedings HTML page; read is O(PDF bytes + selected pages)
  * @concurrency safe
  * @test        tests/unit/adapters/scholar-sources.test.ts
  * @stability   experimental
@@ -15,8 +15,23 @@
 
 import { cli, Strategy } from "../../registry.js";
 import type { ScholarlyWorkRecord } from "../../types/scholarly.js";
+import { readScholarPdf } from "../scholar-artifacts/pdf-read.js";
+import { Agent, request } from "undici";
 
 const ORIGIN = "https://openaccess.thecvf.com";
+const CVF_USER_AGENT = "unicli-cvf/1.0 (https://github.com/olo-dot-io/Uni-CLI)";
+const CVF_HTTP_AGENT = new Agent({ connect: { timeout: 30_000 } });
+export const CVF_HTTP_HEADERS = {
+  Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+  "User-Agent": CVF_USER_AGENT,
+} as const;
+
+type CvfActionableError = Error & {
+  code?: string;
+  suggestion?: string;
+  retryable?: boolean;
+  alternatives?: string[];
+};
 
 function decode(value: string): string {
   return value
@@ -35,6 +50,26 @@ function absolute(path: string): string {
     : `${ORIGIN}${path.startsWith("/") ? "" : "/"}${path}`;
 }
 
+function metaContents(html: string, name: string): string[] {
+  const values: string[] = [];
+  const re = new RegExp(
+    `<meta\\s+name=["']${name}["']\\s+content=["']([^"']*)["'][^>]*>`,
+    "gi",
+  );
+  let match: RegExpExecArray | null;
+  while ((match = re.exec(html)) !== null) values.push(decode(match[1]));
+  return values;
+}
+
+function firstMetaContent(html: string, name: string): string {
+  return metaContents(html, name)[0] ?? "";
+}
+
+function parseYear(value: string): number | undefined {
+  const year = value.match(/\d{4}/)?.[0];
+  return year ? Number(year) : undefined;
+}
+
 function eventId(venue: unknown, year: unknown): string {
   const v = String(venue ?? "CVPR")
     .trim()
@@ -46,6 +81,89 @@ function eventId(venue: unknown, year: unknown): string {
   return `${v}${y}`;
 }
 
+function requireCvfPaperId(value: unknown): string {
+  const raw = String(value ?? "").trim();
+  const id =
+    raw.match(/\/html\/([^/?#]+\.html)/)?.[1]?.replace(/\.html$/, "") ??
+    raw.replace(/\.html$/, "");
+  if (!/^[A-Za-z0-9_.-]+$/.test(id)) {
+    throw new Error(`CVF paper id "${raw}" is not valid.`);
+  }
+  return id;
+}
+
+function paperUrl(id: string, event: string): string {
+  return `${ORIGIN}/content/${event}/html/${id}.html`;
+}
+
+function cvfUpstreamError(label: string, detail: string): CvfActionableError {
+  const error = new Error(`${label} failed: ${detail}.`) as CvfActionableError;
+  error.code = "upstream_error";
+  error.suggestion =
+    "CVF OpenAccess did not return the expected public proceedings page on this network path; retry later or verify the official openaccess.thecvf.com page manually.";
+  error.retryable =
+    /fetch failed|timeout|ECONNRESET|ETIMEDOUT|HTTP (429|5\d\d)/i.test(detail);
+  error.alternatives = [];
+  return error;
+}
+
+function parseListAuthors(block: string): string[] | undefined {
+  const beforeLinks = block.split(/\[<a\s+href=/i)[0] ?? block;
+  const dd = beforeLinks.match(/<dd>([\s\S]*?)(?:<\/dd>|$)/i)?.[1] ?? "";
+  const text = decode(
+    dd.replace(/<div class="bibref[\s\S]*$/i, " ").replace(/<[^>]+>/g, " "),
+  );
+  const authors = text
+    .replace(/;\s*Proceedings[\s\S]*$/i, "")
+    .split(",")
+    .map((author) => author.trim())
+    .filter(Boolean);
+  return authors.length > 0 ? authors : undefined;
+}
+
+export function parseCvfPaperPage(
+  html: string,
+  sourceUrl: string,
+): ScholarlyWorkRecord {
+  const title =
+    firstMetaContent(html, "citation_title") ||
+    decode(
+      html
+        .match(/<div id="papertitle">([\s\S]*?)<dd>/i)?.[1]
+        ?.replace(/<[^>]+>/g, " ") ?? "",
+    );
+  if (!title) throw new Error("CVF paper page did not expose a title.");
+  const event = sourceUrl.match(/\/content\/([A-Z]+\d{4})\//)?.[1] ?? undefined;
+  const id =
+    sourceUrl
+      .split("/")
+      .pop()
+      ?.replace(/\.html$/, "") ?? title;
+  const pdfUrl =
+    firstMetaContent(html, "citation_pdf_url") ||
+    html.match(/<a href="([^"]+\.pdf)">pdf<\/a>/i)?.[1] ||
+    "";
+  return {
+    id,
+    title,
+    authors: metaContents(html, "citation_author"),
+    year:
+      parseYear(firstMetaContent(html, "citation_publication_date")) ??
+      (event ? Number(event.slice(-4)) : undefined),
+    venue:
+      firstMetaContent(html, "citation_conference_title") ||
+      event?.replace(/\d{4}$/, ""),
+    abstract:
+      decode(
+        html.match(/<div id="abstract">([\s\S]*?)<\/div>/i)?.[1] ?? "",
+      ).replace(/<[^>]+>/g, " ") || undefined,
+    pdf_url: pdfUrl ? absolute(pdfUrl) : undefined,
+    source_adapter: "cvf",
+    source_url: sourceUrl,
+    retrieved_at: new Date().toISOString(),
+  };
+}
+
 export function parseCvfRows(
   html: string,
   event = "CVPR2024",
@@ -59,14 +177,6 @@ export function parseCvfRows(
     const title = decode(match[2].replace(/<[^>]+>/g, " "));
     const block = match[3];
     const pdf = block.match(/<a href="([^"]+\.pdf)">pdf<\/a>/i)?.[1] ?? "";
-    const authorText = block
-      .replace(/\[[\s\S]*?\]/g, " ")
-      .replace(/<form[\s\S]*?<\/form>/g, " ")
-      .replace(/<[^>]+>/g, " ");
-    const authors = decode(authorText)
-      .split(",")
-      .map((author) => author.trim())
-      .filter(Boolean);
     out.push({
       id:
         sourceUrl
@@ -74,7 +184,7 @@ export function parseCvfRows(
           .pop()
           ?.replace(/\.html$/, "") ?? title,
       title,
-      authors: authors.length > 0 ? authors : undefined,
+      authors: parseListAuthors(block),
       year: Number(event.slice(-4)),
       venue: event.replace(/\d{4}$/, ""),
       pdf_url: pdf ? absolute(pdf) : undefined,
@@ -86,6 +196,54 @@ export function parseCvfRows(
   return out;
 }
 
+async function fetchCvfHtml(url: string, label: string): Promise<string> {
+  let response: Awaited<ReturnType<typeof request>>;
+  try {
+    response = await request(url, {
+      dispatcher: CVF_HTTP_AGENT,
+      headers: CVF_HTTP_HEADERS,
+    });
+  } catch (error) {
+    throw cvfUpstreamError(
+      label,
+      error instanceof Error ? error.message : String(error),
+    );
+  }
+  if (response.statusCode === 404)
+    throw new Error(`${label} returned no page.`);
+  if (response.statusCode < 200 || response.statusCode >= 300) {
+    throw cvfUpstreamError(label, `HTTP ${response.statusCode}`);
+  }
+  return response.body.text();
+}
+
+async function readCvfPaperPdf(
+  row: ScholarlyWorkRecord,
+  kwargs: Record<string, unknown>,
+): Promise<Record<string, unknown>> {
+  if (!row.pdf_url) throw new Error(`CVF paper ${row.id} has no PDF URL.`);
+  return readScholarPdf(
+    {
+      id: row.id,
+      title: row.title,
+      source_adapter: "cvf",
+      source_url: row.source_url,
+      pdf_url: row.pdf_url,
+      output: kwargs.output,
+      filename: kwargs.filename,
+      "first-page": kwargs["first-page"] ?? kwargs.firstPage,
+      "last-page": kwargs["last-page"] ?? kwargs.lastPage,
+      "max-chars": kwargs["max-chars"] ?? kwargs.maxChars,
+    },
+    {
+      site: "cvf",
+      command: "read",
+      defaultOutput: "./cvf-downloads",
+      userAgent: CVF_USER_AGENT,
+    },
+  );
+}
+
 cli({
   site: "cvf",
   name: "search",
@@ -111,18 +269,11 @@ cli({
       .toLowerCase();
     if (!query) throw new Error("cvf search query cannot be empty.");
     const event = eventId(kwargs.venue, kwargs.year);
-    const response = await fetch(`${ORIGIN}/${event}?day=all`, {
-      headers: {
-        Accept: "*/*",
-        "User-Agent": "unicli-cvf/1.0 (https://github.com/olo-dot-io/Uni-CLI)",
-      },
-    });
-    if (response.status === 404)
-      throw new Error(`CVF ${event} returned no proceedings page.`);
-    if (!response.ok)
-      throw new Error(`CVF ${event} returned HTTP ${response.status}.`);
     const limit = Math.min(Math.max(Number(kwargs.limit ?? 20), 1), 200);
-    const rows = parseCvfRows(await response.text(), event)
+    const rows = parseCvfRows(
+      await fetchCvfHtml(`${ORIGIN}/${event}?day=all`, `CVF ${event}`),
+      event,
+    )
       .filter((row) =>
         `${row.title} ${row.authors?.join(" ") ?? ""}`
           .toLowerCase()
@@ -134,3 +285,85 @@ cli({
     return rows;
   },
 });
+
+cli({
+  site: "cvf",
+  name: "paper",
+  description: "Fetch CVF OpenAccess paper metadata by page id",
+  domain: "openaccess.thecvf.com",
+  strategy: Strategy.PUBLIC,
+  args: [
+    { name: "id", type: "str", required: true, positional: true },
+    { name: "venue", type: "str", default: "CVPR" },
+    { name: "year", type: "str", default: "2024" },
+  ],
+  columns: ["id", "title", "authors", "year", "venue", "pdf_url", "source_url"],
+  capabilities: ["http.fetch", "scholar.get", "scholar.pdf"],
+  func: async (_page, kwargs) => {
+    const event = eventId(kwargs.venue, kwargs.year);
+    const id = requireCvfPaperId(kwargs.id ?? kwargs.ref);
+    const url = paperUrl(id, event);
+    return [parseCvfPaperPage(await fetchCvfHtml(url, `CVF paper ${id}`), url)];
+  },
+});
+
+cli({
+  site: "cvf",
+  name: "read",
+  description:
+    "Download a CVF OpenAccess paper PDF by page id and extract text",
+  domain: "openaccess.thecvf.com",
+  strategy: Strategy.PUBLIC,
+  args: [
+    { name: "id", type: "str", required: true, positional: true },
+    { name: "venue", type: "str", default: "CVPR" },
+    { name: "year", type: "str", default: "2024" },
+    {
+      name: "output",
+      type: "str",
+      default: "./cvf-downloads",
+      description: "Output directory for the downloaded PDF",
+      "x-unicli-kind": "path",
+    },
+    { name: "filename", type: "str", description: "Output PDF filename" },
+    { name: "first-page", type: "int", default: 1, description: "First page" },
+    { name: "last-page", type: "int", default: 20, description: "Last page" },
+    {
+      name: "max-chars",
+      type: "int",
+      default: 40000,
+      description: "Maximum extracted text characters",
+    },
+  ],
+  columns: [
+    "id",
+    "title",
+    "source_adapter",
+    "source_url",
+    "pdf_url",
+    "path",
+    "text_source",
+    "text",
+    "text_chars",
+    "text_truncated",
+  ],
+  capabilities: [
+    "http.fetch",
+    "http.download",
+    "subprocess.exec",
+    "scholar.fulltext",
+    "scholar.pdf",
+  ],
+  executables: ["pdftotext"],
+  minimum_capability: "subprocess.exec",
+  func: async (_page, kwargs) => {
+    const event = eventId(kwargs.venue, kwargs.year);
+    const id = requireCvfPaperId(kwargs.id ?? kwargs.ref);
+    const url = paperUrl(id, event);
+    const row = parseCvfPaperPage(
+      await fetchCvfHtml(url, `CVF paper ${id}`),
+      url,
+    );
+    return [await readCvfPaperPdf(row, kwargs)];
+  },
+});