@zenalexa/unicli 0.207.1

package/src/adapters/bilibili/comments.ts

@@ -0,0 +1,94 @@
+/**
+ * Bilibili video comments adapter.
+ *
+ * Two-step: resolve bvid → aid via /x/web-interface/view,
+ * then fetch comments via /x/v2/reply/main.
+ */
+
+import { cli, Strategy } from "../../registry.js";
+import { wbiFetch } from "./wbi.js";
+import { loadCookies, formatCookieHeader } from "../../engine/cookies.js";
+import { USER_AGENT } from "../../constants.js";
+
+interface ViewResponse {
+  data: {
+    aid: number;
+  };
+}
+
+interface CommentItem {
+  member: { uname: string };
+  content: { message: string };
+  like: number;
+  rcount: number;
+}
+
+interface CommentsResponse {
+  data: {
+    replies: CommentItem[] | null;
+  };
+}
+
+/** Fetch video aid from bvid using the view API (not WBI-signed). */
+async function resolveAid(bvid: string): Promise<number> {
+  const cookies = loadCookies("bilibili");
+  const headers: Record<string, string> = {
+    "User-Agent": USER_AGENT,
+    Accept: "application/json",
+    Referer: "https://www.bilibili.com",
+  };
+  if (cookies) headers["Cookie"] = formatCookieHeader(cookies);
+
+  const resp = await fetch(
+    `https://api.bilibili.com/x/web-interface/view?bvid=${encodeURIComponent(bvid)}`,
+    { headers },
+  );
+  if (!resp.ok) {
+    throw new Error(`Failed to resolve bvid ${bvid}: ${resp.status}`);
+  }
+  const json = (await resp.json()) as ViewResponse;
+  return json.data.aid;
+}
+
+cli({
+  site: "bilibili",
+  name: "comments",
+  description: "Fetch comments on a Bilibili video",
+  domain: "api.bilibili.com",
+  strategy: Strategy.COOKIE,
+  args: [
+    {
+      name: "bvid",
+      required: true,
+      positional: true,
+      description: "Video bvid (e.g. BV1xx...)",
+    },
+    {
+      name: "limit",
+      type: "int",
+      default: 20,
+      description: "Number of comments",
+    },
+  ],
+  columns: ["user", "content", "likes", "replies"],
+  func: async (_page, kwargs) => {
+    const bvid = String(kwargs.bvid);
+    const limit = Number(kwargs.limit) || 20;
+
+    const aid = await resolveAid(bvid);
+
+    const json = (await wbiFetch("https://api.bilibili.com/x/v2/reply/main", {
+      oid: String(aid),
+      type: "1",
+      mode: "3",
+      ps: String(limit),
+    })) as CommentsResponse;
+
+    return (json.data.replies ?? []).map((item) => ({
+      user: item.member.uname,
+      content: item.content.message,
+      likes: item.like,
+      replies: item.rcount,
+    }));
+  },
+});

package/src/adapters/bilibili/download.ts

