@zenalexa/unicli 0.215.1 → 0.216.2

package/src/adapters/google-scholar/cite.ts

@@ -0,0 +1,95 @@
+import { cli, Strategy } from "../../registry.js";
+import type { IPage } from "../../types.js";
+import { intArg, js, str, visibleText } from "../_shared/browser-tools.js";
+
+const STYLE_LABELS: Record<string, string> = {
+  bibtex: "BibTeX",
+  endnote: "EndNote",
+  refman: "RefMan",
+  refworks: "RefWorks",
+};
+
+cli({
+  site: "google-scholar",
+  name: "cite",
+  description: "Fetch a Google Scholar citation for a paper",
+  domain: "scholar.google.com",
+  strategy: Strategy.PUBLIC,
+  browser: true,
+  args: [
+    { name: "query", type: "str", required: true, positional: true },
+    {
+      name: "style",
+      type: "str",
+      default: "bibtex",
+      choices: Object.keys(STYLE_LABELS),
+    },
+    { name: "index", type: "int", default: 1 },
+  ],
+  columns: ["title", "format", "citation"],
+  func: async (page, kwargs) => {
+    const p = page as IPage;
+    const query = str(kwargs.query).trim();
+    const style = str(kwargs.style, "bibtex").toLowerCase();
+    const label = STYLE_LABELS[style] ?? STYLE_LABELS.bibtex;
+    const index = intArg(kwargs.index, 1, 20);
+
+    await p.goto(
+      `https://scholar.google.com/scholar?q=${encodeURIComponent(query)}&hl=en`,
+      { settleMs: 2500 },
+    );
+
+    const clickResult = (await p.evaluate(`(() => {
+      const normalize = (value) => (value || '').replace(/\\s+/g, ' ').trim();
+      const cards = [...document.querySelectorAll('.gs_r.gs_or.gs_scl, .gs_r.gs_or')];
+      const card = cards[${js(index - 1)}];
+      if (!card) return { ok: false, reason: 'result_not_found' };
+      const title = normalize(card.querySelector('.gs_rt, h3')?.textContent);
+      const button = card.querySelector('a.gs_or_cit, .gs_or_cit');
+      if (!(button instanceof HTMLElement)) {
+        return { ok: false, title, reason: 'cite_button_not_found' };
+      }
+      button.click();
+      return { ok: true, title };
+    })()`)) as { ok?: boolean; title?: string; reason?: string };
+
+    if (!clickResult.ok) {
+      return [
+        {
+          title: clickResult.title ?? query,
+          format: style,
+          citation: clickResult.reason ?? "citation_unavailable",
+        },
+      ];
+    }
+
+    await p.waitForSelector("#gs_cit", 5000).catch(() => undefined);
+    const citationUrl = str(
+      await p.evaluate(`(() => {
+        const wanted = ${js(label)};
+        const links = [...document.querySelectorAll('#gs_citi a, #gs_cit a')];
+        const link = links.find((a) => (a.textContent || '').trim().toLowerCase() === wanted.toLowerCase());
+        return link ? new URL(link.getAttribute('href') || '', location.href).href : '';
+      })()`),
+    );
+
+    if (!citationUrl) {
+      return [
+        {
+          title: clickResult.title ?? query,
+          format: style,
+          citation: "citation_link_not_found",
+        },
+      ];
+    }
+
+    await p.goto(citationUrl, { settleMs: 1200 });
+    return [
+      {
+        title: clickResult.title ?? query,
+        format: style,
+        citation: await visibleText(p),
+      },
+    ];
+  },
+});

package/src/adapters/google-scholar/profile.ts

