@zenalexa/unicli 0.225.0 → 0.225.2

package/src/adapters/ollama-cloud/search.yaml

@@ -0,0 +1,43 @@
+site: ollama-cloud
+name: search
+description: Search the web through Ollama Cloud web_search
+type: web-api
+domain: ollama.com
+strategy: public # auth is via OLLAMA_API_KEY Authorization header, no cookies
+
+args:
+  query:
+    type: str
+    required: true
+    positional: true
+    description: Web search query
+  limit:
+    type: int
+    default: 5
+    description: Maximum number of results to return
+
+pipeline:
+  - fetch:
+      url: https://ollama.com/api/web_search
+      method: POST
+      headers:
+        Accept: "application/json"
+        Authorization: "Bearer ${{ env.OLLAMA_API_KEY || '' }}"
+      body:
+        query: "${{ args.query }}"
+  - select: results
+  - map:
+      title: "${{ item.title || '' }}"
+      url: "${{ item.url || '' }}"
+      content: "${{ item.content || '' }}"
+  - limit: ${{ args.limit }}
+
+columns: [title, url, content]
+
+# schema-v2 metadata — injected by `unicli migrate schema-v2`
+capabilities: ["http.fetch", "select", "map", "limit"]
+minimum_capability: http.fetch
+trust: public
+confidentiality: public
+quarantine: false
+schema_version: v2

package/src/adapters/spotify/api.ts

@@ -16,6 +16,12 @@ interface SpotifyConfig {
   SPOTIFY_REDIRECT_URI?: string;
 }
 
+interface SpotifyTrack {
+  uri: string;
+  name: string;
+  artist: string;
+}
+
 const TOKEN_PATH = join(homedir(), ".unicli", "spotify-tokens.json");
 const ENV_PATH = join(homedir(), ".unicli", "spotify.env");
 
@@ -113,13 +119,26 @@ async function spotifyApi(
   return response.json();
 }
 
