@zenalexa/unicli 0.207.1

package/src/adapters/discord-app/discord-app.ts

@@ -0,0 +1,167 @@
+/**
+ * Discord desktop app adapter -- server/channel navigation + messaging.
+ *
+ * Commands: servers, channels, read, send, search, members, status
+ */
+
+import { connectElectronApp } from "../_electron/shared.js";
+import { cli, Strategy } from "../../registry.js";
+
+// servers -- List Discord servers
+cli({
+  site: "discord-app",
+  name: "servers",
+  description: "List Discord servers",
+  strategy: Strategy.PUBLIC,
+  func: async () => {
+    const p = await connectElectronApp("discord-app");
+    const servers = await p.evaluate(`
+      (() => {
+        const items = document.querySelectorAll(
+          '[data-list-id="guildsnav"] [class*="listItem"]'
+        );
+        return Array.from(items).map(el => ({
+          name: el.getAttribute('aria-label') ?? el.textContent?.trim(),
+        })).filter(s => s.name);
+      })()
+    `);
+    return servers as unknown[];
+  },
+});
+
+// channels -- List channels in current server
+cli({
+  site: "discord-app",
+  name: "channels",
+  description: "List channels in current server",
+  strategy: Strategy.PUBLIC,
+  func: async () => {
+    const p = await connectElectronApp("discord-app");
+    const channels = await p.evaluate(`
+      (() => {
+        const items = document.querySelectorAll('[class*="channelName"]');
+        return Array.from(items).slice(0, 50).map(el => ({
+          name: el.textContent?.trim(),
+        }));
+      })()
+    `);
+    return channels as unknown[];
+  },
+});
+
+// read -- Read recent messages
+cli({
+  site: "discord-app",
+  name: "read",
+  description: "Read recent messages",
+  strategy: Strategy.PUBLIC,
+  func: async () => {
+    const p = await connectElectronApp("discord-app");
+    const messages = await p.evaluate(`
+      (() => {
+        const items = document.querySelectorAll(
+          '[id^="chat-messages-"] [class*="message"]'
+        );
+        return Array.from(items).slice(-20).map(el => ({
+          author: el.querySelector('[class*="username"]')?.textContent?.trim(),
+          content: el.querySelector('[id^="message-content-"]')
+            ?.textContent?.trim()?.slice(0, 500),
+        }));
+      })()
+    `);
+    return messages as unknown[];
+  },
+});
+
+// send -- Send message in current channel
+cli({
+  site: "discord-app",
+  name: "send",
+  description: "Send message in current channel",
+  strategy: Strategy.PUBLIC,
+  args: [
+    {
+      name: "message",
+      required: true,
+      positional: true,
+      description: "Message to send",
+    },
+  ],
+  func: async (_page: unknown, kwargs: Record<string, unknown>) => {
+    const p = await connectElectronApp("discord-app");
+    const input =
+      '[class*="textArea"] [role="textbox"], [data-slate-editor="true"]';
+    await p.click(input);
+    await p.wait(0.2);
+    await p.insertText(String(kwargs.message));
+    await p.press("Enter");
+    return [{ ok: true }];
+  },
+});
+
+// search -- Search Discord messages
+cli({
+  site: "discord-app",
+  name: "search",
+  description: "Search Discord messages",
+  strategy: Strategy.PUBLIC,
+  args: [
+    {
+      name: "query",
+      required: true,
+      positional: true,
+      description: "Search query",
+    },
+  ],
+  func: async (_page: unknown, kwargs: Record<string, unknown>) => {
+    const p = await connectElectronApp("discord-app");
+    await p.press("f", ["meta"]);
+    await p.wait(0.5);
+    await p.insertText(String(kwargs.query));
+    await p.press("Enter");
+    await p.wait(2);
+    const results = await p.evaluate(`
+      (() => {
+        const items = document.querySelectorAll('[class*="searchResult"]');
+        return Array.from(items).slice(0, 10).map(el => ({
+          content: el.textContent?.trim()?.slice(0, 200),
+        }));
+      })()
+    `);
+    return results as unknown[];
+  },
+});
+
+// members -- List server members
+cli({
+  site: "discord-app",
+  name: "members",
+  description: "List server members",
+  strategy: Strategy.PUBLIC,
+  func: async () => {
+    const p = await connectElectronApp("discord-app");
+    const members = await p.evaluate(`
+      (() => {
+        const items = document.querySelectorAll('[class*="member-"]');
+        return Array.from(items).slice(0, 50).map(el => ({
+          name: el.querySelector('[class*="username"]')?.textContent?.trim(),
+          status: el.querySelector('[class*="status"]')?.textContent?.trim(),
+        }));
+      })()
+    `);
+    return members as unknown[];
+  },
+});
+
+// status -- Discord app status
+cli({
+  site: "discord-app",
+  name: "status",
+  description: "Discord app status",
+  strategy: Strategy.PUBLIC,
+  func: async () => {
+    const p = await connectElectronApp("discord-app");
+    const title = await p.title();
+    return [{ app: "Discord", title }];
+  },
+});