@@ -0,0 +1,91 @@
+import { cli, Strategy } from "../../registry.js";
+import type { IPage } from "../../types.js";
+import { intArg, js, str } from "../_shared/browser-tools.js";
+
+function isScholarUserId(value: string): boolean {
+  return /^[A-Za-z0-9_-]{8,20}$/.test(value) && !/\s/.test(value);
+}
+
+cli({
+  site: "google-scholar",
+  name: "profile",
+  description: "Read a Google Scholar author profile and top papers",
+  domain: "scholar.google.com",
+  strategy: Strategy.PUBLIC,
+  browser: true,
+  args: [
+    { name: "author", type: "str", required: true, positional: true },
+    { name: "limit", type: "int", default: 10 },
+  ],
+  columns: ["rank", "kind", "title", "authors", "year", "cited", "url"],
+  func: async (page, kwargs) => {
+    const p = page as IPage;
+    const author = str(kwargs.author).trim();
+    const limit = intArg(kwargs.limit, 10, 100);
+
+    if (isScholarUserId(author)) {
+      await p.goto(
+        `https://scholar.google.com/citations?user=${encodeURIComponent(author)}&hl=en`,
+        { settleMs: 2500 },
+      );
+    } else {
+      await p.goto(
+        `https://scholar.google.com/citations?view_op=search_authors&mauthors=${encodeURIComponent(author)}&hl=en`,
+        { settleMs: 2500 },
+      );
+      const profileUrl = str(
+        await p.evaluate(`(() => {
+          const link = document.querySelector('.gsc_1usr_name a, a[href*="citations?user="]');
+          return link ? new URL(link.getAttribute('href') || '', location.href).href : '';
+        })()`),
+      );
+      if (!profileUrl) {
+        return [
+          {
+            rank: 0,
+            kind: "profile",
+            title: author,
+            cited: "profile_not_found",
+            url: "",
+          },
+        ];
+      }
+      await p.goto(profileUrl, { settleMs: 2500 });
+    }
+
+    const rows = await p.evaluate(`(() => {
+      const normalize = (value) => (value || '').replace(/\\s+/g, ' ').trim();
+      const metric = (label) => {
+        const rows = [...document.querySelectorAll('#gsc_rsb_st tr')];
+        const row = rows.find((item) => normalize(item.children?.[0]?.textContent).toLowerCase() === label.toLowerCase());
+        return normalize(row?.children?.[1]?.textContent);
+      };
+      const name = normalize(document.querySelector('#gsc_prf_in')?.textContent);
+      const affiliation = normalize(document.querySelector('.gsc_prf_il')?.textContent);
+      const output = [{
+        rank: 0,
+        kind: 'profile',
+        title: affiliation ? name + ' (' + affiliation + ')' : name,
+        authors: '',
+        year: '',
+        cited: 'h=' + metric('h-index') + ' i10=' + metric('i10-index') + ' total=' + metric('Citations'),
+        url: location.href,
+      }];
+      const papers = [...document.querySelectorAll('#gsc_a_b .gsc_a_tr')];
+      for (const paper of papers.slice(0, ${js(limit)})) {
+        const titleLink = paper.querySelector('.gsc_a_at');
+        output.push({
+          rank: output.length,
+          kind: 'paper',
+          title: normalize(titleLink?.textContent),
+          authors: normalize(paper.querySelector('.gs_gray')?.textContent),
+          year: normalize(paper.querySelector('.gsc_a_y')?.textContent),
+          cited: normalize(paper.querySelector('.gsc_a_c')?.textContent) || '0',
+          url: titleLink ? new URL(titleLink.getAttribute('href') || '', location.href).href : '',
+        });
+      }
+      return output;
+    })()`);
+    return Array.isArray(rows) ? (rows as Record<string, unknown>[]) : [];
+  },
+});

package/src/adapters/google-scholar/search.ts

