@zenalexa/unicli 0.207.1

package/src/adapters/jike/user.yaml

@@ -0,0 +1,53 @@
+site: jike
+name: user
+description: Jike user posts
+domain: m.okjike.com
+type: browser
+strategy: cookie
+auth_cookies: [accessToken]
+
+args:
+  username:
+    positional: true
+    type: str
+    required: true
+    description: Username from profile URL
+  limit:
+    type: int
+    default: 20
+    description: Number of posts
+
+pipeline:
+  - navigate: https://m.okjike.com/users/${{ args.username }}
+
+  - evaluate: |
+      (() => {
+        try {
+          const el = document.querySelector('script[type="application/json"]');
+          if (!el) return [];
+          const data = JSON.parse(el.textContent);
+          const posts = data?.props?.pageProps?.posts || [];
+          return posts.map(p => ({
+            content: (p.content || '').replace(/\n/g, ' ').slice(0, 80),
+            type: p.type === 'ORIGINAL_POST' ? 'post' : p.type === 'REPOST' ? 'repost' : p.type || '',
+            likes: p.likeCount || 0,
+            comments: p.commentCount || 0,
+            time: p.actionTime || p.createdAt || '',
+            id: p.id || '',
+          }));
+        } catch (e) {
+          return [];
+        }
+      })()
+
+  - map:
+      content: ${{ item.content }}
+      type: ${{ item.type }}
+      likes: ${{ item.likes }}
+      comments: ${{ item.comments }}
+      time: ${{ item.time }}
+      url: https://web.okjike.com/originalPost/${{ item.id }}
+
+  - limit: ${{ args.limit }}
+
+columns: [content, type, likes, comments, time, url]

package/src/adapters/jimeng/generate.yaml

@@ -0,0 +1,59 @@
+site: jimeng
+name: generate
+description: Generate images with Jimeng AI (text-to-image)
+domain: jimeng.jianying.com
+strategy: intercept
+browser: true
+
+args:
+  prompt:
+    type: str
+    required: true
+    positional: true
+    description: Image description prompt
+  wait:
+    type: int
+    default: 40
+    description: Seconds to wait for generation
+
+columns: [status, prompt, image_count, image_urls]
+
+pipeline:
+  - navigate:
+      url: https://jimeng.jianying.com/ai-tool/generate?type=image&workspace=0
+      settleMs: 3000
+
+  - evaluate: |
+      (async () => {
+        const prompt = ${{ args.prompt | json }};
+        const waitSec = ${{ args.wait }};
+        const beforeImgs = document.querySelectorAll('img[src*="dreamina-sign"], img[src*="tb4s082cfz"]').length;
+
+        const editor = document.querySelector('[contenteditable="true"]');
+        if (!editor) return [{ status: 'failed', prompt, image_count: 0, image_urls: 'Editor not found' }];
+        editor.focus();
+        await new Promise(r => setTimeout(r, 200));
+        document.execCommand('selectAll');
+        document.execCommand('delete');
+        await new Promise(r => setTimeout(r, 200));
+        document.execCommand('insertText', false, prompt);
+        await new Promise(r => setTimeout(r, 500));
+
+        const btn = document.querySelector('.lv-btn.lv-btn-primary[class*="circle"]');
+        if (!btn) return [{ status: 'failed', prompt, image_count: 0, image_urls: 'Generate button not found' }];
+        btn.click();
+
+        let newImgs = [];
+        for (let i = 0; i < waitSec; i++) {
+          await new Promise(r => setTimeout(r, 1000));
+          const allImgs = document.querySelectorAll('img[src*="dreamina-sign"], img[src*="tb4s082cfz"]');
+          if (allImgs.length > beforeImgs) {
+            newImgs = Array.from(allImgs).slice(0, allImgs.length - beforeImgs);
+            break;
+          }
+        }
+
+        if (newImgs.length === 0) return [{ status: 'timeout', prompt: prompt.substring(0, 80), image_count: 0, image_urls: 'Still generating' }];
+        const urls = newImgs.map(img => img.src);
+        return [{ status: 'success', prompt: prompt.substring(0, 80), image_count: urls.length, image_urls: urls.join('\n') }];
+      })()