@@ -0,0 +1,148 @@
+/**
+ * Bilibili video download URL resolver.
+ *
+ * Two-step: fetch /x/web-interface/view to get cid,
+ * then /x/player/playurl for stream URLs.
+ *
+ * Does NOT use WBI signing — uses cookie auth directly.
+ */
+
+import { cli, Strategy } from "../../registry.js";
+import { loadCookies, formatCookieHeader } from "../../engine/cookies.js";
+import { USER_AGENT } from "../../constants.js";
+
+interface ViewResponse {
+  data: {
+    cid: number;
+  };
+}
+
+interface DashStream {
+  id: number;
+  bandwidth: number;
+  base_url: string;
+  codecs: string;
+  width: number;
+  height: number;
+}
+
+interface PlayurlResponse {
+  data: {
+    quality: number;
+    dash?: {
+      video: DashStream[];
+      audio: Array<{
+        id: number;
+        bandwidth: number;
+        base_url: string;
+        codecs: string;
+      }>;
+    };
+    durl?: Array<{
+      url: string;
+      size: number;
+      order: number;
+    }>;
+  };
+}
+
+/** Build authenticated headers for Bilibili API calls. */
+function buildHeaders(): Record<string, string> {
+  const cookies = loadCookies("bilibili");
+  const headers: Record<string, string> = {
+    "User-Agent": USER_AGENT,
+    Accept: "application/json",
+    Referer: "https://www.bilibili.com",
+  };
+  if (cookies) headers["Cookie"] = formatCookieHeader(cookies);
+  return headers;
+}
+
+cli({
+  site: "bilibili",
+  name: "download",
+  description: "Get download URLs for a Bilibili video",
+  domain: "api.bilibili.com",
+  strategy: Strategy.COOKIE,
+  args: [
+    {
+      name: "bvid",
+      required: true,
+      positional: true,
+      description: "Video bvid (e.g. BV1xx...)",
+    },
+  ],
+  columns: ["type", "quality", "codecs", "size", "url"],
+  func: async (_page, kwargs) => {
+    const bvid = String(kwargs.bvid);
+    const headers = buildHeaders();
+
+    // Step 1: resolve cid from bvid
+    const viewResp = await fetch(
+      `https://api.bilibili.com/x/web-interface/view?bvid=${encodeURIComponent(bvid)}`,
+      { headers },
+    );
+    if (!viewResp.ok) {
+      throw new Error(`Failed to resolve bvid ${bvid}: ${viewResp.status}`);
+    }
+    const viewJson = (await viewResp.json()) as ViewResponse;
+    const cid = viewJson.data.cid;
+
+    // Step 2: get playurl with DASH format (fnval=16) and highest quality (qn=116)
+    const playResp = await fetch(
+      `https://api.bilibili.com/x/player/playurl?bvid=${encodeURIComponent(bvid)}&cid=${cid}&qn=116&fnval=16`,
+      { headers },
+    );
+    if (!playResp.ok) {
+      throw new Error(
+        `Failed to fetch playurl: ${playResp.status} ${playResp.statusText}`,
+      );
+    }
+    const playJson = (await playResp.json()) as PlayurlResponse;
+
+    const results: Array<{
+      type: string;
+      quality: number;
+      codecs: string;
+      size: number;
+      url: string;
+    }> = [];
+
+    // DASH format streams
+    if (playJson.data.dash) {
+      for (const v of playJson.data.dash.video) {
+        results.push({
+          type: "video",
+          quality: v.id,
+          codecs: v.codecs,
+          size: v.bandwidth,
+          url: v.base_url,
+        });
+      }
+      for (const a of playJson.data.dash.audio) {
+        results.push({
+          type: "audio",
+          quality: a.id,
+          codecs: a.codecs,
+          size: a.bandwidth,
+          url: a.base_url,
+        });
+      }
+    }
+
+    // Legacy durl format (fallback)
+    if (playJson.data.durl) {
+      for (const d of playJson.data.durl) {
+        results.push({
+          type: "flv",
+          quality: playJson.data.quality,
+          codecs: "unknown",
+          size: d.size,
+          url: d.url,
+        });
+      }
+    }
+
+    return results;
+  },
+});

package/src/adapters/bilibili/dynamic.yaml