@@ -0,0 +1,58 @@
+import { cli, Strategy } from "../../registry.js";
+import type { IPage } from "../../types.js";
+import { intArg, js, str } from "../_shared/browser-tools.js";
+
+cli({
+  site: "google-scholar",
+  name: "search",
+  description: "Search Google Scholar papers",
+  domain: "scholar.google.com",
+  strategy: Strategy.PUBLIC,
+  browser: true,
+  args: [
+    { name: "query", type: "str", required: true, positional: true },
+    { name: "limit", type: "int", default: 10 },
+  ],
+  columns: ["rank", "title", "authors", "source", "year", "cited", "url"],
+  func: async (page, kwargs) => {
+    const p = page as IPage;
+    const limit = intArg(kwargs.limit, 10, 20);
+    await p.goto(
+      `https://scholar.google.com/scholar?q=${encodeURIComponent(str(kwargs.query))}&hl=en`,
+      { settleMs: 2500 },
+    );
+    const rows = await p.evaluate(`(() => {
+      const normalize = (value) => (value || '').replace(/\\s+/g, ' ').trim();
+      const rows = [];
+      const seen = new Set();
+      const cards = [...document.querySelectorAll('.gs_r.gs_or.gs_scl, .gs_r.gs_or')];
+      for (const card of cards) {
+        const body = card.querySelector('.gs_ri') || card;
+        const link = body.querySelector('.gs_rt a, h3 a');
+        const title = normalize(body.querySelector('.gs_rt, h3')?.textContent);
+        if (!title) continue;
+        const url = link ? new URL(link.getAttribute('href') || '', location.href).href : '';
+        const dedupeKey = url || title.toLowerCase();
+        if (seen.has(dedupeKey)) continue;
+        seen.add(dedupeKey);
+
+        const infoLine = normalize(body.querySelector('.gs_a')?.textContent);
+        const parts = infoLine.split(' - ');
+        const sourceParts = (parts[1] || '').split(',');
+        const citedText = normalize(body.querySelector('.gs_fl a[href*="cites"]')?.textContent);
+        rows.push({
+          rank: rows.length + 1,
+          title,
+          authors: (parts[0] || '').trim(),
+          source: sourceParts.slice(0, -1).join(',').trim() || sourceParts[0]?.trim() || '',
+          year: infoLine.match(/(19|20)\\d{2}/)?.[0] || '',
+          cited: citedText.match(/(\\d+)/)?.[1] || '0',
+          url,
+        });
+        if (rows.length >= ${js(limit)}) break;
+      }
+      return rows;
+    })()`);
+    return Array.isArray(rows) ? (rows as Record<string, unknown>[]) : [];
+  },
+});

package/src/adapters/gov-law/laws.ts

@@ -0,0 +1,61 @@
+import { cli, Strategy } from "../../registry.js";
+import type { IPage } from "../../types.js";
+import { intArg, js, str } from "../_shared/browser-tools.js";
+
+function lawRowsScript(limit: number): string {
+  return `(() => {
+    const cards = [...document.querySelectorAll('a[href], .el-card, .list-item, li')];
+    const seen = new Set();
+    return cards.map((card) => {
+      const link = card.matches?.('a[href]') ? card : card.querySelector?.('a[href]');
+      const text = (card.textContent || '').replace(/\\s+/g, ' ').trim();
+      const title = (link?.textContent || text).replace(/\\s+/g, ' ').trim();
+      const href = link?.getAttribute('href') || '';
+      const url = href ? new URL(href, location.href).href : '';
+      if (!title || (url && seen.has(url))) return null;
+      if (url) seen.add(url);
+      const date = (text.match(/\\d{4}[-年.]\\d{1,2}[-月.]\\d{1,2}/) || [''])[0];
+      return { title, date, url, snippet: text.slice(0, 240) };
+    }).filter((row) => row && row.title.length > 4).slice(0, ${js(limit)});
+  })()`;
+}
+
+cli({
+  site: "gov-law",
+  name: "search",
+  description: "Search the National Laws and Regulations Database",
+  domain: "flk.npc.gov.cn",
+  strategy: Strategy.PUBLIC,
+  browser: true,
+  args: [
+    { name: "query", type: "str", required: true, positional: true },
+    { name: "limit", type: "int", default: 20 },
+  ],
+  columns: ["title", "date", "url"],
+  func: async (page, kwargs) => {
+    const p = page as IPage;
+    const limit = intArg(kwargs.limit, 20, 100);
+    const url = `https://flk.npc.gov.cn/search.html?keyword=${encodeURIComponent(str(kwargs.query))}`;
+    await p.goto(url, { settleMs: 2500 });
+    const rows = await p.evaluate(lawRowsScript(limit));
+    return Array.isArray(rows) ? (rows as Record<string, unknown>[]) : [];
+  },
+});
+
+cli({
+  site: "gov-law",
+  name: "recent",
+  description: "List recent laws and regulations",
+  domain: "flk.npc.gov.cn",
+  strategy: Strategy.PUBLIC,
+  browser: true,
+  args: [{ name: "limit", type: "int", default: 20 }],
+  columns: ["title", "date", "url"],
+  func: async (page, kwargs) => {
+    const p = page as IPage;
+    const limit = intArg(kwargs.limit, 20, 100);
+    await p.goto("https://flk.npc.gov.cn/", { settleMs: 2500 });
+    const rows = await p.evaluate(lawRowsScript(limit));
+    return Array.isArray(rows) ? (rows as Record<string, unknown>[]) : [];
+  },
+});

