@zenalexa/unicli 0.220.1 → 0.221.0

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;
+}

package/src/adapters/cipo/get.ts

@@ -0,0 +1,188 @@
+/**
+ * @owner       src::adapters::cipo::get
+ * @does        Browser-driven CIPO single-document retrieval — Canadian Patents Database detail page extracted into a PatentRecord.
+ * @needs       src/engine/transport/mcp-browser.ts, src/engine/normalizer/patent-envelope.ts, src/adapters/cipo/_shared.ts, src/registry.ts
+ * @feeds       src/commands/patent.ts (capability tag patent.get)
+ * @breaks      PATENT_INVALID_NUMBER, PATENT_NOT_FOUND, PATENT_API_DEPRECATED (MCP_BUS_MISSING)
+ * @invariants  output row is a canonical PatentRecord
+ * @side-effects controls Chrome via MCP
+ * @perf        single navigate + evaluate
+ * @concurrency safe
+ * @test        tests/unit/adapters/cipo/search.test.ts (transport-error shared path)
+ * @stability   experimental
+ * @since       2026-05-18
+ * @verification browser-only
+ */
+
+import { cli, Strategy } from "../../registry.js";
+import { TransportError } from "../../engine/transport/mcp-browser.js";
+import { assemblePatentRecord } from "../../engine/normalizer/patent-envelope.js";
+import {
+  cipoEnvelope,
+  cipoNavigateAndExtract,
+  transportErrorToCipoEnvelope,
+} from "./_shared.js";
+
+const ADAPTER_PATH = "src/adapters/cipo/get.ts";
+
+interface CipoDetail {
+  publication_number?: string;
+  application_number?: string;
+  title?: string;
+  abstract?: string;
+  applicant?: string;
+  inventor?: string;
+  publication_date?: string;
+  filing_date?: string;
+  grant_date?: string;
+  source_url?: string;
+}
+
+const DETAIL_EXTRACTOR = `(() => {
+  const text = (sel) => {
+    const node = document.querySelector(sel);
+    return node ? (node.textContent || '').trim() : '';
+  };
+  return {
+    publication_number: text('.patent-number, [data-field="patentNo"]'),
+    application_number: text('.application-number, [data-field="appNo"]'),
+    title: text('.patent-title, h1.title, [data-field="title"]'),
+    abstract: text('.abstract, [data-field="abstract"]'),
+    applicant: text('.applicant-name, [data-field="applicant"]'),
+    inventor: text('.inventor-name, [data-field="inventor"]'),
+    publication_date: text('.publication-date, [data-field="pubDate"]'),
+    filing_date: text('.filing-date, [data-field="filingDate"]'),
+    grant_date: text('.grant-date, [data-field="grantDate"]'),
+    source_url: location.href,
+  };
+})()`;
+
+function detailUrlFor(pubNo: string): string {
+  const stripped = pubNo.replace(/^CA[-]?/, "");
+  return `https://cipo.ic.gc.ca/opic-cipo/cpd/eng/patent/${encodeURIComponent(stripped)}/summary.html`;
+}
+
+export async function runCipoGet(kwargs: {
+  publication_number: string;
+}): Promise<unknown[]> {
+  const pubNo = String(kwargs.publication_number ?? "").trim();
+  if (pubNo.length === 0) {
+    return [
+      {
+        envelope: cipoEnvelope(
+          "PATENT_INVALID_NUMBER",
+          ADAPTER_PATH,
+          "validate",
+          "cipo get requires a non-empty publication_number",
+        ),
+      },
+    ];
+  }
+  const url = detailUrlFor(pubNo);
+  let detail: CipoDetail;
+  try {
+    const result = await cipoNavigateAndExtract<CipoDetail>(
+      url,
+      DETAIL_EXTRACTOR,
+    );
+    if (!result.data) {
+      return [
+        {
+          envelope: cipoEnvelope(
+            "PATENT_SCHEMA_DRIFT",
+            ADAPTER_PATH,
+            "evaluate",
+            "cipo detail evaluate returned no data",
+          ),
+        },
+      ];
+    }
+    detail = result.data;
+  } catch (err) {
+    if (err instanceof TransportError) {
+      return [
+        {
+          envelope: transportErrorToCipoEnvelope(err, ADAPTER_PATH, "navigate"),
+        },
+      ];
+    }
+    throw err;
+  }
+  if (!detail.publication_number && !detail.title) {
+    return [
+      {
+        envelope: cipoEnvelope(
+          "PATENT_NOT_FOUND",
+          ADAPTER_PATH,
+          "evaluate",
+          `cipo detail page for "${pubNo}" yielded no bibliographic fields`,
+          ["uspto", "epo"],
+        ),
+      },
+    ];
+  }
+  const rawPubNo = detail.publication_number || pubNo;
+  const canonicalPubNo = /^CA[-]?/.test(rawPubNo) ? rawPubNo : `CA${rawPubNo}`;
+  try {
+    return [
+      assemblePatentRecord({
+        publication_number: canonicalPubNo,
+        application_number: detail.application_number || undefined,
+        title: detail.title || undefined,
+        abstract: detail.abstract || undefined,
+        assignees: detail.applicant
+          ? [{ name: detail.applicant, country: "CA" }]
+          : undefined,
+        inventors: detail.inventor
+          ? [{ name: detail.inventor, country: "CA" }]
+          : undefined,
+        publication_date: detail.publication_date || undefined,
+        filing_date: detail.filing_date || undefined,
+        grant_date: detail.grant_date || undefined,
+        source_adapter: "cipo",
+        source_url: detail.source_url || url,
+      } as Parameters<typeof assemblePatentRecord>[0]),
+    ];
+  } catch {
+    return [
+      {
+        envelope: cipoEnvelope(
+          "PATENT_NOT_FOUND",
+          ADAPTER_PATH,
+          "normalize",
+          `cipo detail page for "${pubNo}" did not yield a valid publication_number`,
+          ["uspto"],
+        ),
+      },
+    ];
+  }
+}
+
+cli({
+  site: "cipo",
+  name: "get",
+  description: "Retrieve a single Canadian patent document (CIPO, browser)",
+  domain: "cipo.ic.gc.ca",
+  strategy: Strategy.PUBLIC,
+  adapter_path: ADAPTER_PATH,
+  args: [
+    {
+      name: "publication_number",
+      type: "str",
+      required: true,
+      positional: true,
+      description: "CA publication number (with or without CA prefix)",
+    },
+  ],
+  columns: [
+    "publication_number",
+    "title",
+    "publication_date",
+    "grant_date",
+    "source_url",
+  ],
+  capabilities: ["mcp-browser.navigate", "mcp-browser.evaluate", "patent.get"],
+  minimum_capability: "mcp-browser.evaluate",
+  func: async (_page, kwargs) =>
+    runCipoGet(kwargs as { publication_number: string }),
+});

