@zenalexa/unicli 0.220.0 → 0.221.0

package/src/adapters/bangumi/web.ts

@@ -0,0 +1,295 @@
+/**
+ * @owner   src/adapters/bangumi/web.ts
+ * @does    Register Bangumi public search/detail commands for anime, books, games, subjects, and characters.
+ * @needs   Bangumi public REST/search endpoints and user-agent policy.
+ * @feeds   Chinese/Japanese ACG title, character, and visual-novel discovery.
+ * @breaks  Bangumi legacy search endpoint or v0 subject/character schema changes can block lookup.
+ */
+
+import { USER_AGENT } from "../../constants.js";
+import { cli, Strategy } from "../../registry.js";
+
+const API = "https://api.bgm.tv";
+
+function str(value: unknown): string {
+  return value === undefined || value === null ? "" : String(value);
+}
+
+function required(value: unknown, label: string): string {
+  const text = str(value).trim();
+  if (!text) throw new Error(`bangumi ${label} cannot be empty.`);
+  return text;
+}
+
+function requireLimit(value: unknown): number {
+  if (value === undefined || value === null || value === "") return 10;
+  const n = Number(value);
+  if (!Number.isInteger(n) || n < 1 || n > 50) {
+    throw new Error("bangumi limit must be an integer in [1, 50].");
+  }
+  return n;
+}
+
+function optionalYear(value: unknown): number | undefined {
+  if (value === undefined || value === null || value === "") return undefined;
+  const n = Number(value);
+  if (!Number.isInteger(n) || n < 1900 || n > 2100) {
+    throw new Error("bangumi year must be an integer in [1900, 2100].");
+  }
+  return n;
+}
+
+const TYPE_CODES: Record<string, number> = {
+  book: 1,
+  anime: 2,
+  music: 3,
+  game: 4,
+  real: 6,
+};
+const SORTS = new Set(["match", "rank", "score", "heat"]);
+
+function normalizeSort(value: unknown): string {
+  const sort = str(value || "match")
+    .trim()
+    .toLowerCase();
+  if (!SORTS.has(sort)) {
+    throw new Error("bangumi sort must be one of: match, rank, score, heat.");
+  }
+  return sort;
+}
+
+async function getJson(url: string): Promise<unknown> {
+  const response = await fetch(url, {
+    headers: {
+      Accept: "application/json",
+      "User-Agent": USER_AGENT,
+    },
+  });
+  if (!response.ok)
+    throw new Error(`bangumi request failed with HTTP ${response.status}.`);
+  return response.json();
+}
+
+async function postJson(url: string, body: unknown): Promise<unknown> {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/json",
+      "User-Agent": USER_AGENT,
+    },
+    body: JSON.stringify(body),
+  });
+  if (!response.ok)
+    throw new Error(`bangumi request failed with HTTP ${response.status}.`);
+  return response.json();
+}
+
+export function mapBangumiSubjects(rows: unknown[]): Record<string, unknown>[] {
+  return rows.map((row, index) => {
+    const item = row as Record<string, unknown>;
+    const rating = item.rating as Record<string, unknown> | undefined;
+    const images = item.images as Record<string, unknown> | undefined;
+    return {
+      rank: index + 1,
+      id: item.id,
+      type: item.type,
+      name: str(item.name),
+      name_cn: str(item.name_cn),
+      date: str(item.air_date ?? item.date),
+      score: rating?.score ?? null,
+      rank_site: item.rank ?? null,
+      summary: str(item.summary).slice(0, 500),
+      image: str(images?.common),
+      url: str(item.url) || `https://bgm.tv/subject/${item.id}`,
+    };
+  });
+}
+
+export function mapBangumiSubject(
+  item: Record<string, unknown>,
+): Record<string, unknown> {
+  const rating = item.rating as Record<string, unknown> | undefined;
+  const images = item.images as Record<string, unknown> | undefined;
+  return {
+    id: item.id,
+    type: item.type,
+    name: str(item.name),
+    name_cn: str(item.name_cn),
+    platform: str(item.platform),
+    date: str(item.date),
+    score: rating?.score ?? null,
+    total_votes: rating?.total ?? null,
+    rank_site: item.rank ?? null,
+    summary: str(item.summary).slice(0, 1500),
+    image: str(images?.common),
+    url: `https://bgm.tv/subject/${item.id}`,
+  };
+}
+
+export function mapBangumiCharacters(
+  rows: unknown[],
+): Record<string, unknown>[] {
+  return rows.map((row, index) => {
+    const item = row as Record<string, unknown>;
+    const stat = item.stat as Record<string, unknown> | undefined;
+    const images = item.images as Record<string, unknown> | undefined;
+    return {
+      rank: index + 1,
+      id: item.id,
+      name: str(item.name),
+      gender: str(item.gender),
+      type: item.type ?? null,
+      comments: stat?.comments ?? null,
+      collects: stat?.collects ?? null,
+      summary: str(item.summary).slice(0, 700),
+      image: str(images?.medium ?? images?.grid),
+      url: `https://bgm.tv/character/${item.id}`,
+    };
+  });
+}
+
+async function searchSubject(
+  kind: keyof typeof TYPE_CODES,
+  kwargs: Record<string, unknown>,
+) {
+  const cap = requireLimit(kwargs.limit);
+  const url = new URL(`${API}/v0/search/subjects`);
+  url.searchParams.set("limit", String(cap));
+  url.searchParams.set("offset", "0");
+  const data = (await postJson(
+    url.toString(),
+    bangumiSubjectSearchBody(kind, kwargs),
+  )) as { data?: unknown[] };
+  const rows = mapBangumiSubjects(data.data ?? []);
+  if (rows.length === 0)
+    throw new Error(
+      `No Bangumi ${kind} found for "${required(kwargs.query, "query")}".`,
+    );
+  return rows;
+}
+
+export function bangumiSubjectSearchBody(
+  kind: keyof typeof TYPE_CODES,
+  kwargs: Record<string, unknown>,
+): Record<string, unknown> {
+  const year = optionalYear(kwargs.year);
+  const sort = normalizeSort(kwargs.sort);
+  const filter: Record<string, unknown> = { type: [TYPE_CODES[kind]] };
+  if (year !== undefined) {
+    filter.air_date = [`>=${year}-01-01`, `<${year + 1}-01-01`];
+  }
+  return {
+    keyword: required(kwargs.query, "query"),
+    ...(sort === "match" ? {} : { sort }),
+    filter,
+  };
+}
+
+async function searchCharacters(kwargs: Record<string, unknown>) {
+  const query = required(kwargs.query, "query");
+  const cap = requireLimit(kwargs.limit);
+  const url = new URL(`${API}/v0/search/characters`);
+  url.searchParams.set("limit", String(cap));
+  const data = (await postJson(url.toString(), {
+    keyword: query,
+    filter: {},
+  })) as { data?: unknown[] };
+  const rows = mapBangumiCharacters(data.data ?? []);
+  if (rows.length === 0)
+    throw new Error(`No Bangumi characters found for "${query}".`);
+  return rows;
+}
+
+const SEARCH_ARGS = [
+  { name: "query", type: "str" as const, required: true, positional: true },
+  { name: "limit", type: "int" as const, default: 10 },
+  { name: "year", type: "int" as const },
+  {
+    name: "sort",
+    type: "str" as const,
+    default: "match",
+    choices: ["match", "rank", "score", "heat"],
+    description: "match, rank, score, heat",
+  },
+];
+const CHARACTER_ARGS = SEARCH_ARGS.filter(
+  (arg) => arg.name === "query" || arg.name === "limit",
+);
+const SUBJECT_COLUMNS = [
+  "rank",
+  "id",
+  "type",
+  "name",
+  "name_cn",
+  "date",
+  "score",
+  "rank_site",
+  "url",
+];
+const CHARACTER_COLUMNS = [
+  "rank",
+  "id",
+  "name",
+  "gender",
+  "comments",
+  "collects",
+  "summary",
+  "url",
+];
+
+for (const name of ["anime", "book", "game"] as const) {
+  cli({
+    site: "bangumi",
+    name,
+    description: `Search Bangumi ${name} subjects by Japanese title, Chinese title, romaji, or alias`,
+    domain: "bgm.tv",
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: SEARCH_ARGS,
+    columns: SUBJECT_COLUMNS,
+    func: async (_page, kwargs) => searchSubject(name, kwargs),
+  });
+}
+
+cli({
+  site: "bangumi",
+  name: "characters",
+  description:
+    "Search Bangumi characters by Japanese name, Chinese name, romaji, or alias",
+  domain: "bgm.tv",
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: CHARACTER_ARGS,
+  columns: CHARACTER_COLUMNS,
+  func: async (_page, kwargs) => searchCharacters(kwargs),
+});
+
+cli({
+  site: "bangumi",
+  name: "subject",
+  description: "Get Bangumi subject details by subject id",
+  domain: "bgm.tv",
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [{ name: "id", type: "str", required: true, positional: true }],
+  columns: [
+    "id",
+    "type",
+    "name",
+    "name_cn",
+    "platform",
+    "date",
+    "score",
+    "rank_site",
+    "summary",
+    "url",
+  ],
+  func: async (_page, kwargs) => [
+    mapBangumiSubject(
+      (await getJson(
+        `${API}/v0/subjects/${required(kwargs.id, "id")}`,
+      )) as Record<string, unknown>,
+    ),
+  ],
+});

