@zenalexa/unicli 0.215.1 → 0.216.2

package/src/adapters/ke/rent-transaction.ts

@@ -0,0 +1,70 @@
+import { cli, Strategy } from "../../registry.js";
+import type { IPage } from "../../types.js";
+import { intArg, js, str } from "../_shared/browser-tools.js";
+
+async function extractKe(
+  page: IPage,
+  url: string,
+  limit: number,
+): Promise<Record<string, unknown>[]> {
+  await page.goto(url, { settleMs: 3000 });
+  const rows = await page.evaluate(`(() => {
+    const cards = [...document.querySelectorAll('.content__list--item, .sellListContent li, .listContent li, li.clear')];
+    return cards.map((card) => {
+      const link = card.querySelector('a[href]');
+      const text = (card.textContent || '').replace(/\\s+/g, ' ').trim();
+      return {
+        title: (card.querySelector('.title, .content__list--item--title, a[href]')?.textContent || '').replace(/\\s+/g, ' ').trim(),
+        location: (card.querySelector('.positionInfo, .content__list--item--des')?.textContent || '').replace(/\\s+/g, ' ').trim(),
+        price: (card.querySelector('.totalPrice, .content__list--item-price, .unitPrice')?.textContent || '').replace(/\\s+/g, ' ').trim(),
+        date: (text.match(/\\d{4}[-年.]\\d{1,2}[-月.]\\d{1,2}/) || [''])[0],
+        url: link ? new URL(link.getAttribute('href') || '', location.href).href : '',
+        summary: text.slice(0, 260)
+      };
+    }).filter((row) => row.title).slice(0, ${js(limit)});
+  })()`);
+  return Array.isArray(rows) ? (rows as Record<string, unknown>[]) : [];
+}
+
+cli({
+  site: "ke",
+  name: "zufang",
+  description: "Browse Ke.com rental listings",
+  domain: "ke.com",
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [
+    { name: "city", type: "str", default: "bj" },
+    { name: "district", type: "str", required: false },
+    { name: "max_price", type: "int", required: false },
+    { name: "limit", type: "int", default: 20 },
+  ],
+  columns: ["title", "location", "price", "url"],
+  func: async (page, kwargs) => {
+    const city = str(kwargs.city, "bj");
+    const district = str(kwargs.district);
+    const url = `https://${city}.ke.com/zufang/${district}`;
+    return extractKe(page as IPage, url, intArg(kwargs.limit, 20, 100));
+  },
+});
+
+cli({
+  site: "ke",
+  name: "chengjiao",
+  description: "Browse Ke.com recent transaction records",
+  domain: "ke.com",
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [
+    { name: "city", type: "str", default: "bj" },
+    { name: "district", type: "str", required: false },
+    { name: "limit", type: "int", default: 20 },
+  ],
+  columns: ["title", "location", "price", "date", "url"],
+  func: async (page, kwargs) => {
+    const city = str(kwargs.city, "bj");
+    const district = str(kwargs.district);
+    const url = `https://${city}.ke.com/chengjiao/${district}`;
+    return extractKe(page as IPage, url, intArg(kwargs.limit, 20, 100));
+  },
+});

package/src/adapters/linux-do/search.ts

@@ -0,0 +1,92 @@
+import { cli, Strategy } from "../../registry.js";
+import type { IPage } from "../../types.js";
+
+const HOME = "https://linux.do";
+
+function limitOf(value: unknown): number {
+  const n = Number(value ?? 20);
+  if (!Number.isFinite(n)) return 20;
+  return Math.max(1, Math.min(100, Math.trunc(n)));
+}
+
+async function fetchLinuxDoJson(
+  page: IPage,
+  path: string,
+): Promise<Record<string, unknown>> {
+  await page.goto(HOME, { settleMs: 1500 });
+  const result = (await page.evaluate(`(async () => {
+    const response = await fetch(${JSON.stringify(path)}, {
+      credentials: "include",
+      headers: { accept: "application/json" }
+    });
+    let data = null;
+    try { data = await response.json(); } catch {}
+    return {
+      ok: response.ok,
+      status: response.status,
+      data,
+      error: data === null ? "Response is not valid JSON" : ""
+    };
+  })()`)) as {
+    ok?: boolean;
+    status?: number;
+    data?: Record<string, unknown>;
+    error?: string;
+  };
+
+  if (result.status === 401 || result.status === 403) {
+    throw new Error("Authentication required for linux-do");
+  }
+  if (!result.ok) {
+    throw new Error(
+      result.error ||
+        `linux-do request failed: HTTP ${result.status ?? "unknown"}`,
+    );
+  }
+  return result.data ?? {};
+}
+
+cli({
+  site: "linux-do",
+  name: "search",
+  description: "Search Linux.do forum topics",
+  domain: "linux.do",
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [
+    {
+      name: "query",
+      type: "str",
+      required: true,
+      positional: true,
+      description: "Search query",
+    },
+    {
+      name: "limit",
+      type: "int",
+      default: 20,
+      description: "Number of results",
+    },
+  ],
+  columns: ["rank", "title", "views", "likes", "replies", "url"],
+  func: async (page, kwargs) => {
+    const query = String(kwargs.query ?? "");
+    const limit = limitOf(kwargs.limit);
+    const data = await fetchLinuxDoJson(
+      page as IPage,
+      `/search.json?q=${encodeURIComponent(query)}`,
+    );
+    const topics = Array.isArray(data.topics) ? data.topics : [];
+    return topics.slice(0, limit).map((topic, index) => {
+      const item = topic as Record<string, unknown>;
+      return {
+        rank: index + 1,
+        title: String(item.title ?? ""),
+        views: Number(item.views ?? 0),
+        likes: Number(item.like_count ?? 0),
+        replies: Number(item.posts_count ?? 1) - 1,
+        url: `https://linux.do/t/topic/${String(item.id ?? "")}`,
+      };
+    });
+  },
+});