@@ -0,0 +1,37 @@
+site: bilibili
+name: dynamic
+description: Bilibili user dynamics/activity feed
+domain: api.bilibili.com
+type: web-api
+strategy: cookie
+auth_cookies: [SESSDATA, bili_jct]
+
+args:
+  uid:
+    required: true
+    positional: true
+    description: User mid (numeric ID)
+  limit:
+    type: int
+    default: 20
+    description: Number of items
+
+pipeline:
+  - fetch:
+      url: https://api.bilibili.com/x/polymer/web-dynamic/v1/feed/space
+      params:
+        host_mid: "${{ args.uid }}"
+        timezone_offset: "-480"
+
+  - select: data.items
+
+  - map:
+      type: ${{ item.type }}
+      author: ${{ item.modules?.module_author?.name || '' }}
+      text: ${{ (item.modules?.module_dynamic?.desc?.text || '') | truncate(200) }}
+      timestamp: ${{ item.modules?.module_author?.pub_ts || '' }}
+      id: ${{ item.id_str || '' }}
+
+  - limit: ${{ args.limit }}
+
+columns: [type, author, text, timestamp, id]

package/src/adapters/bilibili/favorites.yaml

@@ -0,0 +1,37 @@
+site: bilibili
+name: favorites
+description: Bilibili favorites list content
+domain: api.bilibili.com
+type: web-api
+strategy: cookie
+auth_cookies: [SESSDATA, bili_jct]
+
+args:
+  fav_id:
+    required: true
+    positional: true
+    description: Favorites folder ID (media_id)
+  limit:
+    type: int
+    default: 20
+    description: Number of items
+
+pipeline:
+  - fetch:
+      url: https://api.bilibili.com/x/v3/fav/resource/list
+      params:
+        media_id: "${{ args.fav_id }}"
+        ps: "${{ args.limit }}"
+        pn: "1"
+
+  - select: data.medias
+
+  - map:
+      title: ${{ item.title }}
+      author: ${{ item.upper?.name || '' }}
+      fav_time: ${{ item.fav_time }}
+      bvid: ${{ item.bvid }}
+
+  - limit: ${{ args.limit }}
+
+columns: [title, author, fav_time, bvid]

package/src/adapters/bilibili/feed.yaml

@@ -0,0 +1,32 @@
+site: bilibili
+name: feed
+description: Bilibili dynamic feed (following updates)
+domain: api.bilibili.com
+type: web-api
+strategy: cookie
+auth_cookies: [SESSDATA, bili_jct]
+
+args:
+  limit:
+    type: int
+    default: 20
+    description: Number of items
+
+pipeline:
+  - fetch:
+      url: https://api.bilibili.com/x/polymer/web-dynamic/v1/feed/all
+      params:
+        timezone_offset: "-480"
+        type: all
+
+  - select: data.items
+
+  - map:
+      author: ${{ item.modules?.module_author?.name || '' }}
+      type: ${{ item.type }}
+      text: ${{ item.modules?.module_dynamic?.desc?.text || '' }}
+      timestamp: ${{ item.modules?.module_author?.pub_ts || '' }}
+
+  - limit: ${{ args.limit }}
+
+columns: [author, type, text, timestamp]

package/src/adapters/bilibili/following.yaml

@@ -0,0 +1,37 @@
+site: bilibili
+name: following
+description: Bilibili user followings list
+domain: api.bilibili.com
+type: web-api
+strategy: cookie
+auth_cookies: [SESSDATA, bili_jct]
+
+args:
+  uid:
+    required: true
+    positional: true
+    description: User ID (mid)
+  limit:
+    type: int
+    default: 20
+    description: Number of users
+
+pipeline:
+  - fetch:
+      url: https://api.bilibili.com/x/relation/followings
+      params:
+        vmid: "${{ args.uid }}"
+        pn: "1"
+        ps: "${{ args.limit }}"
+
+  - select: data.list
+
+  - map:
+      mid: ${{ item.mid }}
+      name: ${{ item.uname }}
+      sign: ${{ item.sign }}
+      face: ${{ item.face }}
+
+  - limit: ${{ args.limit }}
+
+columns: [mid, name, sign]

package/src/adapters/bilibili/history.yaml