-async function searchTrack(query: string): Promise<string> {
+async function searchTrack(query: string): Promise<SpotifyTrack> {
   const data = (await spotifyApi(
     `/search?type=track&limit=1&q=${encodeURIComponent(query)}`,
-  )) as { tracks?: { items?: Array<{ uri?: string }> } };
-  const uri = data.tracks?.items?.[0]?.uri;
-  if (!uri) throw new Error(`No Spotify track found for query: ${query}`);
-  return uri;
+  )) as {
+    tracks?: {
+      items?: Array<{
+        uri?: string;
+        name?: string;
+        artists?: Array<{ name?: string }>;
+      }>;
+    };
+  };
+  const track = data.tracks?.items?.[0];
+  if (!track?.uri)
+    throw new Error(`No Spotify track found for query: ${query}`);
+  return {
+    uri: track.uri,
+    name: track.name ?? "",
+    artist: track.artists?.map((artist) => artist.name).join(", ") ?? "",
+  };
 }
 
 cli({
@@ -235,11 +254,38 @@ cli({
   args: [{ name: "query", type: "str", required: true, positional: true }],
   columns: ["ok", "uri"],
   func: async (_page, kwargs) => {
-    const uri = await searchTrack(str(kwargs.query));
-    await spotifyApi(`/me/player/queue?uri=${encodeURIComponent(uri)}`, {
+    const track = await searchTrack(str(kwargs.query));
+    await spotifyApi(`/me/player/queue?uri=${encodeURIComponent(track.uri)}`, {
       method: "POST",
     });
-    return [{ ok: true, uri }];
+    return [{ ok: true, uri: track.uri }];
+  },
+});
+
+cli({
+  site: "spotify",
+  name: "play-track",
+  description: "Search Spotify for a track query and start playback",
+  domain: "api.spotify.com",
+  strategy: Strategy.COOKIE,
+  args: [{ name: "query", type: "str", required: true, positional: true }],
+  columns: ["ok", "query", "track", "artist", "uri"],
+  func: async (_page, kwargs) => {
+    const query = str(kwargs.query);
+    const track = await searchTrack(query);
+    await spotifyApi("/me/player/play", {
+      method: "PUT",
+      body: JSON.stringify({ uris: [track.uri] }),
+    });
+    return [
+      {
+        ok: true,
+        query,
+        track: track.name,
+        artist: track.artist,
+        uri: track.uri,
+      },
+    ];
   },
 });
 

package/src/adapters/weibo/trending.yaml

@@ -14,6 +14,8 @@ args:
 pipeline:
   - fetch:
       url: https://weibo.com/ajax/side/hotSearch
+      headers:
+        Referer: https://weibo.com/
 
   - select: data.realtime
 

package/src/adapters/xiaohongshu/browser-state.ts

@@ -2,7 +2,7 @@
  * @owner   Xiaohongshu browser adapters.
  * @does    Detects login, risk-control, and rendered-feed state in XHS web pages.
  * @needs   Browser-backed IPage from Uni-CLI runtime.
- * @feeds   xiaohongshu.search and xiaohongshu.trending.
+ * @feeds   xiaohongshu.feed, xiaohongshu.search, and xiaohongshu.trending.
  * @breaks  XHS copy or route changes can require updating page-state detection.
  */
 
@@ -62,7 +62,7 @@ export async function assertXhsReadable(
   assertXhsReadableState(command, await readXhsPageState(page));
 }
 
-export async function fetchXhsFeedItems(page: IPage): Promise<unknown[]> {
+async function fetchXhsStoreFeedItems(page: IPage): Promise<unknown[]> {
   const raw = await page.evaluate(`
     (async () => {
       const app = document.querySelector('#app')?.__vue_app__;
@@ -93,3 +93,60 @@ export async function fetchXhsFeedItems(page: IPage): Promise<unknown[]> {
   `);
   return Array.isArray(raw) ? raw : [];
 }
+
+export async function fetchXhsVisibleFeedItems(
+  page: IPage,
+): Promise<unknown[]> {
+  const raw = await page.evaluate(`
+    (() => {
+      const cleanText = (value) => String(value || '').replace(/\\s+/g, ' ').trim();
+      const normalizeUrl = (href) => {
+        if (!href) return '';
+        if (href.startsWith('http://') || href.startsWith('https://')) return href;
+        if (href.startsWith('/')) return 'https://www.xiaohongshu.com' + href;
+        return '';
+      };
+      const noteIdFromUrl = (url) => {
+        const match = url.match(/\\/(?:explore|search_result|note)\\/([^?#/]+)/i);
+        return match ? match[1] : '';
+      };
+      const rows = [];
+      const seen = new Set();
+      document.querySelectorAll('section.note-item, .note-item').forEach((el) => {
+        const link =
+          el.querySelector('a[href*="/explore/"]') ||
+          el.querySelector('a[href*="/search_result/"]') ||
+          el.querySelector('a[href*="/note/"]');
+        const url = normalizeUrl(link?.getAttribute('href') || '');
+        const id = noteIdFromUrl(url);
+        if (!id || seen.has(id)) return;
+        seen.add(id);
+
+        const titleEl = el.querySelector('.title, .note-title, a.title, .footer .title span');
+        const authorEl = el.querySelector('a.author .name, .name, .author-name, .nick-name, a.author');
+        const likesEl = el.querySelector('.count, .like-count, .like-wrapper .count');
+        const isVideo =
+          !!el.querySelector('video, .play-icon, .video-icon') ||
+          /视频/.test(cleanText(el.textContent));
+
+        rows.push({
+          id,
+          note_card: {
+            display_title: cleanText(titleEl?.textContent || link?.textContent || ''),
+            type: isVideo ? 'video' : 'normal',
+            user: { nickname: cleanText(authorEl?.textContent || '') },
+            interact_info: { liked_count: cleanText(likesEl?.textContent || '0') },
+          },
+        });
+      });
+      return rows;
+    })()
+  `);
+  return Array.isArray(raw) ? raw : [];
+}
+
+export async function fetchXhsFeedItems(page: IPage): Promise<unknown[]> {
+  const storeItems = await fetchXhsStoreFeedItems(page).catch(() => []);
+  if (storeItems.length > 0) return storeItems;
+  return fetchXhsVisibleFeedItems(page);
+}

package/src/adapters/xiaohongshu/feed.ts

@@ -0,0 +1,103 @@
+/**
+ * @owner   src/adapters/xiaohongshu/feed.ts
+ * @does    Register Xiaohongshu home-feed extraction over a logged-in browser page.
+ * @needs   Browser-backed IPage, XHS readable-state checks, visible/store feed extraction.
+ * @feeds   xiaohongshu.feed command.
+ * @breaks  XHS feed route or note-card DOM drift returns structured empty_result.
+ * @invariants Rows expose stable note title, author, likes, type, and canonical note URL.
+ * @side-effects Performs authenticated read navigation to Xiaohongshu explore.
+ * @perf     One page navigation plus at most one visible DOM extraction per invocation.
+ * @concurrency Stateless per invocation.
+ * @test     tests/unit/xiaohongshu-feed.test.ts
+ * @stability stable
+ * @since    2026-06-02
+ */
+
+import { cli, Strategy } from "../../registry.js";
+import type { IPage } from "../../types.js";
+import { socialEmptyError } from "../../social/browser-errors.js";
+import { assertXhsReadable, fetchXhsFeedItems } from "./browser-state.js";
+
+export interface XhsFeedRow {
+  id: string;
+  title: string;
+  author: string;
+  likes: string;
+  type: string;
+  url: string;
+}
+
+function asRecord(value: unknown): Record<string, unknown> {
+  return value && typeof value === "object"
+    ? (value as Record<string, unknown>)
+    : {};
+}
+
+function cleanText(value: unknown): string {
+  return String(value ?? "")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+export function normalizeXhsFeedRows(
+  items: unknown[],
+  limit: number,
+): XhsFeedRow[] {
+  return items
+    .map((item) => {
+      const root = asRecord(item);
+      const note = asRecord(root.note_card);
+      const user = asRecord(note.user);
+      const interact = asRecord(note.interact_info);
+      const id = cleanText(root.id);
+      const title = cleanText(note.display_title);
+      if (!id || !title) return null;
+      return {
+        id,
+        title,
+        type: cleanText(note.type) || "normal",
+        author: cleanText(user.nickname),
+        likes: cleanText(interact.liked_count),
+        url: `https://www.xiaohongshu.com/explore/${id}`,
+      };
+    })
+    .filter((row): row is XhsFeedRow => row !== null)
+    .slice(0, limit);
+}
+
+cli({
+  site: "xiaohongshu",
+  name: "feed",
+  description: "Xiaohongshu home feed",
+  domain: "www.xiaohongshu.com",
+  strategy: Strategy.COOKIE,
+  browser: true,
+  browserSession: "user",
+  args: [
+    {
+      name: "limit",
+      type: "int",
+      default: 20,
+      description: "Number of items to return",
+    },
+  ],
+  columns: ["title", "author", "likes", "type", "url"],
+  capabilities: ["cdp-browser.navigate", "cdp-browser.evaluate"],
+  minimum_capability: "cdp-browser.evaluate",
+  async func(page, kwargs) {
+    const p = page as IPage;
+    const limit = Number(kwargs.limit) || 20;
+    await p.goto("https://www.xiaohongshu.com/explore", { settleMs: 2500 });
+    await p.wait(2);
+    await assertXhsReadable(p, "feed");
+
+    const rows = normalizeXhsFeedRows(await fetchXhsFeedItems(p), limit);
+    if (rows.length > 0) return rows;
+
+    throw socialEmptyError(
+      "xiaohongshu",
+      "feed",
+      "Xiaohongshu explore loaded no parseable feed rows.",
+    );
+  },
+});