package/src/adapters/linux-do/topic-content.ts

@@ -0,0 +1,45 @@
+import TurndownService from "turndown";
+import { cli, Strategy } from "../../registry.js";
+
+interface TopicPost {
+  cooked?: string;
+  username?: string;
+  created_at?: string;
+}
+
+interface TopicResponse {
+  title?: string;
+  post_stream?: {
+    posts?: TopicPost[];
+  };
+}
+
+cli({
+  site: "linux-do",
+  name: "topic-content",
+  description: "Read the main Linux.do topic body as Markdown",
+  domain: "linux.do",
+  strategy: Strategy.PUBLIC,
+  args: [{ name: "id", type: "int", required: true, positional: true }],
+  columns: ["title", "author", "content"],
+  func: async (_page, kwargs) => {
+    const id = Number(kwargs.id);
+    const response = await fetch(`https://linux.do/t/${id}.json`, {
+      headers: { accept: "application/json" },
+    });
+    if (!response.ok) {
+      throw new Error(`linux-do topic request failed: HTTP ${response.status}`);
+    }
+    const data = (await response.json()) as TopicResponse;
+    const first = data.post_stream?.posts?.[0] ?? {};
+    const turndown = new TurndownService({ headingStyle: "atx" });
+    return [
+      {
+        title: data.title ?? "",
+        author: first.username ?? "",
+        created_at: first.created_at ?? "",
+        content: turndown.turndown(first.cooked ?? ""),
+      },
+    ];
+  },
+});

package/src/adapters/maimai/talents.ts

@@ -0,0 +1,65 @@
+import { cli, Strategy } from "../../registry.js";
+import type { IPage } from "../../types.js";
+import { intArg, js, str } from "../_shared/browser-tools.js";
+
+cli({
+  site: "maimai",
+  name: "search-talents",
+  description: "Search Maimai talent profiles with filters",
+  domain: "maimai.cn",
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [
+    { name: "query", type: "str", required: true, positional: true },
+    { name: "companies", type: "str", required: false },
+    { name: "schools", type: "str", required: false },
+    { name: "cities", type: "str", required: false },
+    { name: "page", type: "int", default: 0 },
+    { name: "size", type: "int", default: 20 },
+  ],
+  columns: ["name", "title", "company", "location"],
+  func: async (page, kwargs) => {
+    const p = page as IPage;
+    const size = intArg(kwargs.size, 20, 100);
+    const query = str(kwargs.query);
+    await p.goto("https://maimai.cn/ent/talents/discover/search_v2", {
+      settleMs: 3000,
+    });
+    const rows = await p.evaluate(`(async () => {
+      const response = await fetch('/ent/talents/discover/search_v2', {
+        method: 'POST',
+        credentials: 'include',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+          keywords: ${js(query)},
+          page: ${Number(kwargs.page ?? 0)},
+          size: ${size},
+          companies: ${js(str(kwargs.companies))},
+          schools: ${js(str(kwargs.schools))},
+          cities: ${js(str(kwargs.cities))}
+        })
+      }).catch(() => null);
+      if (response?.ok) {
+        const json = await response.json();
+        const list = json?.data?.list || json?.data?.items || [];
+        if (Array.isArray(list) && list.length) {
+          return list.map((item) => ({
+            name: item.name || item.real_name || '',
+            title: item.position || item.title || '',
+            company: item.company || item.company_name || '',
+            location: item.city || item.location || '',
+            raw: item
+          }));
+        }
+      }
+      const cards = [...document.querySelectorAll('[class*="talent"], [class*="card"], [role="listitem"]')];
+      return cards.map((card) => ({
+        name: (card.querySelector('[class*="name"]')?.textContent || '').trim(),
+        title: (card.querySelector('[class*="position"], [class*="title"]')?.textContent || '').trim(),
+        company: (card.querySelector('[class*="company"]')?.textContent || '').trim(),
+        location: (card.querySelector('[class*="city"], [class*="location"]')?.textContent || '').trim()
+      })).filter((row) => row.name || row.title).slice(0, ${size});
+    })()`);
+    return Array.isArray(rows) ? (rows as Record<string, unknown>[]) : [];
+  },
+});