package/src/adapters/jimeng/history.yaml

@@ -0,0 +1,30 @@
+site: jimeng
+name: history
+description: List Jimeng AI generation history
+domain: jimeng.jianying.com
+strategy: intercept
+browser: true
+
+args:
+  limit:
+    type: int
+    default: 20
+    description: Number of results
+
+columns: [rank, prompt, image_count, url]
+
+pipeline:
+  - navigate:
+      url: https://jimeng.jianying.com/ai-tool/generate?type=image&workspace=0
+      settleMs: 3000
+
+  - evaluate: |
+      (async () => {
+        const limit = ${{ args.limit }};
+        const cards = document.querySelectorAll('[class*="history-item"], [class*="creation-card"]');
+        return Array.from(cards).slice(0, limit).map((el, i) => {
+          const prompt = (el.querySelector('[class*="prompt"], [class*="desc"]')?.textContent || '').trim().substring(0, 100);
+          const images = el.querySelectorAll('img').length;
+          return { rank: i + 1, prompt, image_count: images, url: location.href };
+        });
+      })()

package/src/adapters/jq/format.yaml

@@ -0,0 +1,23 @@
+site: jq
+name: format
+description: Pretty-print and format JSON data
+type: bridge
+strategy: public
+binary: jq
+detect: which jq
+
+pipeline:
+  - exec:
+      command: jq
+      args:
+        - "."
+      stdin: ${{ args.input }}
+      parse: text
+      timeout: 30000
+
+args:
+  input:
+    type: str
+    required: true
+    positional: true
+    description: JSON string to format

package/src/adapters/jq/query.yaml

@@ -0,0 +1,27 @@
+site: jq
+name: query
+description: Query JSON data using a jq filter expression
+type: bridge
+strategy: public
+binary: jq
+detect: which jq
+
+pipeline:
+  - exec:
+      command: jq
+      args:
+        - ${{ args.filter }}
+      stdin: ${{ args.input }}
+      parse: json
+      timeout: 30000
+
+args:
+  filter:
+    type: str
+    required: true
+    positional: true
+    description: jq filter expression (e.g. .items[].name)
+  input:
+    type: str
+    required: true
+    description: JSON string to process

package/src/adapters/kdenlive/effects.yaml

@@ -0,0 +1,15 @@
+# Desktop adapter — list available MLT effects for Kdenlive
+site: kdenlive
+name: effects
+description: List available MLT video/audio effects
+type: desktop
+binary: melt
+detect: which melt
+
+pipeline:
+  - exec:
+      command: melt
+      args: ["-query", "filters"]
+      parse: text
+
+columns: [result]

package/src/adapters/kdenlive/info.yaml

@@ -0,0 +1,41 @@
+# Desktop adapter — extract project info from a Kdenlive file
+site: kdenlive
+name: info
+description: Extract project metadata from a .kdenlive file (tracks, clips, duration)
+type: desktop
+binary: python3
+detect: which python3
+
+args:
+  file:
+    type: str
+    required: true
+    positional: true
+    description: Path to .kdenlive project file
+
+pipeline:
+  - write_temp:
+      filename: kdenlive_info.py
+      content: |
+        import json, xml.etree.ElementTree as ET
+        tree = ET.parse("${{ args.file }}")
+        root = tree.getroot()
+        profile = root.find('.//profile')
+        tracks = root.findall('.//track')
+        producers = root.findall('.//producer')
+        info = {
+            "tracks": len(tracks),
+            "clips": len(producers),
+        }
+        if profile is not None:
+            info["width"] = profile.get("width", "")
+            info["height"] = profile.get("height", "")
+            info["fps"] = profile.get("frame_rate_num", "")
+        print("UNICLI_JSON:" + json.dumps(info))
+
+  - exec:
+      command: python3
+      args: ["${{ temp.kdenlive_info_py }}"]
+      parse: text
+
+columns: [tracks, clips, width, height, fps]

package/src/adapters/kdenlive/render.yaml