package/src/adapters/bilibili/comments-tree.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from "vitest";
+
+import { normalizeCommentRows } from "../../social/comments.js";
+
+describe("bilibili comment tree normalization", () => {
+  it("places fetched child replies under their root rpid", () => {
+    const rows = normalizeCommentRows(
+      [
+        {
+          id: "100",
+          author: "root-user",
+          text: "root",
+          likes: 10,
+          replies: 1,
+        },
+        {
+          id: "101",
+          parent_id: "100",
+          author: "child-user",
+          text: "reply",
+          likes: 2,
+          replies: 0,
+        },
+      ],
+      { platform: "bilibili", contentId: "BV1xx" },
+    );
+
+    expect(rows[0]).toMatchObject({
+      comment_id: "100",
+      parent_id: "",
+      depth: 0,
+      path: "0001",
+    });
+    expect(rows[1]).toMatchObject({
+      comment_id: "101",
+      parent_id: "100",
+      depth: 1,
+      path: "0001.0001",
+    });
+  });
+});

package/src/adapters/bilibili/comments.ts

@@ -7,8 +7,12 @@
 
 import { cli, Strategy } from "../../registry.js";
 import { wbiFetch } from "./wbi.js";
-import { loadCookies, formatCookieHeader } from "../../engine/cookies.js";
+import {
+  loadCookiesWithCDP,
+  formatCookieHeader,
+} from "../../engine/cookies.js";
 import { USER_AGENT } from "../../constants.js";