package/src/adapters/gov-policy/policy.ts

@@ -0,0 +1,61 @@
+import { cli, Strategy } from "../../registry.js";
+import type { IPage } from "../../types.js";
+import { intArg, js, str } from "../_shared/browser-tools.js";
+
+function policyRowsScript(limit: number): string {
+  return `(() => {
+    const links = [...document.querySelectorAll('a[href]')];
+    const seen = new Set();
+    return links.map((a) => {
+      const title = (a.textContent || '').replace(/\\s+/g, ' ').trim();
+      const href = a.getAttribute('href') || '';
+      const url = href ? new URL(href, location.href).href : '';
+      if (!title || title.length < 4 || seen.has(url)) return null;
+      seen.add(url);
+      const parent = a.closest('li, .item, .list, div') || a;
+      const text = (parent.textContent || '').replace(/\\s+/g, ' ').trim();
+      const date = (text.match(/\\d{4}[-年.]\\d{1,2}[-月.]\\d{1,2}/) || [''])[0];
+      return { title, date, url, snippet: text.slice(0, 240) };
+    }).filter(Boolean).slice(0, ${js(limit)});
+  })()`;
+}
+
+cli({
+  site: "gov-policy",
+  name: "search",
+  description: "Search gov.cn policy documents",
+  domain: "www.gov.cn",
+  strategy: Strategy.PUBLIC,
+  browser: true,
+  args: [
+    { name: "query", type: "str", required: true, positional: true },
+    { name: "limit", type: "int", default: 20 },
+  ],
+  columns: ["title", "date", "url"],
+  func: async (page, kwargs) => {
+    const p = page as IPage;
+    const limit = intArg(kwargs.limit, 20, 100);
+    const url = `https://sousuo.www.gov.cn/zcwjk/policyDocumentLibrary?q=${encodeURIComponent(str(kwargs.query))}&t=zhengcelibrary`;
+    await p.goto(url, { settleMs: 2500 });
+    const rows = await p.evaluate(policyRowsScript(limit));
+    return Array.isArray(rows) ? (rows as Record<string, unknown>[]) : [];
+  },
+});
+
+cli({
+  site: "gov-policy",
+  name: "recent",
+  description: "List latest State Council policy documents",
+  domain: "www.gov.cn",
+  strategy: Strategy.PUBLIC,
+  browser: true,
+  args: [{ name: "limit", type: "int", default: 20 }],
+  columns: ["title", "date", "url"],
+  func: async (page, kwargs) => {
+    const p = page as IPage;
+    const limit = intArg(kwargs.limit, 20, 100);
+    await p.goto("https://www.gov.cn/zhengce/zuixin/", { settleMs: 2500 });
+    const rows = await p.evaluate(policyRowsScript(limit));
+    return Array.isArray(rows) ? (rows as Record<string, unknown>[]) : [];
+  },
+});

package/src/adapters/imessage/contact.yaml