@@ -0,0 +1,40 @@
+# Desktop adapter — render a Kdenlive project using melt
+site: kdenlive
+name: render
+description: Render a Kdenlive project to video file via melt
+type: desktop
+binary: melt
+detect: which melt
+timeout: 600000
+
+args:
+  input:
+    type: str
+    required: true
+    positional: true
+    description: Path to .kdenlive project file
+  output:
+    type: str
+    required: true
+    description: Output video file path
+  format:
+    type: str
+    default: mp4
+    choices: [mp4, webm, mkv, avi]
+    description: Output video format
+
+pipeline:
+  - exec:
+      command: melt
+      args:
+        [
+          "${{ args.input }}",
+          "-consumer",
+          "avformat:${{ args.output }}",
+          "acodec=aac",
+          "vcodec=libx264",
+        ]
+      parse: text
+      timeout: 600000
+
+columns: [result]

package/src/adapters/krita/batch.yaml

@@ -0,0 +1,45 @@
+# Desktop adapter — batch export Krita files using a Python script
+site: krita
+name: batch
+description: Batch convert multiple image files to a target format
+type: desktop
+binary: krita
+detect: which krita
+timeout: 300000
+
+args:
+  dir:
+    type: str
+    required: true
+    positional: true
+    description: Directory containing source files
+  format:
+    type: str
+    required: true
+    choices: [png, jpg, webp, tiff]
+    description: Target output format
+
+pipeline:
+  - write_temp:
+      filename: batch_export.py
+      content: |
+        import os, json, subprocess, glob
+        src_dir = "${{ args.dir }}"
+        fmt = "${{ args.format }}"
+        files = glob.glob(os.path.join(src_dir, "*"))
+        count = 0
+        for f in files:
+            ext = os.path.splitext(f)[1].lower()
+            if ext in ('.kra', '.png', '.jpg', '.jpeg', '.tiff', '.webp', '.bmp'):
+                out = os.path.splitext(f)[0] + '.' + fmt
+                subprocess.run(['krita', '--export', '--export-filename', out, f], capture_output=True)
+                count += 1
+        print(f'UNICLI_JSON:{{"processed":{count},"format":"{fmt}"}}')
+
+  - exec:
+      command: python3
+      args: ["${{ temp.batch_export_py }}"]
+      parse: text
+      timeout: 300000
+
+columns: [processed, format]

package/src/adapters/krita/convert.yaml

@@ -0,0 +1,34 @@
+# Desktop adapter — convert image between formats using Krita
+site: krita
+name: convert
+description: Convert image between formats using Krita's headless mode
+type: desktop
+binary: krita
+detect: which krita
+timeout: 60000
+
+args:
+  input:
+    type: str
+    required: true
+    positional: true
+    description: Path to input image
+  output:
+    type: str
+    required: true
+    description: Output file path
+
+pipeline:
+  - exec:
+      command: krita
+      args:
+        [
+          "--export",
+          "--export-filename",
+          "${{ args.output }}",
+          "${{ args.input }}",
+        ]
+      parse: text
+      timeout: 60000
+
+columns: [result]

package/src/adapters/krita/export.yaml

@@ -0,0 +1,34 @@
+# Desktop adapter — export a Krita file to image format
+site: krita
+name: export
+description: Export a .kra file to PNG, JPEG, or other image format
+type: desktop
+binary: krita
+detect: which krita
+timeout: 60000
+
+args:
+  input:
+    type: str
+    required: true
+    positional: true
+    description: Path to .kra file
+  output:
+    type: str
+    required: true
+    description: Output file path (format inferred from extension)
+
+pipeline:
+  - exec:
+      command: krita
+      args:
+        [
+          "--export",
+          "--export-filename",
+          "${{ args.output }}",
+          "${{ args.input }}",
+        ]
+      parse: text
+      timeout: 60000
+
+columns: [result]

package/src/adapters/krita/info.yaml

