@sovovs/bycli 1.8.0

package/clis/bilibili/utils.js

@@ -0,0 +1,184 @@
+/**
+ * Bilibili shared helpers: WBI signing, authenticated fetch, nav data, UID resolution.
+ */
+import https from 'node:https';
+import { AuthRequiredError, CommandExecutionError, EmptyResultError } from '@sovovs/bycli/errors';
+/**
+ * Resolve Bilibili short URL / short code to BV ID.
+ * Supports: BV1MV9NBtENN, XYzsqGa, b23.tv/XYzsqGa, https://b23.tv/XYzsqGa
+ */
+export function resolveBvid(input) {
+    const trimmed = String(input).trim();
+    if (/^BV[A-Za-z0-9]+$/i.test(trimmed)) {
+        return Promise.resolve(trimmed);
+    }
+    try {
+        const parsed = new URL(trimmed);
+        if (/(\.|^)bilibili\.com$/i.test(parsed.hostname)) {
+            const match = parsed.pathname.match(/\/(?:video|bangumi\/play)\/(BV[A-Za-z0-9]+)/i);
+            if (match) {
+                return Promise.resolve(match[1]);
+            }
+        }
+    }
+    catch {
+        // Non-URL inputs fall through to b23.tv short-code resolution.
+    }
+    const shortCode = trimmed.replace(/^https?:\/\//, '').replace(/^(www\.)?b23\.tv\//, '');
+    if (!/^[A-Za-z0-9]+$/.test(shortCode)) {
+        return Promise.reject(new Error(`Cannot resolve BV ID from invalid b23.tv short code: ${trimmed}`));
+    }
+    const url = 'https://b23.tv/' + shortCode;
+    return new Promise((resolve, reject) => {
+        const req = https.get(url, (res) => {
+            const location = res.headers.location;
+            if (location) {
+                const match = location.match(/\/video\/(BV[A-Za-z0-9]+)/);
+                if (match) {
+                    res.resume();
+                    resolve(match[1]);
+                    return;
+                }
+            }
+            res.resume();
+            reject(new Error(`Cannot resolve BV ID from short URL: ${trimmed}`));
+        });
+        req.on('error', reject);
+        req.setTimeout(4000, () => { req.destroy(); reject(new Error(`Timeout resolving short URL: ${trimmed}`)); });
+    });
+}
+const MIXIN_KEY_ENC_TAB = [
+    46, 47, 18, 2, 53, 8, 23, 32, 15, 50, 10, 31, 58, 3, 45, 35, 27, 43, 5, 49,
+    33, 9, 42, 19, 29, 28, 14, 39, 12, 38, 41, 13, 37, 48, 7, 16, 24, 55, 40,
+    61, 26, 17, 0, 1, 60, 51, 30, 4, 22, 25, 54, 21, 56, 59, 6, 63, 57, 62, 11,
+    36, 20, 34, 44, 52,
+];
+export function stripHtml(s) {
+    return s.replace(/<[^>]+>/g, '').replace(/&[a-z]+;/gi, ' ').trim();
+}
+export function payloadData(payload) {
+    return payload?.data ?? payload;
+}
+async function getNavData(page) {
+    return page.evaluate(`
+    async () => {
+      const res = await fetch('https://api.bilibili.com/x/web-interface/nav', { credentials: 'include' });
+      return await res.json();
+    }
+  `);
+}
+async function getWbiKeys(page) {
+    const nav = await getNavData(page);
+    const wbiImg = nav?.data?.wbi_img ?? {};
+    const imgUrl = wbiImg.img_url ?? '';
+    const subUrl = wbiImg.sub_url ?? '';
+    const imgKey = imgUrl.split('/').pop()?.split('.')[0] ?? '';
+    const subKey = subUrl.split('/').pop()?.split('.')[0] ?? '';
+    return { imgKey, subKey };
+}
+function getMixinKey(imgKey, subKey) {
+    const raw = imgKey + subKey;
+    return MIXIN_KEY_ENC_TAB.map(i => raw[i] || '').join('').slice(0, 32);
+}
+async function md5(text) {
+    const { createHash } = await import('node:crypto');
+    return createHash('md5').update(text).digest('hex');
+}
+export async function wbiSign(page, params) {
+    const { imgKey, subKey } = await getWbiKeys(page);
+    const mixinKey = getMixinKey(imgKey, subKey);
+    const wts = Math.floor(Date.now() / 1000);
+    const sorted = {};
+    const allParams = { ...params, wts: String(wts) };
+    for (const key of Object.keys(allParams).sort()) {
+        sorted[key] = String(allParams[key]).replace(/[!'()*]/g, '');
+    }
+    // Bilibili WBI verification expects %20 for spaces, not + (URLSearchParams default).
+    // Using + causes signature mismatch → CORS-blocked error response → TypeError: Failed to fetch.
+    const query = new URLSearchParams(sorted).toString().replace(/\+/g, '%20');
+    const wRid = await md5(query + mixinKey);
+    sorted.w_rid = wRid;
+    return sorted;
+}
+export async function apiGet(page, path, opts = {}) {
+    const baseUrl = 'https://api.bilibili.com';
+    let params = opts.params ?? {};
+    if (opts.signed) {
+        params = await wbiSign(page, params);
+    }
+    const qs = new URLSearchParams(Object.fromEntries(Object.entries(params).map(([k, v]) => [k, String(v)]))).toString().replace(/\+/g, '%20');
+    const url = `${baseUrl}${path}?${qs}`;
+    return fetchJson(page, url);
+}
+export async function fetchJson(page, url) {
+    const urlJs = JSON.stringify(url);
+    return page.evaluate(`
+    async () => {
+      const res = await fetch(${urlJs}, { credentials: "include" });
+      return await res.json();
+    }
+  `);
+}
+/**
+ * POST form-encoded params to a Bilibili API endpoint.
+ * Runs inside the logged-in browser context and auto-attaches the bili_jct CSRF token,
+ * which Bilibili requires on every authenticated write request.
+ */
+export async function apiPost(page, path, opts = {}) {
+    const params = opts.params ?? {};
+    const stringified = Object.fromEntries(Object.entries(params).map(([k, v]) => [k, String(v)]));
+    const paramsJs = JSON.stringify(stringified);
+    const urlJs = JSON.stringify(`https://api.bilibili.com${path}`);
+    return page.evaluate(`
+    async () => {
+      const csrf = (document.cookie.match(/bili_jct=([^;]+)/) || [])[1] || "";
+      const body = new URLSearchParams(${paramsJs});
+      body.set("csrf", csrf);
+      const res = await fetch(${urlJs}, {
+        method: "POST",
+        credentials: "include",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: body.toString(),
+      });
+      // Bilibili write endpoints can return an HTML risk-control page (e.g. HTTP 412)
+      // instead of JSON. Surface that as a structured error rather than a parse crash.
+      const text = await res.text();
+      try {
+        return JSON.parse(text);
+      } catch {
+        return { code: -1, message: "Non-JSON response (HTTP " + res.status + "): " + text.slice(0, 200) };
+      }
+    }
+  `);
+}
+export async function getSelfUid(page) {
+    const nav = await getNavData(page);
+    const mid = nav?.data?.mid;
+    if (!mid)
+        throw new AuthRequiredError('bilibili.com');
+    return String(mid);
+}
+export async function resolveUid(page, input) {
+    if (/^\d+$/.test(input))
+        return input;
+    // Search for user by name
+    const payload = await apiGet(page, '/x/web-interface/wbi/search/type', {
+        params: { search_type: 'bili_user', keyword: input },
+        signed: true,
+    });
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload) || !payload.data || typeof payload.data !== 'object' || Array.isArray(payload.data) || !Object.hasOwn(payload.data, 'result')) {
+        throw new CommandExecutionError(`Bilibili user search returned malformed result for ${input}`);
+    }
+    const results = payload.data.result;
+    if (!Array.isArray(results)) {
+        throw new CommandExecutionError(`Bilibili user search returned malformed result for ${input}`);
+    }
+    if (results.length > 0) {
+        const mid = String(results[0]?.mid ?? '').trim();
+        if (!mid) {
+            throw new CommandExecutionError(`Bilibili user search returned malformed mid for ${input}`);
+        }
+        return mid;
+    }
+    throw new EmptyResultError(`bilibili user search: ${input}`, 'User may not exist or username may have changed.');
+}

package/clis/bilibili/utils.test.js

@@ -0,0 +1,61 @@
+import { describe, expect, it } from 'vitest';
+import { CommandExecutionError, EmptyResultError } from '@sovovs/bycli/errors';
+import { resolveBvid, resolveUid } from './utils.js';
+describe('resolveBvid', () => {
+    it('passes through a valid BV ID', async () => {
+        expect(await resolveBvid('BV1MV9NBtENN')).toBe('BV1MV9NBtENN');
+    });
+    it('passes through BV ID with surrounding whitespace', async () => {
+        expect(await resolveBvid('  BV1MV9NBtENN  ')).toBe('BV1MV9NBtENN');
+    });
+    it('handles non-string input via String() coercion', async () => {
+        expect(await resolveBvid('BV123abc')).toBe('BV123abc');
+    });
+    it('extracts BV IDs from bilibili video URLs', async () => {
+        expect(await resolveBvid('https://www.bilibili.com/video/BV1xx411c7mD/?spm_id_from=333.1007')).toBe('BV1xx411c7mD');
+        expect(await resolveBvid('https://m.bilibili.com/video/BV1Je9EBnEha')).toBe('BV1Je9EBnEha');
+    });
+    it('rejects invalid input that cannot be resolved', async () => {
+        // A random string that b23.tv won't resolve — should timeout or fail
+        await expect(resolveBvid('not-a-valid-code-99999')).rejects.toThrow();
+    });
+});
+
+describe('resolveUid', () => {
+    function pageWithUserSearchResult(result) {
+        return {
+            evaluate: async (script) => {
+                if (String(script).includes('/x/web-interface/nav')) {
+                    return {
+                        data: {
+                            wbi_img: {
+                                img_url: 'https://i0.hdslb.com/bfs/wbi/abcdefghijklmnopqrstuvwxyz123456.png',
+                                sub_url: 'https://i0.hdslb.com/bfs/wbi/ABCDEFGHIJKLMNOPQRSTUVWXYZ123456.png',
+                            },
+                        },
+                    };
+                }
+                return result;
+            },
+        };
+    }
+
+    it('returns numeric uid input without searching', async () => {
+        expect(await resolveUid({}, '12345')).toBe('12345');
+    });
+
+    it('fails closed when user search payload lacks result', async () => {
+        await expect(resolveUid(pageWithUserSearchResult({ code: 0, data: {} }), 'missing'))
+            .rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('fails closed when user search result row lacks mid', async () => {
+        await expect(resolveUid(pageWithUserSearchResult({ code: 0, data: { result: [{}] } }), 'missing-mid'))
+            .rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('keeps explicit no-user result as EmptyResultError', async () => {
+        await expect(resolveUid(pageWithUserSearchResult({ code: 0, data: { result: [] } }), 'nobody'))
+            .rejects.toBeInstanceOf(EmptyResultError);
+    });
+});

package/clis/bilibili/video.js

@@ -0,0 +1,69 @@
+import { cli, Strategy } from '@sovovs/bycli/registry';
+import { CommandExecutionError } from '@sovovs/bycli/errors';
+import { apiGet, resolveBvid } from './utils.js';
+
+cli({
+  site: 'bilibili',
+  name: 'video',
+    access: 'read',
+  description: 'Get Bilibili video metadata (title, author, duration, stats, etc.)',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'bvid', required: true, positional: true, help: 'BV ID, video URL, or b23.tv short link' },
+  ],
+  columns: ['field', 'value'],
+  func: async (page, kwargs) => {
+    if (!page) {
+      throw new CommandExecutionError('Browser session required for bilibili video');
+    }
+
+    // Resolve BV ID from three advertised input forms:
+    //   1. Bare "BV..." id
+    //   2. Full bilibili.com/video/<BV>... URL (with or without query string / www / m.)
+    //   3. b23.tv short link (delegated to resolveBvid)
+    // resolveBvid() alone handles (1) and (3) but not (2), so we pre-extract
+    // from bilibili URLs before falling through.
+    const input = String(kwargs.bvid ?? '').trim();
+    const bilibiliUrlMatch = input.match(/bilibili\.com\/(?:video|bangumi\/play)\/(BV[A-Za-z0-9]+)/i);
+    const bvid = bilibiliUrlMatch ? bilibiliUrlMatch[1] : await resolveBvid(input);
+
+    // Navigate to video page first so subsequent api call shares a primed session.
+    await page.goto(`https://www.bilibili.com/video/${bvid}/`);
+
+    const payload = await apiGet(page, '/x/web-interface/view', {
+      params: { bvid },
+    });
+    if (payload.code !== 0) {
+      throw new CommandExecutionError(`Bilibili view API failed: ${payload.message} (${payload.code})`);
+    }
+
+    const d = payload.data || {};
+    const stat = d.stat || {};
+    const owner = d.owner || {};
+
+    const pubDate = d.pubdate ? new Date(d.pubdate * 1000).toISOString().slice(0, 16).replace('T', ' ') : '';
+    const dur = d.duration || 0;
+    const mm = Math.floor(dur / 60);
+    const ss = dur % 60;
+
+    return [
+      { field: 'bvid',         value: d.bvid ?? '' },
+      { field: 'aid',          value: String(d.aid ?? '') },
+      { field: 'title',        value: d.title ?? '' },
+      { field: 'author',       value: owner.name ? `${owner.name} (mid: ${owner.mid})` : '' },
+      { field: 'category',     value: d.tname_v2 || d.tname || '' },
+      { field: 'publish_time', value: pubDate },
+      { field: 'duration',     value: dur ? `${mm}m${ss}s (${dur}s)` : '' },
+      { field: 'view',         value: String(stat.view ?? '') },
+      { field: 'danmaku',      value: String(stat.danmaku ?? '') },
+      { field: 'reply',        value: String(stat.reply ?? '') },
+      { field: 'like',         value: String(stat.like ?? '') },
+      { field: 'coin',         value: String(stat.coin ?? '') },
+      { field: 'favorite',     value: String(stat.favorite ?? '') },
+      { field: 'share',        value: String(stat.share ?? '') },
+      { field: 'parts',        value: String(d.videos ?? 1) },
+      { field: 'thumbnail',    value: d.pic ?? '' },
+      { field: 'description',  value: d.desc ?? '' },
+    ];
+  },
+});

package/clis/bilibili/video.test.js

@@ -0,0 +1,132 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { CommandExecutionError } from '@sovovs/bycli/errors';
+
+const { mockApiGet } = vi.hoisted(() => ({
+  mockApiGet: vi.fn(),
+}));
+
+vi.mock('./utils.js', async (importOriginal) => ({
+  ...(await importOriginal()),
+  apiGet: mockApiGet,
+}));
+
+import { getRegistry } from '@sovovs/bycli/registry';
+import './video.js';
+
+describe('bilibili video', () => {
+  const command = getRegistry().get('bilibili/video');
+  const page = {
+    goto: vi.fn().mockResolvedValue(undefined),
+    evaluate: vi.fn(),
+  };
+
+  beforeEach(() => {
+    mockApiGet.mockReset();
+    page.goto.mockClear();
+    page.evaluate.mockReset();
+  });
+
+  it('returns a field/value table of video metadata on success', async () => {
+    mockApiGet.mockResolvedValueOnce({
+      code: 0,
+      data: {
+        bvid: 'BV1xx411c7mD',
+        aid: 12345678,
+        title: '三层结构笔记法',
+        tname: '教程',
+        pubdate: 1775053078, // 2026-04-01 14:17:58 UTC
+        duration: 434,
+        videos: 1,
+        pic: 'https://i1.hdslb.com/some.jpg',
+        desc: 'Obsidian 教程',
+        owner: { mid: 507578555, name: 'IOI科技' },
+        stat: { view: 6128, danmaku: 0, reply: 21, like: 162, coin: 48, favorite: 564, share: 26 },
+      },
+    });
+
+    const rows = await command.func(page, { bvid: 'BV1xx411c7mD' });
+
+    // Every row has { field, value }
+    expect(Array.isArray(rows)).toBe(true);
+    for (const row of rows) {
+      expect(row).toHaveProperty('field');
+      expect(row).toHaveProperty('value');
+    }
+
+    const byField = Object.fromEntries(rows.map((r) => [r.field, r.value]));
+    expect(byField.bvid).toBe('BV1xx411c7mD');
+    expect(byField.title).toBe('三层结构笔记法');
+    expect(byField.author).toBe('IOI科技 (mid: 507578555)');
+    expect(byField.duration).toBe('7m14s (434s)');
+    expect(byField.view).toBe('6128');
+    expect(byField.like).toBe('162');
+
+    // Navigation primes the session
+    expect(page.goto).toHaveBeenCalledWith('https://www.bilibili.com/video/BV1xx411c7mD/');
+    // API called without signing
+    expect(mockApiGet).toHaveBeenCalledWith(page, '/x/web-interface/view', { params: { bvid: 'BV1xx411c7mD' } });
+  });
+
+  it('throws CommandExecutionError when bilibili view API returns non-zero code', async () => {
+    mockApiGet.mockResolvedValueOnce({
+      code: -404,
+      message: '啥都木有',
+      data: null,
+    });
+
+    await expect(command.func(page, { bvid: 'BV1xx411c7mD' })).rejects.toSatisfy(
+      (err) => err instanceof CommandExecutionError && /啥都木有|-404/.test(err.message),
+    );
+  });
+
+  it('extracts BV ID from full bilibili.com URL input', async () => {
+    mockApiGet.mockResolvedValueOnce({
+      code: 0,
+      data: { bvid: 'BV1xx411c7mD', stat: {}, owner: {}, desc: '' },
+    });
+
+    await command.func(page, { bvid: 'https://www.bilibili.com/video/BV1xx411c7mD/' });
+
+    expect(page.goto).toHaveBeenCalledWith('https://www.bilibili.com/video/BV1xx411c7mD/');
+    expect(mockApiGet).toHaveBeenCalledWith(page, '/x/web-interface/view', { params: { bvid: 'BV1xx411c7mD' } });
+  });
+
+  it('extracts BV ID from bilibili URL with trailing query string', async () => {
+    mockApiGet.mockResolvedValueOnce({
+      code: 0,
+      data: { bvid: 'BV1Je9EBnEha', stat: {}, owner: {}, desc: '' },
+    });
+
+    await command.func(page, {
+      bvid: 'https://www.bilibili.com/video/BV1Je9EBnEha/?spm_id_from=333.1007&vd_source=abc',
+    });
+
+    expect(mockApiGet).toHaveBeenCalledWith(page, '/x/web-interface/view', { params: { bvid: 'BV1Je9EBnEha' } });
+  });
+
+  it('extracts BV ID from m.bilibili.com mobile URL', async () => {
+    mockApiGet.mockResolvedValueOnce({
+      code: 0,
+      data: { bvid: 'BV1xx411c7mD', stat: {}, owner: {}, desc: '' },
+    });
+
+    await command.func(page, { bvid: 'https://m.bilibili.com/video/BV1xx411c7mD' });
+
+    expect(mockApiGet).toHaveBeenCalledWith(page, '/x/web-interface/view', { params: { bvid: 'BV1xx411c7mD' } });
+  });
+
+  it('returns full description without truncation or whitespace collapse', async () => {
+    const longDesc = '第一行描述\n\n第二段，有多个空格   和换行\n\n' + 'x'.repeat(500);
+    mockApiGet.mockResolvedValueOnce({
+      code: 0,
+      data: { bvid: 'BV1xx411c7mD', stat: {}, owner: {}, desc: longDesc },
+    });
+
+    const rows = await command.func(page, { bvid: 'BV1xx411c7mD' });
+    const byField = Object.fromEntries(rows.map((r) => [r.field, r.value]));
+    // JSON/YAML consumers must receive the complete description verbatim,
+    // including original whitespace and length > 200 chars.
+    expect(byField.description).toBe(longDesc);
+    expect(byField.description.length).toBeGreaterThan(200);
+  });
+});

package/clis/binance/asks.js

@@ -0,0 +1,22 @@
+import { cli, Strategy } from '@sovovs/bycli/registry';
+
+cli({
+  site: 'binance',
+  name: 'asks',
+    access: 'read',
+  description: 'Order book ask prices for a trading pair',
+  domain: 'data-api.binance.vision',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [
+    { name: 'symbol', type: 'str', required: true, positional: true, help: 'Trading pair symbol (e.g. BTCUSDT, ETHUSDT)' },
+    { name: 'limit', type: 'int', default: 10, help: 'Number of price levels (5, 10, 20, 50, 100)' },
+  ],
+  columns: ['rank', 'ask_price', 'ask_qty'],
+  pipeline: [
+    { fetch: { url: 'https://data-api.binance.vision/api/v3/depth?symbol=${{ args.symbol }}&limit=${{ args.limit }}' } },
+    { select: 'asks' },
+    { map: { rank: '${{ index + 1 }}', ask_price: '${{ item.0 }}', ask_qty: '${{ item.1 }}' } },
+    { limit: '${{ args.limit }}' },
+  ],
+});

package/clis/binance/commands.test.js

@@ -0,0 +1,70 @@
+import { getRegistry } from '@sovovs/bycli/registry';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { executePipeline } from '@sovovs/bycli/pipeline';
+
+// Import all binance adapters to register them
+import './top.js';
+import './gainers.js';
+import './pairs.js';
+
+function loadPipeline(name) {
+  const cmd = getRegistry().get(`binance/${name}`);
+  if (!cmd?.pipeline) throw new Error(`Command binance/${name} not found or has no pipeline`);
+  return cmd.pipeline;
+}
+
+function mockJsonOnce(payload) {
+  vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+    ok: true,
+    status: 200,
+    statusText: 'OK',
+    json: vi.fn().mockResolvedValue(payload),
+  }));
+}
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+  vi.restoreAllMocks();
+});
+
+describe('binance adapters', () => {
+  it('sorts top pairs by numeric quote volume', async () => {
+    mockJsonOnce([
+      { symbol: 'SMALL', lastPrice: '1', priceChangePercent: '1.2', highPrice: '1', lowPrice: '1', quoteVolume: '9.9' },
+      { symbol: 'LARGE', lastPrice: '2', priceChangePercent: '2.3', highPrice: '2', lowPrice: '2', quoteVolume: '100.0' },
+      { symbol: 'MID', lastPrice: '3', priceChangePercent: '3.4', highPrice: '3', lowPrice: '3', quoteVolume: '11.0' },
+    ]);
+
+    const result = await executePipeline(null, loadPipeline('top'), { args: { limit: 3 } });
+
+    expect(result.map((item) => item.symbol)).toEqual(['LARGE', 'MID', 'SMALL']);
+    expect(result.map((item) => item.rank)).toEqual([1, 2, 3]);
+  });
+
+  it('sorts gainers by numeric percent change', async () => {
+    mockJsonOnce([
+      { symbol: 'TEN', lastPrice: '1', priceChangePercent: '10.0', quoteVolume: '100' },
+      { symbol: 'NINE', lastPrice: '1', priceChangePercent: '9.5', quoteVolume: '100' },
+      { symbol: 'HUNDRED', lastPrice: '1', priceChangePercent: '100.0', quoteVolume: '100' },
+    ]);
+
+    const result = await executePipeline(null, loadPipeline('gainers'), { args: { limit: 3 } });
+
+    expect(result.map((item) => item.symbol)).toEqual(['HUNDRED', 'TEN', 'NINE']);
+  });
+
+  it('keeps only TRADING pairs', async () => {
+    mockJsonOnce({
+      symbols: [
+        { symbol: 'BTCUSDT', baseAsset: 'BTC', quoteAsset: 'USDT', status: 'TRADING' },
+        { symbol: 'OLDPAIR', baseAsset: 'OLD', quoteAsset: 'USDT', status: 'BREAK' },
+      ],
+    });
+
+    const result = await executePipeline(null, loadPipeline('pairs'), { args: { limit: 10 } });
+
+    expect(result).toEqual([
+      { symbol: 'BTCUSDT', base: 'BTC', quote: 'USDT', status: 'TRADING' },
+    ]);
+  });
+});