@@ -53,7 +53,7 @@ pipeline:
           # Force integer on limit
           lim=${UNICLI_LIMIT//[^0-9]/}
           : "${lim:=50}"
-          sqlite3 -json "$db" \
+          out=$(sqlite3 -json "$db" \
             "SELECT datetime(m.date/1000000000 + 978307200, 'unixepoch', 'localtime') AS ts, \
                     m.text, \
                     m.is_from_me, \
@@ -63,7 +63,12 @@ pipeline:
              WHERE h.id = '$h' AND m.text IS NOT NULL \
              ORDER BY m.date DESC \
              LIMIT $lim;" \
-            2>/dev/null || echo "[]"
+            2>/dev/null) || { echo "[]"; exit 0; }
+          if [ -z "$out" ]; then
+            echo "[]"
+          else
+            printf '%s\n' "$out"
+          fi
       env:
         UNICLI_HANDLE: "${{ args.name }}"
         UNICLI_LIMIT: "${{ args.limit }}"

package/src/adapters/imessage/recent.yaml

@@ -48,7 +48,7 @@ pipeline:
           # Force integer on limit (strip non-digits, default 50)
           lim=${UNICLI_LIMIT//[^0-9]/}
           : "${lim:=50}"
-          sqlite3 -json "$db" \
+          out=$(sqlite3 -json "$db" \
             "SELECT datetime(date/1000000000 + 978307200, 'unixepoch', 'localtime') AS ts, \
                     text, \
                     is_from_me, \
@@ -57,7 +57,12 @@ pipeline:
              WHERE text IS NOT NULL \
              ORDER BY date DESC \
              LIMIT $lim;" \
-            2>/dev/null || echo "[]"
+            2>/dev/null) || { echo "[]"; exit 0; }
+          if [ -z "$out" ]; then
+            echo "[]"
+          else
+            printf '%s\n' "$out"
+          fi
       env:
         UNICLI_LIMIT: "${{ args.limit }}"
       parse: json

package/src/adapters/imessage/search.yaml

@@ -55,7 +55,7 @@ pipeline:
           # Force integer on limit
           lim=${UNICLI_LIMIT//[^0-9]/}
           : "${lim:=50}"
-          sqlite3 -json "$db" \
+          out=$(sqlite3 -json "$db" \
             "SELECT datetime(m.date/1000000000 + 978307200, 'unixepoch', 'localtime') AS ts, \
                     m.text, \
                     m.is_from_me, \
@@ -65,7 +65,12 @@ pipeline:
              WHERE m.text LIKE '%$q%' \
              ORDER BY m.date DESC \
              LIMIT $lim;" \
-            2>/dev/null || echo "[]"
+            2>/dev/null) || { echo "[]"; exit 0; }
+          if [ -z "$out" ]; then
+            echo "[]"
+          else
+            printf '%s\n' "$out"
+          fi
       env:
         UNICLI_QUERY: "${{ args.text }}"
         UNICLI_LIMIT: "${{ args.limit }}"

package/src/adapters/jd/commerce.ts

@@ -0,0 +1,142 @@
+import { cli, Strategy } from "../../registry.js";
+import type { IPage } from "../../types.js";
+import { clickFirst, intArg, js, str } from "../_shared/browser-tools.js";
+
+async function jdDetail(sku: string): Promise<Record<string, unknown>> {
+  const body = JSON.stringify({ skuId: sku });
+  const url = new URL("https://api.m.jd.com/api");
+  url.searchParams.set("appid", "item-v3");
+  url.searchParams.set("functionId", "pc_detailpage_wareBusiness");
+  url.searchParams.set("body", body);
+  const response = await fetch(url);
+  const data = (await response.json()) as Record<string, unknown>;
+  const ware = (data.wareInfo ?? {}) as Record<string, unknown>;
+  const price = (data.priceInfo ?? {}) as Record<string, unknown>;
+  const shop = (data.shopInfo ?? {}) as Record<string, unknown>;
+  const stock = (data.stockInfo ?? {}) as Record<string, unknown>;
+  return {
+    sku,
+    title: str(ware.wname),
+    brand: str(ware.brand),
+    price: str(price.price),
+    shop: str(shop.shop),
+    stock: str(stock.stockDesc),
+    url: `https://item.jd.com/${sku}.html`,
+  };
+}
+
+cli({
+  site: "jd",
+  name: "detail",
+  description: "Fetch JD product detail by SKU",
+  domain: "jd.com",
+  strategy: Strategy.PUBLIC,
+  args: [{ name: "sku", type: "str", required: true, positional: true }],
+  columns: ["title", "price", "shop", "stock", "sku"],
+  func: async (_page, kwargs) => [await jdDetail(str(kwargs.sku))],
+});
+
+cli({
+  site: "jd",
+  name: "reviews",
+  description: "Fetch JD product reviews by SKU",
+  domain: "jd.com",
+  strategy: Strategy.PUBLIC,
+  args: [
+    { name: "sku", type: "str", required: true, positional: true },
+    { name: "limit", type: "int", default: 10 },
+  ],
+  columns: ["nickname", "score", "content", "creationTime"],
+  func: async (_page, kwargs) => {
+    const sku = str(kwargs.sku);
+    const limit = intArg(kwargs.limit, 10, 50);
+    const url = new URL(
+      "https://club.jd.com/comment/productPageComments.action",
+    );
+    url.searchParams.set("productId", sku);
+    url.searchParams.set("score", "0");
+    url.searchParams.set("sortType", "5");
+    url.searchParams.set("page", "0");
+    url.searchParams.set("pageSize", String(limit));
+    const response = await fetch(url, {
+      headers: { "user-agent": "Mozilla/5.0 (compatible; Uni-CLI)" },
+    });
+    const data = (await response.json()) as {
+      comments?: Record<string, unknown>[];
+    };
+    return (data.comments ?? []).slice(0, limit).map((item) => ({
+      nickname: str(item.nickname),
+      score: item.score ?? "",
+      content: str(item.content).slice(0, 300),
+      creationTime: str(item.creationTime),
+    }));
+  },
+});
+
+cli({
+  site: "jd",
+  name: "cart",
+  description: "Read JD cart items from the active browser session",
+  domain: "jd.com",
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [{ name: "limit", type: "int", default: 30 }],
+  columns: ["title", "price", "quantity", "url"],
+  func: async (page, kwargs) => {
+    const p = page as IPage;
+    await p.goto("https://cart.jd.com/cart_index", { settleMs: 3000 });
+    const limit = intArg(kwargs.limit, 30, 100);
+    const rows = (await p.evaluate(`(() => {
+      const cards = [...document.querySelectorAll('.item-list .item-item, .cart-item-list .item-form')];
+      return cards.map((card) => {
+        const link = card.querySelector('.p-name a, a[href*="item.jd.com"]');
+        return {
+          title: (link?.textContent || '').replace(/\\s+/g, ' ').trim(),
+          price: (card.querySelector('.p-price, .price')?.textContent || '').replace(/\\s+/g, ' ').trim(),
+          quantity: (card.querySelector('input.itxt, input[type="text"]')?.value || '').trim(),
+          url: link ? new URL(link.getAttribute('href') || '', location.href).href : ''
+        };
+      }).filter((row) => row.title).slice(0, ${js(limit)});
+    })()`)) as Record<string, unknown>[];
+    return rows;
+  },
+});
+
+cli({
+  site: "jd",
+  name: "add-cart",
+  description: "Add a JD product to cart in the active browser session",
+  domain: "jd.com",
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [
+    { name: "sku", type: "str", required: true, positional: true },
+    { name: "quantity", type: "int", default: 1 },
+  ],
+  columns: ["ok", "selector", "url"],
+  func: async (page, kwargs) => {
+    const p = page as IPage;
+    const sku = str(kwargs.sku);
+    await p.goto(`https://item.jd.com/${encodeURIComponent(sku)}.html`, {
+      settleMs: 3000,
+    });
+    const quantity = intArg(kwargs.quantity, 1, 99);
+    if (quantity > 1) {
+      await p.evaluate(`(() => {
+        const input = document.querySelector('#buy-num, input.quantity, input[type="text"]');
+        if (input) {
+          input.value = ${js(String(quantity))};
+          input.dispatchEvent(new Event('input', { bubbles: true }));
+          input.dispatchEvent(new Event('change', { bubbles: true }));
+        }
+      })()`);
+    }
+    const selector = await clickFirst(p, [
+      "#InitCartUrl",
+      "#btn-add-cart",
+      ".btn-append",
+      "a[href*='cart']",
+    ]);
+    return [{ ok: selector !== null, selector, url: await p.url() }];
+  },
+});

package/src/adapters/jianyu/detail.ts

@@ -0,0 +1,28 @@
+import { cli, Strategy } from "../../registry.js";
+import type { IPage } from "../../types.js";
+import { str, visibleText } from "../_shared/browser-tools.js";
+
+cli({
+  site: "jianyu",
+  name: "detail",
+  description: "Extract Jianyu procurement notice detail evidence",
+  domain: "www.jianyu360.cn",
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [{ name: "url", type: "str", required: true, positional: true }],
+  columns: ["title", "published_at", "detail_text", "url"],
+  func: async (page, kwargs) => {
+    const p = page as IPage;
+    await p.goto(str(kwargs.url), { settleMs: 2500 });
+    const text = await visibleText(p);
+    const date = (text.match(/\d{4}[-年.]\d{1,2}[-月.]\d{1,2}/) ?? [""])[0];
+    return [
+      {
+        title: await p.title(),
+        published_at: date,
+        detail_text: text.slice(0, 8000),
+        url: await p.url(),
+      },
+    ];
+  },
+});

package/src/adapters/jimeng/workspace.ts

@@ -0,0 +1,53 @@
+import { cli, Strategy } from "../../registry.js";
+import type { IPage } from "../../types.js";
+import { clickFirst, intArg, js } from "../_shared/browser-tools.js";
+
+const JIMENG =
+  "https://jimeng.jianying.com/ai-tool/generate?type=image&workspace=0";
+
+cli({
+  site: "jimeng",
+  name: "new",
+  description: "Open a new Jimeng generation workspace",
+  domain: "jimeng.jianying.com",
+  strategy: Strategy.COOKIE,
+  browser: true,
+  columns: ["ok", "url"],
+  func: async (page) => {
+    const p = page as IPage;
+    await p.goto(JIMENG, { settleMs: 2500 });
+    const selector = await clickFirst(p, [
+      "button[aria-label*='新建']",
+      "button[title*='新建']",
+      ".lv-btn-primary",
+    ]);
+    return [{ ok: true, selector, url: await p.url() }];
+  },
+});
+
+cli({
+  site: "jimeng",
+  name: "workspaces",
+  description: "List Jimeng visible workspaces",
+  domain: "jimeng.jianying.com",
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [{ name: "limit", type: "int", default: 20 }],
+  columns: ["name", "url"],
+  func: async (page, kwargs) => {
+    const p = page as IPage;
+    const limit = intArg(kwargs.limit, 20, 100);
+    await p.goto(JIMENG, { settleMs: 2500 });
+    const rows = await p.evaluate(`(() => {
+      const links = [...document.querySelectorAll('a[href*="workspace"], [class*="workspace"] a[href]')];
+      const seen = new Set();
+      return links.map((a) => {
+        const url = new URL(a.getAttribute('href') || '', location.href).href;
+        if (seen.has(url)) return null;
+        seen.add(url);
+        return { name: (a.textContent || '').replace(/\\s+/g, ' ').trim(), url };
+      }).filter((row) => row && row.name).slice(0, ${js(limit)});
+    })()`);
+    return Array.isArray(rows) ? (rows as Record<string, unknown>[]) : [];
+  },
+});