@@ -0,0 +1,46 @@
+# Desktop adapter — get Krita file info via Python
+site: krita
+name: info
+description: Extract metadata from a Krita .kra file (dimensions, layers, color space)
+type: desktop
+binary: python3
+detect: which python3
+
+args:
+  file:
+    type: str
+    required: true
+    positional: true
+    description: Path to .kra file
+
+pipeline:
+  - write_temp:
+      filename: krita_info.py
+      content: |
+        import zipfile, json, xml.etree.ElementTree as ET
+        path = "${{ args.file }}"
+        with zipfile.ZipFile(path, 'r') as z:
+            with z.open('maindoc.xml') as f:
+                tree = ET.parse(f)
+                root = tree.getroot()
+                ns = {'k': root.tag.split('}')[0].strip('{')} if '{' in root.tag else {}
+                img = root.find('.//IMAGE') or root.find('.//{*}IMAGE') or root.find('.//image')
+                if img is not None:
+                    info = {
+                        "width": img.get("width", ""),
+                        "height": img.get("height", ""),
+                        "name": img.get("name", ""),
+                        "colorspace": img.get("colorspacename", ""),
+                    }
+                    layers = img.findall('.//{*}layer') or img.findall('.//layer')
+                    info["layers"] = len(layers)
+                else:
+                    info = {"error": "Could not parse maindoc.xml"}
+        print("UNICLI_JSON:" + json.dumps(info))
+
+  - exec:
+      command: python3
+      args: ["${{ temp.krita_info_py }}"]
+      parse: text
+
+columns: [name, width, height, colorspace, layers]

package/src/adapters/lark/version.yaml

@@ -0,0 +1,17 @@
+site: lark
+name: version
+description: Check Lark CLI version and status
+type: bridge
+strategy: public
+binary: lark
+detect: which lark
+
+pipeline:
+  - exec:
+      command: lark
+      args:
+        - --version
+      parse: text
+      timeout: 10000
+
+columns: [output]

package/src/adapters/lesswrong/comments.yaml

@@ -0,0 +1,41 @@
+site: lesswrong
+name: comments
+description: Top comments on a post
+domain: www.lesswrong.com
+strategy: public
+
+args:
+  post-id:
+    type: str
+    required: true
+    positional: true
+    description: Post URL or LessWrong post ID
+  limit:
+    type: int
+    default: 5
+    description: Number of comments
+
+columns: [rank, score, author, text]
+
+pipeline:
+  - fetch:
+      url: https://www.lesswrong.com/graphql
+      method: POST
+      headers:
+        Content-Type: application/json
+        Accept: application/json
+      body:
+        query: >
+          query Comments {
+            comments(input: {terms: {view: "postCommentsTop", postId: "${{ (args['post-id'].match(/posts\\/([a-zA-Z0-9]+)/) || [null, args['post-id']])[1] }}", limit: ${{ args.limit }}}}) {
+              results { _id user { displayName } baseScore htmlBody }
+            }
+          }
+
+  - select: data.comments.results
+
+  - map:
+      rank: "${{ index + 1 }}"
+      score: "${{ item.baseScore || 0 }}"
+      author: "${{ item.user.displayName || 'Unknown' }}"
+      text: "${{ (item.htmlBody || '').replace(/<[^>]+>/g, ' ').replace(/\\s+/g, ' ').trim() | truncate(500) }}"

package/src/adapters/lesswrong/curated.yaml

@@ -0,0 +1,38 @@
+site: lesswrong
+name: curated
+description: "Curated editor's picks"
+domain: www.lesswrong.com
+strategy: public
+
+args:
+  limit:
+    type: int
+    default: 10
+    description: Number of results
+
+columns: [rank, title, author, karma, comments, url]
+
+pipeline:
+  - fetch:
+      url: https://www.lesswrong.com/graphql
+      method: POST
+      headers:
+        Content-Type: application/json
+        Accept: application/json
+      body:
+        query: >
+          query PostsList {
+            posts(input: {terms: {view: "curated", limit: ${{ args.limit }}}}) {
+              results { _id title user { displayName } baseScore commentCount slug }
+            }
+          }
+
+  - select: data.posts.results
+
+  - map:
+      rank: "${{ index + 1 }}"
+      title: "${{ item.title }}"
+      author: "${{ item.user.displayName || 'Unknown' }}"
+      karma: "${{ item.baseScore || 0 }}"
+      comments: "${{ item.commentCount || 0 }}"
+      url: "https://www.lesswrong.com/posts/${{ item._id }}/${{ item.slug }}"

