@zenalexa/unicli 0.218.1 → 0.220.0

package/src/adapters/dianping/shop.test.ts

@@ -0,0 +1,134 @@
+import { describe, expect, it, vi } from "vitest";
+import { resolveCommand } from "../../registry.js";
+import {
+  classifyDianpingShopFailure,
+  mapDianpingShopFields,
+  normalizeDianpingShopId,
+  parseDianpingPrice,
+  parseDianpingReviewCount,
+} from "./shop.js";
+
+function pageMock(evaluateResults: unknown[]) {
+  return {
+    goto: vi.fn().mockResolvedValue(undefined),
+    wait: vi.fn().mockResolvedValue(undefined),
+    evaluate: vi.fn(async () => evaluateResults.shift()),
+  };
+}
+
+describe("dianping shop agent-facing command", () => {
+  it("validates shop ids and parses Dianping numbers", () => {
+    expect(normalizeDianpingShopId("abc_123-DEF")).toBe("abc_123-DEF");
+    expect(
+      normalizeDianpingShopId("https://www.dianping.com/shop/abc_123?x=1"),
+    ).toBe("abc_123");
+    expect(() => normalizeDianpingShopId("")).toThrow("non-empty");
+    expect(() => normalizeDianpingShopId("bad/id")).toThrow("shop_id");
+    expect(parseDianpingReviewCount("1.2万条")).toBe(12000);
+    expect(parseDianpingReviewCount("21241条")).toBe(21241);
+    expect(parseDianpingReviewCount("")).toBeNull();
+    expect(parseDianpingPrice("人均￥109")).toBe(109);
+    expect(parseDianpingPrice("暂无")).toBeNull();
+  });
+
+  it("maps shop details to surface field rows", () => {
+    expect(
+      mapDianpingShopFields(
+        "abc_123",
+        {
+          name: " 芈重山老火锅 ",
+          rating: "4.8",
+          reviewsRaw: "1.2万条",
+          priceRaw: "人均￥109",
+          rank: "海淀区重庆火锅口味榜 · 第1名",
+          breakdown: { 口味: 4.8, 环境: "4.7", 服务: 4.6, 食材: 4.9 },
+          hours: "营业中 11:00-次日02:00",
+          address: "北京市海淀区",
+          subway: "距地铁五道口站步行300m",
+          features: ["可停车", "有包间"],
+          url: "https://www.dianping.com/shop/abc_123",
+        },
+        "https://www.dianping.com/shop/abc_123",
+      ),
+    ).toEqual([
+      { field: "shop_id", value: "abc_123" },
+      { field: "name", value: "芈重山老火锅" },
+      { field: "rating", value: 4.8 },
+      { field: "reviews", value: 12000 },
+      { field: "price", value: 109 },
+      { field: "rank", value: "海淀区重庆火锅口味榜 · 第1名" },
+      { field: "taste", value: 4.8 },
+      { field: "environment", value: 4.7 },
+      { field: "service", value: 4.6 },
+      { field: "ingredients", value: 4.9 },
+      { field: "hours", value: "营业中 11:00-次日02:00" },
+      { field: "address", value: "北京市海淀区" },
+      { field: "subway", value: "距地铁五道口站步行300m" },
+      { field: "features", value: "可停车, 有包间" },
+      { field: "url", value: "https://www.dianping.com/shop/abc_123" },
+    ]);
+  });
+
+  it("extracts Dianping shop details", async () => {
+    const command = resolveCommand("dianping", "shop")?.command;
+    const page = pageMock([
+      {
+        ok: true,
+        name: "芈重山老火锅",
+        rating: "4.8",
+        reviewsRaw: "21241条",
+        priceRaw: "￥109",
+        breakdown: { 口味: 4.8 },
+        url: "https://www.dianping.com/shop/abc_123",
+      },
+    ]);
+    await expect(command!.func!(page, { shop_id: "abc_123" })).resolves.toEqual(
+      expect.arrayContaining([
+        { field: "shop_id", value: "abc_123" },
+        { field: "name", value: "芈重山老火锅" },
+        { field: "rating", value: 4.8 },
+        { field: "reviews", value: 21241 },
+        { field: "price", value: 109 },
+        { field: "taste", value: 4.8 },
+      ]),
+    );
+    expect(page.goto).toHaveBeenCalledWith(
+      "https://www.dianping.com/shop/abc_123",
+      { waitUntil: "load", settleMs: 3000 },
+    );
+    expect(page.wait).toHaveBeenCalledWith(3);
+  });
+
+  it("fails before navigation on malformed shop ids", async () => {
+    const command = resolveCommand("dianping", "shop")?.command;
+    const page = pageMock([]);
+    await expect(command!.func!(page, { shop_id: "bad/id" })).rejects.toThrow(
+      "Dianping shop_id",
+    );
+    expect(page.goto).not.toHaveBeenCalled();
+  });
+
+  it("classifies Dianping auth, captcha, and empty pages", () => {
+    expect(() =>
+      classifyDianpingShopFailure(
+        "美团安全验证 请依次点击",
+        "https://verify.meituan.com",
+        "abc",
+      ),
+    ).toThrow("blocked by captcha");
+    expect(() =>
+      classifyDianpingShopFailure(
+        "请先登录",
+        "https://login.dianping.com",
+        "abc",
+      ),
+    ).toThrow("requires login");
+    expect(() =>
+      classifyDianpingShopFailure(
+        "商户不存在",
+        "https://www.dianping.com/shop/abc",
+        "abc",
+      ),
+    ).toThrow("not found");
+  });
+});