package/src/adapters/docker/build.yaml

@@ -0,0 +1,28 @@
+site: docker
+name: build
+description: Build a Docker image from a Dockerfile
+type: bridge
+strategy: public
+binary: docker
+detect: which docker
+
+pipeline:
+  - exec:
+      command: docker
+      args:
+        - build
+        - -t
+        - ${{ args.tag }}
+        - ${{ args.context }}
+      parse: text
+      timeout: 300000
+
+args:
+  tag:
+    type: str
+    required: true
+    description: Tag for the built image (e.g. myapp:latest)
+  context:
+    type: str
+    default: "."
+    description: Build context path (directory containing Dockerfile)

package/src/adapters/docker/images.yaml

@@ -0,0 +1,26 @@
+site: docker
+name: images
+description: List local Docker images
+type: bridge
+strategy: public
+binary: docker
+detect: which docker
+
+pipeline:
+  - exec:
+      command: docker
+      args:
+        - images
+        - "--format"
+        - "json"
+      parse: lines
+      timeout: 30000
+
+  - map:
+      repository: "${{ JSON.parse(item.line).Repository }}"
+      tag: "${{ JSON.parse(item.line).Tag }}"
+      id: "${{ JSON.parse(item.line).ID }}"
+      size: "${{ JSON.parse(item.line).Size }}"
+      created: "${{ JSON.parse(item.line).CreatedSince }}"
+
+columns: [repository, tag, id, size, created]

package/src/adapters/docker/logs.yaml

@@ -0,0 +1,29 @@
+site: docker
+name: logs
+description: Fetch logs from a Docker container
+type: bridge
+strategy: public
+binary: docker
+detect: which docker
+
+pipeline:
+  - exec:
+      command: docker
+      args:
+        - logs
+        - ${{ args.container }}
+        - --tail
+        - ${{ args.tail }}
+      parse: text
+      timeout: 30000
+
+args:
+  container:
+    type: str
+    required: true
+    positional: true
+    description: Container name or ID
+  tail:
+    type: int
+    default: 100
+    description: Number of lines to show from the end of logs

package/src/adapters/docker/ps.yaml

@@ -0,0 +1,32 @@
+site: docker
+name: ps
+description: List running Docker containers
+type: bridge
+strategy: public
+binary: docker
+detect: which docker
+
+pipeline:
+  - exec:
+      command: docker
+      args:
+        - ps
+        - "--format"
+        - "json"
+      parse: lines
+      timeout: 30000
+
+  - map:
+      id: "${{ JSON.parse(item.line).ID }}"
+      name: "${{ JSON.parse(item.line).Names }}"
+      image: "${{ JSON.parse(item.line).Image }}"
+      status: "${{ JSON.parse(item.line).Status }}"
+      ports: "${{ JSON.parse(item.line).Ports }}"
+
+args:
+  all:
+    type: bool
+    default: false
+    description: Show all containers including stopped ones
+
+columns: [id, name, image, status, ports]