package/clis/binance/depth.js

@@ -0,0 +1,21 @@
+import { cli, Strategy } from '@sovovs/bycli/registry';
+
+cli({
+  site: 'binance',
+  name: 'depth',
+    access: 'read',
+  description: 'Order book bid and ask prices for a trading pair',
+  domain: 'data-api.binance.vision',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [
+    { name: 'symbol', type: 'str', required: true, positional: true, help: 'Trading pair symbol (e.g. BTCUSDT, ETHUSDT)' },
+    { name: 'limit', type: 'int', default: 10, help: 'Number of price levels (5, 10, 20, 50, 100)' },
+  ],
+  columns: ['rank', 'bid_price', 'bid_qty', 'ask_price', 'ask_qty'],
+  pipeline: [
+    { fetch: { url: 'https://data-api.binance.vision/api/v3/depth?symbol=${{ args.symbol }}&limit=${{ args.limit }}' } },
+    { map: { select: 'bids', rank: '${{ index + 1 }}', bid_price: '${{ item[0] }}', bid_qty: '${{ item[1] }}', ask_price: '${{ root.asks[index]?.[0] ?? "" }}', ask_qty: '${{ root.asks[index]?.[1] ?? "" }}' } },
+    { limit: '${{ args.limit }}' },
+  ],
+});