@@ -0,0 +1,33 @@
+site: bilibili
+name: history
+description: Bilibili watch history
+domain: api.bilibili.com
+type: web-api
+strategy: cookie
+auth_cookies: [SESSDATA, bili_jct]
+
+args:
+  limit:
+    type: int
+    default: 20
+    description: Number of items
+
+pipeline:
+  - fetch:
+      url: https://api.bilibili.com/x/web-interface/history/cursor
+      params:
+        ps: "${{ args.limit }}"
+
+  - select: data.list
+
+  - map:
+      title: ${{ item.title }}
+      author: ${{ item.author_name }}
+      progress: ${{ item.progress }}
+      duration: ${{ item.duration }}
+      view_at: ${{ item.view_at }}
+      bvid: ${{ item.history?.bvid || '' }}
+
+  - limit: ${{ args.limit }}
+
+columns: [title, author, progress, duration, view_at, bvid]

package/src/adapters/bilibili/hot.yaml

@@ -0,0 +1,34 @@
+site: bilibili
+name: hot
+description: Bilibili popular videos
+domain: api.bilibili.com
+type: web-api
+strategy: cookie
+auth_cookies: [SESSDATA, bili_jct]
+
+args:
+  limit:
+    type: int
+    default: 20
+    description: Number of videos
+
+pipeline:
+  - fetch:
+      url: https://api.bilibili.com/x/web-interface/popular
+      params:
+        ps: "${{ args.limit }}"
+        pn: "1"
+
+  - select: data.list
+
+  - map:
+      rank: ${{ index + 1 }}
+      title: ${{ item.title }}
+      author: ${{ item.owner.name }}
+      views: ${{ item.stat.view }}
+      danmaku: ${{ item.stat.danmaku }}
+      bvid: ${{ item.bvid }}
+
+  - limit: ${{ args.limit }}
+
+columns: [rank, title, author, views, danmaku, bvid]

package/src/adapters/bilibili/me.yaml

@@ -0,0 +1,22 @@
+site: bilibili
+name: me
+description: Current Bilibili user profile info
+domain: api.bilibili.com
+type: web-api
+strategy: cookie
+auth_cookies: [SESSDATA, bili_jct]
+
+pipeline:
+  - fetch:
+      url: https://api.bilibili.com/x/web-interface/nav
+
+  - select: data
+
+  - map:
+      uid: ${{ item.mid }}
+      name: ${{ item.uname }}
+      coins: ${{ item.money }}
+      level: ${{ item.level_info?.current_level }}
+      vip: ${{ item.vipStatus }}
+
+columns: [uid, name, coins, level, vip]

package/src/adapters/bilibili/ranking.yaml

@@ -0,0 +1,33 @@
+site: bilibili
+name: ranking
+description: Bilibili video rankings
+domain: api.bilibili.com
+type: web-api
+strategy: cookie
+auth_cookies: [SESSDATA, bili_jct]
+
+args:
+  limit:
+    type: int
+    default: 20
+    description: Number of videos
+
+pipeline:
+  - fetch:
+      url: https://api.bilibili.com/x/web-interface/ranking/v2
+      params:
+        rid: "0"
+        type: all
+
+  - select: data.list
+
+  - map:
+      rank: ${{ index + 1 }}
+      title: ${{ item.title }}
+      author: ${{ item.owner.name }}
+      views: ${{ item.stat.view }}
+      bvid: ${{ item.bvid }}
+
+  - limit: ${{ args.limit }}
+
+columns: [rank, title, author, views, bvid]

package/src/adapters/bilibili/search.ts