package/src/adapters/docker/run.yaml

@@ -0,0 +1,29 @@
+site: docker
+name: run
+description: Run a command in a Docker container
+type: bridge
+strategy: public
+binary: docker
+detect: which docker
+
+pipeline:
+  - exec:
+      command: docker
+      args:
+        - run
+        - --rm
+        - ${{ args.image }}
+        - ${{ args.cmd }}
+      parse: text
+      timeout: 60000
+
+args:
+  image:
+    type: str
+    required: true
+    positional: true
+    description: Docker image to run
+  cmd:
+    type: str
+    default: ""
+    description: Command to run inside the container

package/src/adapters/doctl/droplets.yaml

@@ -0,0 +1,22 @@
+site: doctl
+name: droplets
+description: List DigitalOcean droplets
+type: bridge
+strategy: public
+binary: doctl
+detect: which doctl
+autoInstall: brew install doctl
+
+pipeline:
+  - exec:
+      command: doctl
+      args:
+        - compute
+        - droplet
+        - list
+        - --output
+        - json
+      parse: json
+      timeout: 30000
+
+columns: [id, name, region, status, vcpus, memory]

package/src/adapters/douban/book-hot.yaml

@@ -0,0 +1,32 @@
+site: douban
+name: book-hot
+description: Douban hot books
+domain: book.douban.com
+type: web-api
+strategy: public
+
+args:
+  limit:
+    type: int
+    default: 20
+    description: Number of books
+
+pipeline:
+  - fetch:
+      url: https://book.douban.com/j/search_subjects
+      params:
+        type: book
+        tag: 热门
+        page_limit: "${{ args.limit }}"
+        page_start: "0"
+
+  - select: subjects
+
+  - map:
+      title: ${{ item.title }}
+      rate: ${{ item.rate }}
+      url: ${{ item.url }}
+
+  - limit: ${{ args.limit }}
+
+columns: [title, rate, url]

package/src/adapters/douban/download.yaml