package/src/adapters/dianping/shop.ts

@@ -0,0 +1,261 @@
+/**
+ * @owner   src/adapters/dianping/shop.ts
+ * @does    Register agent-facing Dianping shop detail extraction implemented with site-specific safety checks.
+ * @needs   Dianping shop page DOM and a browser profile that can pass Dianping anti-bot checks.
+ * @feeds   surface coverage ledger and restaurant search-to-detail workflows.
+ * @breaks  Dianping shop-head DOM drift, login redirects, captcha gates, or deleted shops can hide detail fields.
+ */
+
+import { cli, Strategy } from "../../registry.js";
+import type { IPage } from "../../types.js";
+import { str } from "../_shared/browser-tools.js";
+
+const DIANPING_ORIGIN = "https://www.dianping.com";
+const SHOP_ID_RE = /^[A-Za-z0-9_-]+$/;
+const SHOP_FIELDS = [
+  "shop_id",
+  "name",
+  "rating",
+  "reviews",
+  "price",
+  "rank",
+  "taste",
+  "environment",
+  "service",
+  "ingredients",
+  "hours",
+  "address",
+  "subway",
+  "features",
+  "url",
+] as const;
+
+type DianpingShopField = (typeof SHOP_FIELDS)[number];
+
+interface DianpingShopBreakdown {
+  口味?: unknown;
+  环境?: unknown;
+  服务?: unknown;
+  食材?: unknown;
+}
+
+interface DianpingShopData {
+  name?: unknown;
+  rating?: unknown;
+  reviewsRaw?: unknown;
+  priceRaw?: unknown;
+  rank?: unknown;
+  breakdown?: DianpingShopBreakdown;
+  hours?: unknown;
+  address?: unknown;
+  subway?: unknown;
+  features?: unknown;
+  url?: unknown;
+}
+
+interface DianpingShopResult extends DianpingShopData {
+  ok?: unknown;
+  sample?: unknown;
+}
+
+export function normalizeDianpingShopId(value: unknown): string {
+  const raw = str(value).trim();
+  if (!raw) throw new Error("Dianping shop_id must be a non-empty string.");
+  const match = raw.match(/\/shop\/([^/?#]+)/);
+  const shopId = match?.[1] ?? raw;
+  if (!SHOP_ID_RE.test(shopId)) {
+    throw new Error(
+      `Dianping shop_id must be an alphanumeric shop ID or /shop/<id> URL.`,
+    );
+  }
+  return shopId;
+}
+
+export function parseDianpingReviewCount(value: unknown): number | null {
+  const text = str(value).trim();
+  if (!text) return null;
+  const wan = text.match(/^([\d.]+)\s*万/);
+  if (wan) {
+    const count = Number(wan[1]);
+    return Number.isFinite(count) ? Math.round(count * 10000) : null;
+  }
+  const plain = text.match(/(\d+(?:\.\d+)?)/);
+  if (!plain) return null;
+  const count = Number(plain[1]);
+  return Number.isFinite(count) ? Math.round(count) : null;
+}
+
+export function parseDianpingPrice(value: unknown): number | null {
+  const match = str(value).match(/[¥￥]\s*(\d+(?:\.\d+)?)/);
+  if (!match) return null;
+  const price = Number(match[1]);
+  return Number.isFinite(price) ? price : null;
+}
+
+function numberOrNull(value: unknown): number | null {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  const text = str(value).trim();
+  if (!text) return null;
+  const valueNumber = Number(text);
+  return Number.isFinite(valueNumber) ? valueNumber : null;
+}
+
+function featuresText(value: unknown): string {
+  if (Array.isArray(value))
+    return value
+      .map((item) => str(item).trim())
+      .filter(Boolean)
+      .join(", ");
+  return str(value).trim();
+}
+
+export function mapDianpingShopFields(
+  shopId: string,
+  data: DianpingShopData,
+  fallbackUrl: string,
+): Array<{ field: DianpingShopField; value: unknown }> {
+  const rating = numberOrNull(data.rating);
+  const breakdown = data.breakdown ?? {};
+  const values: Record<DianpingShopField, unknown> = {
+    shop_id: shopId,
+    name: str(data.name).trim(),
+    rating,
+    reviews: parseDianpingReviewCount(data.reviewsRaw),
+    price: parseDianpingPrice(data.priceRaw),
+    rank: str(data.rank).trim(),
+    taste: numberOrNull(breakdown["口味"]),
+    environment: numberOrNull(breakdown["环境"]),
+    service: numberOrNull(breakdown["服务"]),
+    ingredients: numberOrNull(breakdown["食材"]),
+    hours: str(data.hours).trim(),
+    address: str(data.address).trim(),
+    subway: str(data.subway).trim(),
+    features: featuresText(data.features),
+    url: str(data.url).trim() || fallbackUrl,
+  };
+  return SHOP_FIELDS.map((field) => ({ field, value: values[field] }));
+}
+
+export function classifyDianpingShopFailure(
+  sample: unknown,
+  url: string,
+  shopId: string,
+): never {
+  const signal = `${url} ${str(sample)}`;
+  if (
+    /verify\.meituan\.com|verifyimg|身份核实|请依次点击|美团安全验证|Yoda/i.test(
+      signal,
+    )
+  ) {
+    throw new Error(
+      `Dianping shop ${shopId} is blocked by captcha; solve the Dianping captcha in this browser profile and retry.`,
+    );
+  }
+  if (
+    /login\.dianping\.com|account\.dianping\.com|请先登录|未登录|请登录/.test(
+      signal,
+    )
+  ) {
+    throw new Error(
+      `Dianping shop ${shopId} requires login; sign in to dianping.com in this browser profile and retry.`,
+    );
+  }
+  if (
+    /商户不存在|店铺不存在|店铺已关闭|页面不存在|404|已下线|没有找到相关商户/i.test(
+      signal,
+    )
+  ) {
+    throw new Error(`Dianping shop ${shopId} was not found or is unavailable.`);
+  }
+  const preview = str(sample).slice(0, 160);
+  throw new Error(
+    `Dianping shop ${shopId} did not render expected shop data${preview ? `; sample: ${preview}` : ""}.`,
+  );
+}
+
+function buildDianpingShopEvaluate(): string {
+  return `(() => {
+    const clean = (value) => value == null ? '' : String(value).replace(/\\s+/g, ' ').trim();
+    const head = document.querySelector('.shop-head');
+    if (!head) {
+      const sample = clean(document.body?.innerText || document.body?.textContent || '').slice(0, 800);
+      return { ok: false, sample, url: location.href };
+    }
+    const headText = clean(head.textContent);
+    const titleEl = document.querySelector('.shop-name, .shop-head h2, .shop-head h1');
+    let name = clean(titleEl?.textContent);
+    if (!name) {
+      const match = String(document.title || '').match(/【([^】]+)】/);
+      if (match) name = clean(match[1]);
+    }
+    const rating = clean(document.querySelector('.star-score')?.textContent);
+    const reviewEl = document.querySelector('.reviews, .review-num, .reviewCount, .reviewCountSentence');
+    let reviewsRaw = clean(reviewEl?.textContent);
+    if (!reviewsRaw) {
+      const titleText = clean(document.querySelector('.review-title')?.textContent);
+      const titleMatch = titleText.match(/评价\\(([\\d.,万]+)\\)/);
+      if (titleMatch) reviewsRaw = titleMatch[1];
+    }
+    const priceMatch = headText.match(/[¥￥]\\s*\\d+(?:\\.\\d+)?/);
+    const breakdown = {};
+    for (const key of ['口味', '环境', '服务', '食材']) {
+      const match = headText.match(new RegExp(key + '[:：]\\\\s*([0-9.]+)'));
+      if (match) breakdown[key] = Number(match[1]);
+    }
+    const features = Array.from(document.querySelectorAll('.shop-feature')).map((node) => clean(node.textContent)).filter(Boolean);
+    const subwayMatch = headText.match(/距(?:地铁)?[^\\s]+?步行\\d+m/);
+    const hoursMatch = headText.match(/营业中[^\\s]*\\d{1,2}:\\d{2}-(?:次日)?\\d{1,2}:\\d{2}|今日休息|暂停营业/);
+    const rankMatch = headText.match(/[^\\s]+?(?:口味|人气|环境|服务)榜\\s*[·•]\\s*第\\d+名/);
+    return {
+      ok: true,
+      name,
+      rating,
+      reviewsRaw,
+      priceRaw: priceMatch?.[0] || '',
+      rank: rankMatch?.[0] || '',
+      breakdown,
+      hours: hoursMatch?.[0] || '',
+      address: clean(document.querySelector('.desc-info')?.textContent),
+      subway: subwayMatch?.[0] || '',
+      features,
+      url: location.href,
+    };
+  })()`;
+}
+
+cli({
+  site: "dianping",
+  name: "shop",
+  description: "Read Dianping shop details by shop ID or shop URL",
+  domain: "www.dianping.com",
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [
+    {
+      name: "shop_id",
+      type: "str",
+      required: true,
+      positional: true,
+      description: "Dianping shop ID or https://www.dianping.com/shop/<id> URL",
+    },
+  ],
+  columns: ["field", "value"],
+  func: async (page, kwargs) => {
+    const shopId = normalizeDianpingShopId(kwargs.shop_id);
+    const url = `${DIANPING_ORIGIN}/shop/${shopId}`;
+    const p = page as IPage;
+    await p.goto(url, { waitUntil: "load", settleMs: 3000 });
+    await p.wait(3);
+    const result = (await p.evaluate(
+      buildDianpingShopEvaluate(),
+    )) as DianpingShopResult;
+    if (!result?.ok) {
+      classifyDianpingShopFailure(
+        result?.sample,
+        str(result?.url) || url,
+        shopId,
+      );
+    }
+    return mapDianpingShopFields(shopId, result, url);
+  },
+});

package/src/adapters/dictionary/search.yaml

@@ -4,6 +4,7 @@ description: Look up word definitions, phonetics, and parts of speech
 domain: api.dictionaryapi.dev
 type: web-api
 strategy: public
+lint_listing_detail: skip
 
 args:
   word:

package/src/adapters/dockerhub/registry.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, it } from "vitest";
+import {
+  mapDockerHubImageRow,
+  mapDockerHubSearchRows,
+  parseDockerHubImage,
+  requireDockerHubLimit,
+  requireDockerHubString,
+} from "./registry.js";
+
+describe("dockerhub agent-facing registry commands", () => {
+  it("validates shared registry args", () => {
+    expect(requireDockerHubString(" nginx ", "query")).toBe("nginx");
+    expect(() => requireDockerHubString("", "query")).toThrow(
+      "query is required",
+    );
+    expect(requireDockerHubLimit(undefined, 25)).toBe(25);
+    expect(requireDockerHubLimit("4", 25)).toBe(4);
+    expect(() => requireDockerHubLimit("0", 25)).toThrow(
+      "limit must be an integer",
+    );
+    expect(() => requireDockerHubLimit("101", 25)).toThrow(
+      "limit must be an integer",
+    );
+  });
+
+  it("parses official and namespaced image names", () => {
+    expect(parseDockerHubImage("nginx")).toEqual({
+      owner: "library",
+      name: "nginx",
+    });
+    expect(parseDockerHubImage("bitnami/redis")).toEqual({
+      owner: "bitnami",
+      name: "redis",
+    });
+    expect(() => parseDockerHubImage("too/many/parts")).toThrow(
+      "image must be a Docker Hub image name",
+    );
+  });
+
+  it("maps Docker Hub search rows to agent-facing columns", () => {
+    expect(
+      mapDockerHubSearchRows(
+        [
+          {
+            repo_name: "nginx",
+            is_official: true,
+            star_count: 10,
+            pull_count: 100,
+            short_description: "web server",
+          },
+        ],
+        25,
+      ),
+    ).toEqual([
+      {
+        rank: 1,
+        image: "library/nginx",
+        official: true,
+        stars: 10,
+        pulls: 100,
+        description: "web server",
+        url: "https://hub.docker.com/r/library/nginx",
+      },
+    ]);
+  });
+
+  it("maps Docker Hub image detail rows", () => {
+    expect(
+      mapDockerHubImageRow(
+        {
+          namespace: "bitnami",
+          name: "redis",
+          star_count: 7,
+          pull_count: 70,
+          description: "Redis image",
+          last_updated: "2026-05-01T12:00:00.123Z",
+          last_modified: "2026-05-02T12:00:00Z",
+          date_registered: "2020-01-01T00:00:00Z",
+          status_description: "active",
+        },
+        "library",
+        "redis",
+      ),
+    ).toEqual({
+      image: "bitnami/redis",
+      official: false,
+      stars: 7,
+      pulls: 70,
+      description: "Redis image",
+      lastUpdated: "2026-05-01T12:00:00Z",
+      lastModified: "2026-05-02T12:00:00Z",
+      registered: "2020-01-01T00:00:00Z",
+      status: "active",
+      url: "https://hub.docker.com/r/bitnami/redis",
+    });
+  });
+});