package/clis/binance/gainers.js

@@ -0,0 +1,23 @@
+import { cli, Strategy } from '@sovovs/bycli/registry';
+
+cli({
+  site: 'binance',
+  name: 'gainers',
+    access: 'read',
+  description: 'Top gaining trading pairs by 24h price change',
+  domain: 'data-api.binance.vision',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [
+    { name: 'limit', type: 'int', default: 10, help: 'Number of trading pairs' },
+  ],
+  columns: ['rank', 'symbol', 'price', 'change_24h', 'volume'],
+  pipeline: [
+    { fetch: { url: 'https://data-api.binance.vision/api/v3/ticker/24hr' } },
+    { filter: 'item.priceChangePercent' },
+    { map: { symbol: '${{ item.symbol }}', price: '${{ item.lastPrice }}', change_24h: '${{ item.priceChangePercent }}', volume: '${{ item.quoteVolume }}', sort_change: '${{ Number(item.priceChangePercent) }}' } },
+    { sort: { by: 'sort_change', order: 'desc' } },
+    { map: { rank: '${{ index + 1 }}', symbol: '${{ item.symbol }}', price: '${{ item.lastPrice }}', change_24h: '${{ item.priceChangePercent }}', volume: '${{ item.quoteVolume }}' } },
+    { limit: '${{ args.limit }}' },
+  ],
+});