@@ -0,0 +1,51 @@
+site: douban
+name: download
+description: List Douban movie photo download URLs
+domain: movie.douban.com
+type: browser
+strategy: cookie
+auth_cookies: [dbcl2]
+
+args:
+  id:
+    positional: true
+    required: true
+    description: Movie subject ID
+  type:
+    default: R
+    description: Photo type (R=stills, S=posters)
+  limit:
+    type: int
+    default: 30
+    description: Number of photos
+
+pipeline:
+  - navigate: https://movie.douban.com/subject/${{ args.id }}/photos?type=${{ args.type }}
+
+  - evaluate: |
+      (() => {
+        const results = [];
+        const nodes = document.querySelectorAll('.poster-col3 li, .poster-col3l li, .article li');
+        for (const node of nodes) {
+          const link = node.querySelector('a[href*="/photos/photo/"]');
+          const img = node.querySelector('img');
+          if (!link || !img) continue;
+          const detailUrl = link.href || '';
+          const photoId = detailUrl.match(/\/photo\/(\d+)/)?.[1] || '';
+          const thumbUrl = img.getAttribute('data-origin') || img.getAttribute('data-src') || img.src || '';
+          const imageUrl = thumbUrl.replace(/\/view\/photo\/[^/]+\/public\//, '/view/photo/l/public/');
+          const title = link.getAttribute('title') || img.getAttribute('alt') || '';
+          results.push({
+            index: results.length + 1,
+            photo_id: photoId,
+            title: title || ('photo_' + (photoId || results.length + 1)),
+            download_url: imageUrl,
+            detail_url: detailUrl
+          });
+        }
+        return results;
+      })()
+
+  - limit: ${{ args.limit }}
+
+columns: [index, photo_id, title, download_url, detail_url]

package/src/adapters/douban/marks.yaml

@@ -0,0 +1,64 @@
+site: douban
+name: marks
+description: Douban movie marks/ratings for a user
+domain: movie.douban.com
+type: browser
+strategy: cookie
+auth_cookies: [dbcl2]
+
+args:
+  uid:
+    required: true
+    positional: true
+    description: Douban user ID (from profile URL)
+  status:
+    default: collect
+    description: "Mark type: collect (watched), wish, do (watching)"
+  limit:
+    type: int
+    default: 30
+    description: Number of marks
+
+pipeline:
+  - navigate: https://movie.douban.com/people/${{ args.uid }}/${{ args.status }}?start=0&sort=time&rating=all&filter=all&mode=grid
+
+  - evaluate: |
+      (() => {
+        const results = [];
+        const items = document.querySelectorAll('.item');
+        items.forEach(item => {
+          const titleLink = item.querySelector('.info a[href*="/subject/"]');
+          if (!titleLink) return;
+          const titleEl = titleLink.querySelector('em');
+          const title = (titleEl?.textContent?.trim() || titleLink.textContent?.trim() || '').split('/')[0].trim();
+          const href = titleLink.href || '';
+          const idMatch = href.match(/subject\/(\d+)/);
+          if (!idMatch || !title) return;
+
+          let myRating = '';
+          const ratingSpan = item.querySelector('span[class*="rating"]');
+          if (ratingSpan) {
+            const cls = ratingSpan.className || '';
+            const ratingMatch = cls.match(/rating(\d)-t/);
+            if (ratingMatch) myRating = String(parseInt(ratingMatch[1], 10) * 2);
+          }
+
+          const dateSpan = item.querySelector('.date');
+          const myDate = dateSpan?.textContent?.trim() || '';
+          const commentSpan = item.querySelector('.comment');
+          const myComment = commentSpan?.textContent?.trim() || '';
+
+          results.push({
+            title,
+            myRating,
+            myDate,
+            myComment: myComment.substring(0, 100),
+            url: href
+          });
+        });
+        return results;
+      })()
+
+  - limit: ${{ args.limit }}
+
+columns: [title, myRating, myDate, myComment, url]

package/src/adapters/douban/movie-hot.yaml

@@ -0,0 +1,33 @@
+site: douban
+name: movie-hot
+description: Douban hot movies
+domain: movie.douban.com
+type: web-api
+strategy: public
+
+args:
+  limit:
+    type: int
+    default: 20
+    description: Number of movies
+
+pipeline:
+  - fetch:
+      url: https://movie.douban.com/j/search_subjects
+      params:
+        type: movie
+        tag: 热门
+        page_limit: "${{ args.limit }}"
+        page_start: "0"
+
+  - select: subjects
+
+  - map:
+      title: ${{ item.title }}
+      rate: ${{ item.rate }}
+      url: ${{ item.url }}
+      cover: ${{ item.cover }}
+
+  - limit: ${{ args.limit }}
+
+columns: [title, rate, url]

package/src/adapters/douban/photos.yaml

@@ -0,0 +1,50 @@
+site: douban
+name: photos
+description: Get Douban movie posters and stills
+domain: movie.douban.com
+type: browser
+strategy: cookie
+auth_cookies: [dbcl2]
+
+args:
+  id:
+    positional: true
+    required: true
+    description: Movie subject ID
+  type:
+    default: R
+    description: Photo type (R=stills, S=posters)
+  limit:
+    type: int
+    default: 30
+    description: Number of photos
+
+pipeline:
+  - navigate: https://movie.douban.com/subject/${{ args.id }}/photos?type=${{ args.type }}
+
+  - evaluate: |
+      (() => {
+        const results = [];
+        const nodes = document.querySelectorAll('.poster-col3 li, .poster-col3l li, .article li');
+        for (const node of nodes) {
+          const link = node.querySelector('a[href*="/photos/photo/"]');
+          const img = node.querySelector('img');
+          if (!link || !img) continue;
+          const detailUrl = link.href || '';
+          const photoId = detailUrl.match(/\/photo\/(\d+)/)?.[1] || '';
+          const thumbUrl = img.getAttribute('data-origin') || img.getAttribute('data-src') || img.src || '';
+          const imageUrl = thumbUrl.replace(/\/view\/photo\/[^/]+\/public\//, '/view/photo/l/public/');
+          const title = link.getAttribute('title') || img.getAttribute('alt') || '';
+          results.push({
+            index: results.length + 1,
+            title: title || ('photo_' + (photoId || results.length + 1)),
+            image_url: imageUrl,
+            detail_url: detailUrl
+          });
+        }
+        return results;
+      })()
+
+  - limit: ${{ args.limit }}
+
+columns: [index, title, image_url, detail_url]

package/src/adapters/douban/reviews.yaml

@@ -0,0 +1,61 @@
+site: douban
+name: reviews
+description: Douban user movie reviews
+domain: movie.douban.com
+type: browser
+strategy: cookie
+auth_cookies: [dbcl2]
+
+args:
+  uid:
+    required: true
+    positional: true
+    description: Douban user ID (from profile URL)
+  limit:
+    type: int
+    default: 20
+    description: Number of reviews
+
+pipeline:
+  - navigate: https://movie.douban.com/people/${{ args.uid }}/reviews?start=0&sort=time
+
+  - evaluate: |
+      (() => {
+        const reviews = [];
+        document.querySelectorAll('.tlst').forEach(el => {
+          const movieLinkEl = el.querySelector('.ilst a');
+          const reviewTitleEl = el.querySelector('.nlst a[title]');
+          const ratingEl = el.querySelector('.clst span[class*="allstar"]');
+          const contentEl = el.querySelector('.review-short span');
+          const votesEl = el.querySelector('.review-short .pl span');
+
+          const movieTitle = movieLinkEl?.getAttribute('title') || movieLinkEl?.textContent?.trim() || '';
+          const title = reviewTitleEl?.textContent?.trim() || '';
+          const reviewHref = reviewTitleEl?.href || '';
+
+          let myRating = '';
+          if (ratingEl) {
+            const cls = ratingEl.className || '';
+            const ratingMatch = cls.match(/allstar(\d)0/);
+            if (ratingMatch) myRating = String(parseInt(ratingMatch[1], 10) * 2);
+          }
+
+          const votesText = votesEl?.textContent || '';
+          const votesMatch = votesText.match(/(\d+)/);
+          const votes = votesMatch ? votesMatch[1] : '0';
+
+          reviews.push({
+            movieTitle,
+            title,
+            myRating,
+            votes,
+            content: (contentEl?.textContent?.trim() || '').substring(0, 150),
+            url: reviewHref
+          });
+        });
+        return reviews;
+      })()
+
+  - limit: ${{ args.limit }}
+
+columns: [movieTitle, title, myRating, votes, content, url]

package/src/adapters/douban/search.yaml

@@ -0,0 +1,35 @@
+site: douban
+name: search
+description: Search Douban movies and books
+domain: www.douban.com
+type: web-api
+strategy: cookie
+auth_cookies: [dbcl2]
+
+args:
+  query:
+    required: true
+    positional: true
+    description: Search query
+  limit:
+    type: int
+    default: 20
+
+pipeline:
+  - fetch:
+      url: https://www.douban.com/j/search
+      params:
+        q: "${{ args.query }}"
+        start: "0"
+        cat: "1002"
+
+  - select: items
+
+  - map:
+      title: ${{ (item.title || '') | strip_html }}
+      url: ${{ item.url }}
+      rating: ${{ item.rating?.average || '' }}
+
+  - limit: ${{ args.limit }}
+
+columns: [title, url, rating]