@@ -0,0 +1,80 @@
+/**
+ * Bilibili video search adapter — WBI-signed keyword search.
+ *
+ * Endpoint: /x/web-interface/wbi/search/type
+ */
+
+import { cli, Strategy } from "../../registry.js";
+import { wbiFetch } from "./wbi.js";
+
+interface SearchResult {
+  title: string;
+  author: string;
+  play: number;
+  bvid: string;
+}
+
+interface SearchResponse {
+  data: {
+    result: Array<{
+      title: string;
+      author: string;
+      play: number;
+      bvid: string;
+    }>;
+  };
+}
+
+/** Strip HTML tags from Bilibili search result titles. */
+function stripHtml(html: string): string {
+  return html.replace(/<[^>]*>/g, "");
+}
+
+cli({
+  site: "bilibili",
+  name: "search",
+  description: "Search Bilibili videos by keyword",
+  domain: "api.bilibili.com",
+  strategy: Strategy.COOKIE,
+  args: [
+    {
+      name: "keyword",
+      required: true,
+      positional: true,
+      description: "Search keyword",
+    },
+    {
+      name: "limit",
+      type: "int",
+      default: 20,
+      description: "Number of results",
+    },
+  ],
+  columns: ["rank", "title", "author", "play", "bvid"],
+  func: async (_page, kwargs) => {
+    const keyword = String(kwargs.keyword);
+    const limit = Number(kwargs.limit) || 20;
+
+    const json = (await wbiFetch(
+      "https://api.bilibili.com/x/web-interface/wbi/search/type",
+      {
+        search_type: "video",
+        keyword,
+        page: "1",
+        page_size: String(limit),
+      },
+    )) as SearchResponse;
+
+    const results: Array<SearchResult & { rank: number }> = (
+      json.data.result ?? []
+    ).map((item, idx) => ({
+      rank: idx + 1,
+      title: stripHtml(item.title),
+      author: item.author,
+      play: item.play,
+      bvid: item.bvid,
+    }));
+
+    return results.slice(0, limit);
+  },
+});

package/src/adapters/bilibili/subtitle.ts

@@ -0,0 +1,82 @@
+/**
+ * Bilibili video subtitle extractor.
+ *
+ * Uses /x/player/wbi/v2 to get subtitle metadata,
+ * then fetches the actual subtitle JSON file.
+ */
+
+import { cli, Strategy } from "../../registry.js";
+import { wbiFetch } from "./wbi.js";
+
+interface SubtitleInfo {
+  subtitle_url: string;
+}
+
+interface PlayerResponse {
+  data: {
+    subtitle: {
+      subtitles: SubtitleInfo[];
+    };
+  };
+}
+
+interface SubtitleEntry {
+  from: number;
+  to: number;
+  content: string;
+}
+
+interface SubtitleFile {
+  body: SubtitleEntry[];
+}
+
+cli({
+  site: "bilibili",
+  name: "subtitle",
+  description: "Extract subtitles from a Bilibili video",
+  domain: "api.bilibili.com",
+  strategy: Strategy.COOKIE,
+  args: [
+    {
+      name: "bvid",
+      required: true,
+      positional: true,
+      description: "Video bvid (e.g. BV1xx...)",
+    },
+  ],
+  columns: ["from", "to", "content"],
+  func: async (_page, kwargs) => {
+    const bvid = String(kwargs.bvid);
+
+    const playerJson = (await wbiFetch(
+      "https://api.bilibili.com/x/player/wbi/v2",
+      { bvid },
+    )) as PlayerResponse;
+
+    const subtitles = playerJson.data.subtitle.subtitles;
+    if (!subtitles || subtitles.length === 0) {
+      return [];
+    }
+
+    // Use the first available subtitle track
+    let subtitleUrl = subtitles[0].subtitle_url;
+    // Bilibili sometimes returns protocol-relative URLs
+    if (subtitleUrl.startsWith("//")) {
+      subtitleUrl = "https:" + subtitleUrl;
+    }
+
+    const resp = await fetch(subtitleUrl);
+    if (!resp.ok) {
+      throw new Error(
+        `Failed to fetch subtitle file: ${resp.status} ${resp.statusText}`,
+      );
+    }
+    const subtitleData = (await resp.json()) as SubtitleFile;
+
+    return (subtitleData.body ?? []).map((entry) => ({
+      from: entry.from,
+      to: entry.to,
+      content: entry.content,
+    }));
+  },
+});