package/clis/binance/klines.js

@@ -0,0 +1,22 @@
+import { cli, Strategy } from '@sovovs/bycli/registry';
+
+cli({
+  site: 'binance',
+  name: 'klines',
+    access: 'read',
+  description: 'Candlestick/kline data for a trading pair',
+  domain: 'data-api.binance.vision',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [
+    { name: 'symbol', type: 'str', required: true, positional: true, help: 'Trading pair symbol (e.g. BTCUSDT, ETHUSDT)' },
+    { name: 'interval', type: 'str', default: '1d', help: 'Kline interval (1m, 5m, 15m, 1h, 4h, 1d, 1w, 1M)' },
+    { name: 'limit', type: 'int', default: 10, help: 'Number of klines (max 1000)' },
+  ],
+  columns: ['open', 'high', 'low', 'close', 'volume'],
+  pipeline: [
+    { fetch: { url: 'https://data-api.binance.vision/api/v3/klines?symbol=${{ args.symbol }}&interval=${{ args.interval }}&limit=${{ args.limit }}' } },
+    { map: { open: '${{ item.1 }}', high: '${{ item.2 }}', low: '${{ item.3 }}', close: '${{ item.4 }}', volume: '${{ item.5 }}' } },
+    { limit: '${{ args.limit }}' },
+  ],
+});