+import { normalizeCommentRows } from "../../social/comments.js";
 
 interface ViewResponse {
   data: {
@@ -17,10 +21,14 @@ interface ViewResponse {
 }
 
 interface CommentItem {
+  rpid?: number;
+  root?: number;
+  parent?: number;
   member: { uname: string };
   content: { message: string };
   like: number;
   rcount: number;
+  ctime?: number;
 }
 
 interface CommentsResponse {
@@ -31,7 +39,7 @@ interface CommentsResponse {
 
 /** Fetch video aid from bvid using the view API (not WBI-signed). */
 async function resolveAid(bvid: string): Promise<number> {
-  const cookies = loadCookies("bilibili");
+  const cookies = await loadCookiesWithCDP("bilibili", "bilibili.com");
   const headers: Record<string, string> = {
     "User-Agent": USER_AGENT,
     Accept: "application/json",
@@ -69,11 +77,32 @@ cli({
       default: 20,
       description: "Number of comments",
     },
+    {
+      name: "with-replies",
+      type: "bool",
+      default: false,
+      description: "Include nested replies for each root comment",
+    },
+  ],
+  columns: [
+    "platform",
+    "content_id",
+    "comment_id",
+    "parent_id",
+    "depth",
+    "path",
+    "author",
+    "text",
+    "likes",
+    "replies",
+    "created",
+    "user",
+    "content",
   ],
-  columns: ["user", "content", "likes", "replies"],
   func: async (_page, kwargs) => {
     const bvid = String(kwargs.bvid);
     const limit = Number(kwargs.limit) || 20;
+    const withReplies = Boolean(kwargs["with-replies"]);
 
     const aid = await resolveAid(bvid);
 
@@ -84,11 +113,56 @@ cli({
       ps: String(limit),
     })) as CommentsResponse;
 
-    return (json.data.replies ?? []).map((item) => ({
+    const roots = json.data.replies ?? [];
+    const rows = roots.map((item) => ({
+      id: item.rpid ? String(item.rpid) : "",
+      parent_id:
+        item.parent && item.parent > 0
+          ? String(item.parent)
+          : item.root && item.root > 0
+            ? String(item.root)
+            : "",
       user: item.member.uname,
+      author: item.member.uname,
       content: item.content.message,
+      text: item.content.message,
       likes: item.like,
       replies: item.rcount,
+      created: item.ctime ? String(item.ctime) : "",
     }));
+
+    if (withReplies) {
+      for (const root of roots) {
+        if (!root.rpid || root.rcount <= 0) continue;
+        const repliesJson = (await wbiFetch(
+          "https://api.bilibili.com/x/v2/reply/reply",
+          {
+            oid: String(aid),
+            type: "1",
+            root: String(root.rpid),
+            ps: "20",
+            pn: "1",
+          },
+        )) as CommentsResponse;
+        for (const reply of repliesJson.data.replies ?? []) {
+          rows.push({
+            id: reply.rpid ? String(reply.rpid) : "",
+            parent_id: String(root.rpid),
+            user: reply.member.uname,
+            author: reply.member.uname,
+            content: reply.content.message,
+            text: reply.content.message,
+            likes: reply.like,
+            replies: reply.rcount,
+            created: reply.ctime ? String(reply.ctime) : "",
+          });
+        }
+      }
+    }
+
+    return normalizeCommentRows(rows, {
+      platform: "bilibili",
+      contentId: bvid,
+    });
   },
 });

package/src/adapters/bilibili/compat.ts

@@ -1,10 +1,13 @@
 import { cli, Strategy } from "../../registry.js";
-import { loadCookies, formatCookieHeader } from "../../engine/cookies.js";
+import {
+  loadCookiesWithCDP,
+  formatCookieHeader,
+} from "../../engine/cookies.js";
 import { USER_AGENT } from "../../constants.js";
 import { intArg, str } from "../_shared/browser-tools.js";
 
 async function bilibiliJson(url: string): Promise<Record<string, unknown>> {
-  const cookies = loadCookies("bilibili");
+  const cookies = await loadCookiesWithCDP("bilibili", "bilibili.com");
   const headers: Record<string, string> = {
     "user-agent": USER_AGENT,
     referer: "https://www.bilibili.com",

package/src/adapters/bilibili/download.ts

@@ -8,7 +8,10 @@
  */
 
 import { cli, Strategy } from "../../registry.js";
-import { loadCookies, formatCookieHeader } from "../../engine/cookies.js";
+import {
+  loadCookiesWithCDP,
+  formatCookieHeader,
+} from "../../engine/cookies.js";
 import { USER_AGENT } from "../../constants.js";
 
 interface ViewResponse {
@@ -47,8 +50,8 @@ interface PlayurlResponse {
 }
 
 /** Build authenticated headers for Bilibili API calls. */
-function buildHeaders(): Record<string, string> {
-  const cookies = loadCookies("bilibili");
+async function buildHeaders(): Promise<Record<string, string>> {
+  const cookies = await loadCookiesWithCDP("bilibili", "bilibili.com");
   const headers: Record<string, string> = {
     "User-Agent": USER_AGENT,
     Accept: "application/json",
@@ -75,7 +78,7 @@ cli({
   columns: ["type", "quality", "codecs", "size", "url"],
   func: async (_page, kwargs) => {
     const bvid = String(kwargs.bvid);
-    const headers = buildHeaders();
+    const headers = await buildHeaders();
 
     // Step 1: resolve cid from bvid
     const viewResp = await fetch(

package/src/adapters/bilibili/wbi.ts

@@ -6,7 +6,10 @@
  */
 
 import { createHash } from "node:crypto";
-import { loadCookies, formatCookieHeader } from "../../engine/cookies.js";
+import {
+  loadCookiesWithCDP,
+  formatCookieHeader,
+} from "../../engine/cookies.js";
 import { USER_AGENT } from "../../constants.js";
 
 const MIXIN_KEY_ENC_TAB = [
@@ -31,7 +34,7 @@ async function fetchWbiKeys(): Promise<string> {
   const now = Date.now();
   if (cachedMixinKey && now - cachedAt < CACHE_TTL) return cachedMixinKey;
 
-  const cookies = loadCookies("bilibili");
+  const cookies = await loadCookiesWithCDP("bilibili", "bilibili.com");
   const headers: Record<string, string> = { "User-Agent": USER_AGENT };
   if (cookies) headers["Cookie"] = formatCookieHeader(cookies);
 
@@ -76,7 +79,7 @@ export async function wbiFetch(
   const query = await signWbi(params);
   const url = `${baseUrl}?${query}`;
 
-  const cookies = loadCookies("bilibili");
+  const cookies = await loadCookiesWithCDP("bilibili", "bilibili.com");
   const headers: Record<string, string> = {
     "User-Agent": USER_AGENT,
     Accept: "application/json",

package/src/adapters/brave/search.yaml

@@ -0,0 +1,53 @@
+# Brave Search — keyless HTML scrape against the public web result page.
+#
+# verification_status: keyless-best-effort
+#
+# Brave operates a paid Search API at https://api.search.brave.com — that
+# path needs an X-Subscription-Token header (free 2000 queries/month plan).
+# This adapter takes the no-key route: hit https://search.brave.com/search
+# and parse the SSR-emitted result list. Anti-bot may rate-limit aggressive
+# loops; results are best-effort, not guaranteed parity with the API.
+site: brave
+name: search
+description: Search the public web via Brave Search (no API key needed)
+type: web-api
+domain: search.brave.com
+strategy: public
+lint_listing_detail: skip
+
+args:
+  query:
+    type: str
+    required: true
+    positional: true
+    description: Free-text web search query
+  limit:
+    type: int
+    default: 10
+    description: Maximum results returned (page caps around 20)
+
+pipeline:
+  - fetch_text:
+      url: "https://search.brave.com/search?q=${{ args.query | url_encode }}&source=web"
+      headers:
+        User-Agent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36"
+        Accept: "text/html,application/xhtml+xml"
+
+  - extract:
+      selector: "div.snippet[data-type='web']"
+      fields:
+        title: "div.snippet-title"
+        url: "a@href"
+        snippet: ".snippet-description"
+
+  - limit: ${{ args.limit }}
+
+columns: [title, url, snippet]
+
+# schema-v2 metadata
+capabilities: ["http.fetch"]
+minimum_capability: http.fetch
+trust: public
+confidentiality: public
+quarantine: false
+schema_version: v2

package/src/adapters/cipo/_shared.ts

@@ -0,0 +1,98 @@
+/**
+ * @owner       src::adapters::cipo::_shared
+ * @does        Shared helpers for the CIPO Canadian Patents Database browser adapter — emits structured envelopes for MCP-bus / not-found / schema-drift gaps.
+ * @needs       src/engine/transport/mcp-browser.ts, src/engine/normalizer/patent-envelope.ts, src/types/patent.ts
+ * @feeds       src/adapters/cipo/*.ts
+ * @breaks      none — pure helpers
+ * @invariants  every error path emits a PatentEnvelope row
+ * @side-effects none
+ * @perf        n/a
+ * @concurrency safe
+ * @test        covered transitively
+ * @stability   experimental
+ * @since       2026-05-18
+ * @verification browser-only
+ */
+
+import {
+  TransportError,
+  initMcpBrowserTransport,
+  mcpBrowserEvaluate,
+  mcpBrowserNavigate,
+  type McpBrowserResult,
+} from "../../engine/transport/mcp-browser.js";
+import { buildPatentEnvelope } from "../../engine/normalizer/patent-envelope.js";
+import type { PatentEnvelope, PatentErrorCode } from "../../types/patent.js";
+
+export function cipoEnvelope(
+  code: PatentErrorCode,
+  adapter_path: string,
+  step: string,
+  suggestion: string,
+  alternatives: string[] = [],
+): PatentEnvelope {
+  return buildPatentEnvelope({
+    code,
+    adapter_path,
+    step,
+    suggestion,
+    alternatives,
+    retryable: false,
+  });
+}
+
+export function transportErrorToCipoEnvelope(
+  err: TransportError,
+  adapter_path: string,
+  step: string,
+): PatentEnvelope {
+  if (err.code === "MCP_BUS_MISSING") {
+    return buildPatentEnvelope({
+      code: "PATENT_API_DEPRECATED",
+      adapter_path,
+      step,
+      suggestion:
+        "engine has no outbound MCP transport wired into the bus today; install an McpResolver before invoking the CIPO browser adapter, or use uspto/epo as a partial fallback",
+      alternatives: ["uspto", "epo", "lens"],
+      retryable: false,
+    });
+  }
+  return buildPatentEnvelope({
+    code: "PATENT_API_DEPRECATED",
+    adapter_path,
+    step,
+    suggestion: `mcp-browser transport error (${err.code}): ${err.message}`,
+    alternatives: ["uspto", "epo"],
+    retryable: false,
+  });
+}
+
+export async function cipoNavigateAndExtract<T>(
+  url: string,
+  expression: string,
+): Promise<McpBrowserResult<T>> {
+  const init = await initMcpBrowserTransport();
+  if (init.active_server === "none") {
+    const code =
+      init.reason === "bus-missing" ? "MCP_BUS_MISSING" : "MCP_NO_SERVER";
+    throw new TransportError(code, `mcp-browser unavailable (${init.reason})`);
+  }
+  const navResult = await mcpBrowserNavigate({ url });
+  if (!navResult.ok) {
+    throw new TransportError(
+      navResult.code ?? "MCP_NAVIGATE_FAILED",
+      navResult.message ?? "navigate did not succeed",
+    );
+  }
+  const evalResult = await mcpBrowserEvaluate<T>({
+    expression,
+    tab: navResult.tab,
+  });
+  if (!evalResult.ok) {
+    throw new TransportError(
+      evalResult.code ?? "MCP_EVALUATE_FAILED",
+      evalResult.message ?? "evaluate did not succeed",
+    );
+  }
+  return evalResult;
+}