package/src/adapters/lesswrong/frontpage.yaml

@@ -0,0 +1,38 @@
+site: lesswrong
+name: frontpage
+description: Algorithmic frontpage posts
+domain: www.lesswrong.com
+strategy: public
+
+args:
+  limit:
+    type: int
+    default: 10
+    description: Number of results
+
+columns: [rank, title, author, karma, comments, url]
+
+pipeline:
+  - fetch:
+      url: https://www.lesswrong.com/graphql
+      method: POST
+      headers:
+        Content-Type: application/json
+        Accept: application/json
+      body:
+        query: >
+          query PostsList {
+            posts(input: {terms: {view: "frontpage", limit: ${{ args.limit }}}}) {
+              results { _id title user { displayName } baseScore commentCount slug }
+            }
+          }
+
+  - select: data.posts.results
+
+  - map:
+      rank: "${{ index + 1 }}"
+      title: "${{ item.title }}"
+      author: "${{ item.user.displayName || 'Unknown' }}"
+      karma: "${{ item.baseScore || 0 }}"
+      comments: "${{ item.commentCount || 0 }}"
+      url: "https://www.lesswrong.com/posts/${{ item._id }}/${{ item.slug }}"

package/src/adapters/lesswrong/new.yaml

@@ -0,0 +1,38 @@
+site: lesswrong
+name: new
+description: Latest posts
+domain: www.lesswrong.com
+strategy: public
+
+args:
+  limit:
+    type: int
+    default: 10
+    description: Number of results
+
+columns: [rank, title, author, karma, comments, url]
+
+pipeline:
+  - fetch:
+      url: https://www.lesswrong.com/graphql
+      method: POST
+      headers:
+        Content-Type: application/json
+        Accept: application/json
+      body:
+        query: >
+          query PostsList {
+            posts(input: {terms: {view: "new", limit: ${{ args.limit }}}}) {
+              results { _id title user { displayName } baseScore commentCount slug }
+            }
+          }
+
+  - select: data.posts.results
+
+  - map:
+      rank: "${{ index + 1 }}"
+      title: "${{ item.title }}"
+      author: "${{ item.user.displayName || 'Unknown' }}"
+      karma: "${{ item.baseScore || 0 }}"
+      comments: "${{ item.commentCount || 0 }}"
+      url: "https://www.lesswrong.com/posts/${{ item._id }}/${{ item.slug }}"

package/src/adapters/lesswrong/read.yaml

@@ -0,0 +1,40 @@
+site: lesswrong
+name: read
+description: Read full post by URL or ID
+domain: www.lesswrong.com
+strategy: public
+
+args:
+  post-id:
+    type: str
+    required: true
+    positional: true
+    description: Post URL or LessWrong post ID (e.g. "abc123" or full URL)
+
+columns: [title, author, karma, comments, tags, content, url]
+
+pipeline:
+  - fetch:
+      url: https://www.lesswrong.com/graphql
+      method: POST
+      headers:
+        Content-Type: application/json
+        Accept: application/json
+      body:
+        query: >
+          query PostsSingle {
+            post(input: {selector: {documentId: "${{ (args['post-id'].match(/posts\\/([a-zA-Z0-9]+)/) || [null, args['post-id']])[1] }}"}}) {
+              result { _id title user { displayName } baseScore commentCount htmlBody slug tags { name } }
+            }
+          }
+
+  - select: data.post.result
+
+  - map:
+      title: "${{ item.title }}"
+      author: "${{ item.user.displayName || 'Unknown' }}"
+      karma: "${{ item.baseScore || 0 }}"
+      comments: "${{ item.commentCount || 0 }}"
+      tags: "${{ (item.tags || []).map(t => t.name).join(', ') }}"
+      content: "${{ (item.htmlBody || '').replace(/<[^>]+>/g, ' ').replace(/\\s+/g, ' ').trim() | truncate(3000) }}"
+      url: "https://www.lesswrong.com/posts/${{ item._id }}/${{ item.slug }}"