package/src/adapters/cipo/legal-status.ts

@@ -0,0 +1,148 @@
+/**
+ * @owner       src::adapters::cipo::legal-status
+ * @does        Browser-driven CIPO legal-status / prosecution timeline lookup; emits the most recent administrative-status field from the CPD admin tab.
+ * @needs       src/engine/transport/mcp-browser.ts, src/adapters/cipo/_shared.ts, src/registry.ts
+ * @feeds       src/commands/patent.ts (capability tag patent.legal-status)
+ * @breaks      PATENT_INVALID_NUMBER, PATENT_NOT_FOUND, PATENT_API_DEPRECATED (MCP_BUS_MISSING)
+ * @invariants  output row carries legal_status verbatim as CIPO displayed it
+ * @side-effects controls Chrome via MCP
+ * @perf        single navigate + evaluate
+ * @concurrency safe
+ * @test        tests/unit/adapters/cipo/search.test.ts (shared transport-error path)
+ * @stability   experimental
+ * @since       2026-05-18
+ * @verification browser-only
+ */
+
+import { cli, Strategy } from "../../registry.js";
+import { TransportError } from "../../engine/transport/mcp-browser.js";
+import {
+  cipoEnvelope,
+  cipoNavigateAndExtract,
+  transportErrorToCipoEnvelope,
+} from "./_shared.js";
+
+const ADAPTER_PATH = "src/adapters/cipo/legal-status.ts";
+
+interface CipoLegalExtract {
+  publication_number?: string;
+  legal_status?: string;
+  status_date?: string;
+  source_url?: string;
+}
+
+const EXTRACTOR = `(() => {
+  const text = (sel) => {
+    const node = document.querySelector(sel);
+    return node ? (node.textContent || '').trim() : '';
+  };
+  return {
+    publication_number: text('.patent-number, [data-field="patentNo"]'),
+    legal_status: text('.admin-status, [data-field="adminStatus"]'),
+    status_date: text('.status-date, [data-field="statusDate"]'),
+    source_url: location.href,
+  };
+})()`;
+
+function legalUrlFor(pubNo: string): string {
+  const stripped = pubNo.replace(/^CA[-]?/, "");
+  return `https://cipo.ic.gc.ca/opic-cipo/cpd/eng/patent/${encodeURIComponent(stripped)}/admin.html`;
+}
+
+export async function runCipoLegalStatus(kwargs: {
+  publication_number: string;
+}): Promise<unknown[]> {
+  const pubNo = String(kwargs.publication_number ?? "").trim();
+  if (pubNo.length === 0) {
+    return [
+      {
+        envelope: cipoEnvelope(
+          "PATENT_INVALID_NUMBER",
+          ADAPTER_PATH,
+          "validate",
+          "cipo legal-status requires a non-empty publication_number",
+        ),
+      },
+    ];
+  }
+  const url = legalUrlFor(pubNo);
+  let detail: CipoLegalExtract;
+  try {
+    const result = await cipoNavigateAndExtract<CipoLegalExtract>(
+      url,
+      EXTRACTOR,
+    );
+    if (!result.data) {
+      return [
+        {
+          envelope: cipoEnvelope(
+            "PATENT_SCHEMA_DRIFT",
+            ADAPTER_PATH,
+            "evaluate",
+            "cipo legal-status evaluate returned no data",
+          ),
+        },
+      ];
+    }
+    detail = result.data;
+  } catch (err) {
+    if (err instanceof TransportError) {
+      return [
+        {
+          envelope: transportErrorToCipoEnvelope(err, ADAPTER_PATH, "navigate"),
+        },
+      ];
+    }
+    throw err;
+  }
+  if (!detail.legal_status) {
+    return [
+      {
+        envelope: cipoEnvelope(
+          "PATENT_NOT_FOUND",
+          ADAPTER_PATH,
+          "evaluate",
+          `cipo returned no admin/legal-status for "${pubNo}"`,
+          ["uspto", "epo"],
+        ),
+      },
+    ];
+  }
+  return [
+    {
+      publication_number: detail.publication_number || pubNo,
+      legal_status: detail.legal_status,
+      status_date: detail.status_date,
+      source_adapter: "cipo",
+      source_url: detail.source_url || url,
+      retrieved_at: new Date().toISOString(),
+    },
+  ];
+}
+
+cli({
+  site: "cipo",
+  name: "legal-status",
+  description: "CIPO Canadian patent administrative-status lookup (browser)",
+  domain: "cipo.ic.gc.ca",
+  strategy: Strategy.PUBLIC,
+  adapter_path: ADAPTER_PATH,
+  args: [
+    {
+      name: "publication_number",
+      type: "str",
+      required: true,
+      positional: true,
+      description: "CA publication number",
+    },
+  ],
+  columns: ["publication_number", "legal_status", "status_date", "source_url"],
+  capabilities: [
+    "mcp-browser.navigate",
+    "mcp-browser.evaluate",
+    "patent.legal-status",
+  ],
+  minimum_capability: "mcp-browser.evaluate",
+  func: async (_page, kwargs) =>
+    runCipoLegalStatus(kwargs as { publication_number: string }),
+});