package/clis/binance/losers.js

@@ -0,0 +1,23 @@
+import { cli, Strategy } from '@sovovs/bycli/registry';
+
+cli({
+  site: 'binance',
+  name: 'losers',
+    access: 'read',
+  description: 'Top losing trading pairs by 24h price change',
+  domain: 'data-api.binance.vision',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [
+    { name: 'limit', type: 'int', default: 10, help: 'Number of trading pairs' },
+  ],
+  columns: ['rank', 'symbol', 'price', 'change_24h', 'volume'],
+  pipeline: [
+    { fetch: { url: 'https://data-api.binance.vision/api/v3/ticker/24hr' } },
+    { filter: 'item.priceChangePercent' },
+    { map: { symbol: '${{ item.symbol }}', price: '${{ item.lastPrice }}', change_24h: '${{ item.priceChangePercent }}', volume: '${{ item.quoteVolume }}', sort_change: '${{ Number(item.priceChangePercent) }}' } },
+    { sort: { by: 'sort_change' } },
+    { map: { rank: '${{ index + 1 }}', symbol: '${{ item.symbol }}', price: '${{ item.lastPrice }}', change_24h: '${{ item.priceChangePercent }}', volume: '${{ item.quoteVolume }}' } },
+    { limit: '${{ args.limit }}' },
+  ],
+});

package/clis/binance/pairs.js

@@ -0,0 +1,22 @@
+import { cli, Strategy } from '@sovovs/bycli/registry';
+
+cli({
+  site: 'binance',
+  name: 'pairs',
+    access: 'read',
+  description: 'List active trading pairs on Binance',
+  domain: 'data-api.binance.vision',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [
+    { name: 'limit', type: 'int', default: 20, help: 'Number of trading pairs' },
+  ],
+  columns: ['symbol', 'base', 'quote', 'status'],
+  pipeline: [
+    { fetch: { url: 'https://data-api.binance.vision/api/v3/exchangeInfo' } },
+    { select: 'symbols' },
+    { filter: 'item.status === \'TRADING\'' },
+    { map: { symbol: '${{ item.symbol }}', base: '${{ item.baseAsset }}', quote: '${{ item.quoteAsset }}', status: '${{ item.status }}' } },
+    { limit: '${{ args.limit }}' },
+  ],
+});