package/src/adapters/mubu/docs.ts

@@ -0,0 +1,107 @@
+import { cli, Strategy } from "../../registry.js";
+import type { IPage } from "../../types.js";
+import { intArg, js, str, visibleText } from "../_shared/browser-tools.js";
+
+const APP = "https://mubu.com/app";
+
+async function readDocList(
+  page: IPage,
+  url: string,
+  limit: number,
+): Promise<Record<string, unknown>[]> {
+  await page.goto(url, { settleMs: 2500 });
+  const rows = (await page.evaluate(`(() => {
+    const cards = [...document.querySelectorAll('a[href*="/doc/"], [class*="doc-item"], [class*="document-item"], [class*="file-item"]')];
+    const seen = new Set();
+    return cards.map((card) => {
+      const link = card.matches?.('a') ? card : card.querySelector?.('a[href*="/doc/"]');
+      const url = link ? new URL(link.getAttribute('href') || '', location.href).href : '';
+      if (url && seen.has(url)) return null;
+      if (url) seen.add(url);
+      return {
+        title: (card.textContent || '').replace(/\\s+/g, ' ').trim().slice(0, 160),
+        url,
+        updated: (card.querySelector?.('[class*="time"], [class*="date"], [class*="update"]')?.textContent || '').trim()
+      };
+    }).filter((row) => row && row.title).slice(0, ${js(limit)});
+  })()`)) as Record<string, unknown>[];
+  return rows;
+}
+
+cli({
+  site: "mubu",
+  name: "docs",
+  description: "List Mubu documents and folders",
+  domain: "mubu.com",
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [
+    { name: "folder", type: "str", required: false },
+    { name: "starred", type: "bool", default: false },
+    { name: "limit", type: "int", default: 20 },
+  ],
+  columns: ["title", "updated", "url"],
+  func: async (page, kwargs) => {
+    const folder = str(kwargs.folder);
+    const url = folder ? `${APP}/folder/${encodeURIComponent(folder)}` : APP;
+    return readDocList(page as IPage, url, intArg(kwargs.limit, 20, 100));
+  },
+});
+
+cli({
+  site: "mubu",
+  name: "doc",
+  description: "Read a Mubu document as Markdown-like text",
+  domain: "mubu.com",
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [
+    { name: "id", type: "str", required: true, positional: true },
+    { name: "output", type: "str", default: "markdown" },
+  ],
+  columns: ["title", "content", "url"],
+  func: async (page, kwargs) => {
+    const p = page as IPage;
+    const id = str(kwargs.id);
+    const url = id.startsWith("http") ? id : `https://mubu.com/doc/${id}`;
+    await p.goto(url, { settleMs: 2500 });
+    const content = await visibleText(p);
+    return [{ title: await p.title(), content, url: await p.url() }];
+  },
+});
+
+cli({
+  site: "mubu",
+  name: "recent",
+  description: "List recently edited Mubu documents",
+  domain: "mubu.com",
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [{ name: "limit", type: "int", default: 20 }],
+  columns: ["title", "updated", "url"],
+  func: async (page, kwargs) =>
+    readDocList(page as IPage, `${APP}/recent`, intArg(kwargs.limit, 20, 100)),
+});
+
+cli({
+  site: "mubu",
+  name: "notes",
+  description: "Read Mubu quick notes for a date or date range",
+  domain: "mubu.com",
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [
+    { name: "date", type: "str", required: false },
+    { name: "month", type: "str", required: false },
+    { name: "from", type: "str", required: false },
+    { name: "to", type: "str", required: false },
+    { name: "list", type: "bool", default: false },
+  ],
+  columns: ["title", "content", "url"],
+  func: async (page) => {
+    const p = page as IPage;
+    await p.goto(`${APP}/notes`, { settleMs: 2500 });
+    const content = await visibleText(p);
+    return [{ title: await p.title(), content, url: await p.url() }];
+  },
+});