@zenalexa/unicli 0.219.0 → 0.220.0

package/src/adapters/uisdc/news.ts

@@ -0,0 +1,111 @@
+/**
+ * @owner   src/adapters/uisdc/news.ts
+ * @does    Register agent-facing UISDC news browser extraction command.
+ * @needs   Public UISDC news page, browser runtime, selector-drift error reporting.
+ * @feeds   surface coverage ledger, design/AI news discovery, Chinese design news surface.
+ * @breaks  UISDC DOM drift or silent empty extraction hides news coverage failures.
+ */
+
+import { cli, Strategy } from "../../registry.js";
+import type { IPage } from "../../types.js";
+
+const UISDC_NEWS_URL = "https://www.uisdc.com/news";
+
+function normalizeText(value: unknown): string {
+  return String(value ?? "")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+export function requireNewsLimit(value: unknown, fallback = 20): number {
+  if (value === undefined || value === null || value === "") return fallback;
+  const n = Number(value);
+  if (!Number.isInteger(n) || n < 1 || n > 50) {
+    throw new Error("limit must be an integer in [1, 50].");
+  }
+  return n;
+}
+
+export function buildExtractUisdcNewsJs(): string {
+  return `
+    (() => {
+      const cards = Array.from(document.querySelectorAll(
+        '.news-list > .news-item:first-child > .item-content > .dubao-items > .dubao-item'
+      ));
+      if (cards.length === 0) {
+        return {
+          ok: false,
+          reason: 'selector-missing',
+          title: document.title || '',
+          bodyText: (document.body?.innerText || document.body?.textContent || '').slice(0, 500),
+        };
+      }
+      const rows = cards.map((el) => {
+        const anchor = el.querySelector('a[href]');
+        return {
+          title: el.querySelector('.dubao-title')?.textContent || '',
+          summary: el.querySelector('.dubao-content')?.textContent || '',
+          url: anchor ? new URL(anchor.getAttribute('href'), location.href).href : '',
+        };
+      });
+      return { ok: true, rows };
+    })()
+  `;
+}
+
+interface BrowserExtractPayload {
+  ok?: unknown;
+  reason?: unknown;
+  title?: unknown;
+  rows?: Array<{ title?: unknown; summary?: unknown; url?: unknown }>;
+}
+
+export function mapUisdcNewsPayload(
+  payload: BrowserExtractPayload,
+  limit: number,
+): Array<Record<string, unknown>> {
+  if (!payload || typeof payload !== "object") {
+    throw new Error("UISDC news page returned an unreadable payload.");
+  }
+  if (payload.ok !== true) {
+    const reason = normalizeText(payload.reason) || "selector-drift";
+    const title = normalizeText(payload.title);
+    throw new Error(
+      `UISDC news selector drift: ${reason}${title ? ` (${title})` : ""}`,
+    );
+  }
+  const rows = (Array.isArray(payload.rows) ? payload.rows : [])
+    .map((row, index) => ({
+      rank: index + 1,
+      title: normalizeText(row.title),
+      summary: normalizeText(row.summary),
+      url: normalizeText(row.url),
+    }))
+    .filter((row) => row.title && row.url);
+  if (rows.length === 0) {
+    throw new Error("UISDC news page loaded, but no news rows were extracted.");
+  }
+  return rows
+    .slice(0, limit)
+    .map((row, index) => ({ ...row, rank: index + 1 }));
+}
+
+cli({
+  site: "uisdc",
+  name: "news",
+  description: "UISDC latest AI and design news",
+  domain: "www.uisdc.com",
+  strategy: Strategy.PUBLIC,
+  browser: true,
+  args: [{ name: "limit", type: "int", default: 20, description: "Max rows" }],
+  columns: ["rank", "title", "summary", "url"],
+  func: async (page, kwargs) => {
+    const p = page as IPage;
+    const limit = requireNewsLimit(kwargs.limit);
+    await p.goto(UISDC_NEWS_URL, { waitUntil: "load", settleMs: 3000 });
+    const payload = (await p.evaluate(
+      buildExtractUisdcNewsJs(),
+    )) as BrowserExtractPayload;
+    return mapUisdcNewsPayload(payload, limit);
+  },
+});

package/src/adapters/weibo/favorites-publish.test.ts

@@ -0,0 +1,177 @@
+import * as fs from "node:fs";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it, vi } from "vitest";
+import { resolveCommand } from "../../registry.js";
+import {
+  dedupeWeiboFavorites,
+  parseWeiboFavoriteCard,
+  requireWeiboFavoritesLimit,
+  validateWeiboImagePaths,
+  validateWeiboPublishText,
+} from "./favorites-publish.js";
+
+function pageMock(evaluateResults: unknown[]) {
+  const queue = [...evaluateResults];
+  return {
+    goto: vi.fn().mockResolvedValue(undefined),
+    wait: vi.fn().mockResolvedValue(undefined),
+    evaluate: vi.fn(async (script: string) => {
+      if (String(script).includes("window.scrollBy")) return undefined;
+      return queue.shift();
+    }),
+    setFileInput: vi.fn().mockResolvedValue(undefined),
+  };
+}
+
+describe("weibo agent-facing favorites and publish commands", () => {
+  it("validates favorites limits and parses favorites", () => {
+    expect(requireWeiboFavoritesLimit(undefined)).toBe(20);
+    expect(() => requireWeiboFavoritesLimit(0)).toThrow("positive integer");
+    expect(() => requireWeiboFavoritesLimit(51)).toThrow("<= 50");
+    const row = parseWeiboFavoriteCard(
+      {
+        text: [
+          "作者A",
+          "昨天 12:00",
+          "来自 iPhone",
+          "这是一条收藏微博",
+          "12",
+          "3",
+          "2",
+        ].join("\n"),
+        url: "https://weibo.com/123/AbCd1",
+      },
+      "https://www.weibo.com/u/page/fav/123456",
+    );
+    expect(row).toMatchObject({
+      author: "作者A",
+      text: "这是一条收藏微博",
+      time: "昨天 12:00",
+      source: "来自 iPhone",
+      likes: "12",
+      comments: "3",
+      reposts: "2",
+      url: "https://weibo.com/123/AbCd1",
+    });
+    expect(
+      dedupeWeiboFavorites(
+        [row!, row!],
+        "https://www.weibo.com/u/page/fav/123456",
+      ),
+    ).toHaveLength(1);
+  });
+
+  it("reads Weibo favorites from the browser page", async () => {
+    const command = resolveCommand("weibo", "favorites")?.command;
+    const page = pageMock([
+      "123456",
+      [
+        {
+          text: ["作者A", "昨天 12:00", "来自 iPhone", "收藏微博内容"].join(
+            "\n",
+          ),
+          url: "https://weibo.com/123/AbCd1",
+        },
+      ],
+    ]);
+    await expect(command!.func!(page, { limit: 10 })).resolves.toEqual([
+      expect.objectContaining({
+        author: "作者A",
+        text: "收藏微博内容",
+        url: "https://weibo.com/123/AbCd1",
+      }),
+    ]);
+    expect(page.goto).toHaveBeenCalledWith("https://weibo.com");
+    expect(page.goto).toHaveBeenCalledWith(
+      "https://www.weibo.com/u/page/fav/123456",
+    );
+  });
+
+  it("validates publish text and image paths before navigation", async () => {
+    expect(validateWeiboPublishText(" hello ")).toBe("hello");
+    expect(() => validateWeiboPublishText("")).toThrow("cannot be empty");
+    const dir = mkdtempSync(join(tmpdir(), "unicli-weibo-"));
+    try {
+      const png = join(dir, "a.png");
+      writeFileSync(png, "png");
+      expect(validateWeiboImagePaths(png)).toEqual([png]);
+      expect(() => validateWeiboImagePaths(join(dir, "a.bmp"))).toThrow(
+        "Unsupported image format",
+      );
+      expect(() => validateWeiboImagePaths(join(dir, "missing.png"))).toThrow(
+        "Not a valid file",
+      );
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+    const command = resolveCommand("weibo", "publish")?.command;
+    const page = pageMock([]);
+    await expect(command!.func!(page, { text: "" })).rejects.toThrow(
+      "cannot be empty",
+    );
+    expect(page.goto).not.toHaveBeenCalled();
+  });
+
+  it("publishes text-only Weibo posts when UI reports success", async () => {
+    const command = resolveCommand("weibo", "publish")?.command;
+    const page = pageMock([
+      "123456",
+      { ok: true },
+      { found: true, visible: true, rectTop: 100 },
+      { ok: true, valueLength: 5 },
+      { ok: true, label: "发送" },
+      { ok: true, message: "发送成功" },
+    ]);
+    await expect(command!.func!(page, { text: "hello" })).resolves.toEqual([
+      { status: "success", message: "发送成功", text: "hello" },
+    ]);
+    expect(page.goto).toHaveBeenCalledWith("https://weibo.com", {
+      waitUntil: "load",
+      settleMs: 2000,
+    });
+  });
+
+  it("uploads images before publishing", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "unicli-weibo-"));
+    const image = join(dir, "a.png");
+    writeFileSync(image, "png");
+    try {
+      const command = resolveCommand("weibo", "publish")?.command;
+      const page = pageMock([
+        "123456",
+        { ok: true },
+        { found: true, visible: true, rectTop: 100 },
+        true,
+        { ok: true, count: 1 },
+        { ok: true, valueLength: 5 },
+        { ok: true, label: "发送" },
+        { ok: true, message: "发送成功" },
+      ]);
+      await command!.func!(page, { text: "hello", images: image });
+      expect(page.setFileInput).toHaveBeenCalledWith(
+        'input[type="file"][class*="_file_"]',
+        [image],
+      );
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("keeps publish failures explicit", async () => {
+    const command = resolveCommand("weibo", "publish")?.command;
+    const page = pageMock([
+      "123456",
+      { ok: true },
+      { found: true, visible: true, rectTop: 100 },
+      { ok: true, valueLength: 5 },
+      { ok: true, label: "发送" },
+      { ok: false, message: "内容违规" },
+    ]);
+    await expect(command!.func!(page, { text: "hello" })).rejects.toThrow(
+      "内容违规",
+    );
+    expect(fs.existsSync("/path/that/should/not/exist")).toBe(false);
+  });
+});