@zenalexa/unicli 0.207.1

package/src/adapters/bilibili/user-videos.ts

@@ -0,0 +1,69 @@
+/**
+ * Bilibili user video list adapter — list videos by user mid.
+ *
+ * Endpoint: /x/space/wbi/arc/search
+ */
+
+import { cli, Strategy } from "../../registry.js";
+import { wbiFetch } from "./wbi.js";
+
+interface VideoItem {
+  title: string;
+  play: number;
+  like: number;
+  created: number;
+  bvid: string;
+}
+
+interface UserVideosResponse {
+  data: {
+    list: {
+      vlist: VideoItem[];
+    };
+  };
+}
+
+cli({
+  site: "bilibili",
+  name: "user-videos",
+  description: "List videos published by a Bilibili user",
+  domain: "api.bilibili.com",
+  strategy: Strategy.COOKIE,
+  args: [
+    {
+      name: "mid",
+      required: true,
+      positional: true,
+      description: "User mid (numeric ID)",
+    },
+    {
+      name: "limit",
+      type: "int",
+      default: 20,
+      description: "Number of videos",
+    },
+  ],
+  columns: ["title", "play", "likes", "created", "bvid"],
+  func: async (_page, kwargs) => {
+    const mid = String(kwargs.mid);
+    const limit = Number(kwargs.limit) || 20;
+
+    const json = (await wbiFetch(
+      "https://api.bilibili.com/x/space/wbi/arc/search",
+      {
+        mid,
+        pn: "1",
+        ps: String(limit),
+        order: "pubdate",
+      },
+    )) as UserVideosResponse;
+
+    return (json.data.list.vlist ?? []).map((item) => ({
+      title: item.title,
+      play: item.play,
+      likes: item.like,
+      created: item.created,
+      bvid: item.bvid,
+    }));
+  },
+});

package/src/adapters/bilibili/wbi.ts

@@ -0,0 +1,92 @@
+/**
+ * WBI signing utility for Bilibili API requests.
+ *
+ * Bilibili's WBI mechanism signs query parameters with a rotating key
+ * derived from the nav API. Keys are cached for 10 minutes.
+ */
+
+import { createHash } from "node:crypto";
+import { loadCookies, formatCookieHeader } from "../../engine/cookies.js";
+import { USER_AGENT } from "../../constants.js";
+
+const MIXIN_KEY_ENC_TAB = [
+  46, 47, 18, 2, 53, 8, 23, 32, 15, 50, 10, 31, 58, 3, 45, 35, 27, 43, 5, 49,
+  33, 9, 42, 19, 29, 28, 14, 39, 12, 38, 41, 13, 37, 48, 7, 16, 24, 55, 40, 61,
+  26, 17, 0, 1, 60, 51, 30, 4, 22, 25, 54, 21, 56, 59, 6, 63, 57, 62, 11, 36,
+  20, 34, 44, 52,
+];
+
+let cachedMixinKey: string | null = null;
+let cachedAt = 0;
+const CACHE_TTL = 10 * 60 * 1000;
+
+function getMixinKey(imgKey: string, subKey: string): string {
+  const raw = imgKey + subKey;
+  return MIXIN_KEY_ENC_TAB.map((i) => raw[i])
+    .join("")
+    .slice(0, 32);
+}
+
+async function fetchWbiKeys(): Promise<string> {
+  const now = Date.now();
+  if (cachedMixinKey && now - cachedAt < CACHE_TTL) return cachedMixinKey;
+
+  const cookies = loadCookies("bilibili");
+  const headers: Record<string, string> = { "User-Agent": USER_AGENT };
+  if (cookies) headers["Cookie"] = formatCookieHeader(cookies);
+
+  const resp = await fetch("https://api.bilibili.com/x/web-interface/nav", {
+    headers,
+  });
+  const json = (await resp.json()) as {
+    data: { wbi_img: { img_url: string; sub_url: string } };
+  };
+
+  const imgKey = json.data.wbi_img.img_url.split("/").pop()!.split(".")[0];
+  const subKey = json.data.wbi_img.sub_url.split("/").pop()!.split(".")[0];
+
+  cachedMixinKey = getMixinKey(imgKey, subKey);
+  cachedAt = now;
+  return cachedMixinKey;
+}
+
+/** Sign query parameters with WBI and return the full query string. */
+export async function signWbi(params: Record<string, string>): Promise<string> {
+  const mixinKey = await fetchWbiKeys();
+  const wts = Math.floor(Date.now() / 1000);
+  const signed: Record<string, string> = { ...params, wts: String(wts) };
+
+  const sorted = Object.keys(signed).sort();
+  const query = sorted
+    .map((k) => `${encodeURIComponent(k)}=${encodeURIComponent(signed[k])}`)
+    .join("&");
+
+  const wRid = createHash("md5")
+    .update(query + mixinKey)
+    .digest("hex");
+
+  return query + "&w_rid=" + wRid;
+}
+
+/** Fetch a Bilibili API endpoint with WBI-signed parameters. */
+export async function wbiFetch(
+  baseUrl: string,
+  params: Record<string, string>,
+): Promise<unknown> {
+  const query = await signWbi(params);
+  const url = `${baseUrl}?${query}`;
+
+  const cookies = loadCookies("bilibili");
+  const headers: Record<string, string> = {
+    "User-Agent": USER_AGENT,
+    Accept: "application/json",
+    Referer: "https://www.bilibili.com",
+  };
+  if (cookies) headers["Cookie"] = formatCookieHeader(cookies);
+
+  const resp = await fetch(url, { headers });
+  if (!resp.ok) {
+    throw new Error(`Bilibili API error: ${resp.status} ${resp.statusText}`);
+  }
+  return resp.json();
+}

package/src/adapters/blender/animation.yaml

@@ -0,0 +1,51 @@
+# Desktop adapter — renders an animation frame range from a .blend file via headless CLI
+site: blender
+name: animation
+description: Render an animation range from a Blender file to an output directory
+type: desktop
+binary: blender
+detect: which blender
+timeout: 600000
+
+args:
+  file:
+    type: str
+    required: true
+    positional: true
+    description: Path to .blend file
+  output:
+    type: str
+    required: true
+    description: Output path pattern (e.g. /tmp/frame_####.png)
+  engine:
+    type: str
+    default: CYCLES
+    choices: [CYCLES, EEVEE, WORKBENCH]
+    description: Render engine
+  start:
+    type: int
+    default: 1
+    description: Start frame
+  end:
+    type: int
+    default: 250
+    description: End frame
+
+execArgs:
+  - -b
+  - ${{ args.file }}
+  - --engine
+  - ${{ args.engine }}
+  - --render-output
+  - ${{ args.output }}
+  - -s
+  - ${{ args.start }}
+  - -e
+  - ${{ args.end }}
+  - --render-anim
+
+pipeline:
+  - exec:
+      command: blender
+      args: ${{ execArgs }}
+      parse: text

package/src/adapters/blender/camera.yaml

@@ -0,0 +1,43 @@
+# Desktop adapter — list cameras and their settings in a Blender file
+site: blender
+name: camera
+description: List all cameras and their properties (focal length, sensor, clipping)
+type: desktop
+binary: blender
+detect: which blender
+
+args:
+  file:
+    type: str
+    required: true
+    positional: true
+    description: Path to .blend file
+
+pipeline:
+  - exec:
+      command: blender
+      args:
+        - -b
+        - ${{ args.file }}
+        - --python-expr
+        - |
+          import bpy, json
+          cameras = []
+          for obj in bpy.data.objects:
+              if obj.type != "CAMERA":
+                  continue
+              cam = obj.data
+              cameras.append({
+                  "name": obj.name,
+                  "type": cam.type,
+                  "focal_length": round(cam.lens, 2),
+                  "sensor_width": round(cam.sensor_width, 2),
+                  "clip_start": cam.clip_start,
+                  "clip_end": cam.clip_end,
+                  "location": [round(obj.location.x, 3), round(obj.location.y, 3), round(obj.location.z, 3)],
+              })
+          active = bpy.context.scene.camera.name if bpy.context.scene.camera else None
+          print("UNICLI_JSON:" + json.dumps({"cameras": cameras, "active": active, "count": len(cameras)}))
+      parse: text
+
+columns: [cameras, active, count]

package/src/adapters/blender/convert.yaml

@@ -0,0 +1,36 @@
+# Desktop adapter — converts a Blender scene to another 3D format via headless Python
+site: blender
+name: convert
+description: Convert a .blend file to another 3D format (fbx, obj, stl, gltf, blend)
+type: desktop
+binary: blender
+detect: which blender
+timeout: 120000
+
+args:
+  input:
+    type: str
+    required: true
+    positional: true
+    description: Path to source .blend file
+  output:
+    type: str
+    required: true
+    description: Output file path
+  format:
+    type: str
+    default: fbx
+    choices: [fbx, obj, stl, gltf, blend]
+    description: Export format
+
+execArgs:
+  - -b
+  - ${{ args.input }}
+  - --python-expr
+  - "import bpy;fmt='${{ args.format }}';o='${{ args.output }}';{'fbx':lambda:bpy.ops.export_scene.fbx(filepath=o),'obj':lambda:bpy.ops.export_scene.obj(filepath=o),'stl':lambda:bpy.ops.export_mesh.stl(filepath=o),'gltf':lambda:bpy.ops.export_scene.gltf(filepath=o),'blend':lambda:bpy.ops.wm.save_as_mainfile(filepath=o)}[fmt]()"
+
+pipeline:
+  - exec:
+      command: blender
+      args: ${{ execArgs }}
+      parse: text

package/src/adapters/blender/export.yaml

@@ -0,0 +1,54 @@
+# Desktop adapter — export selected objects from a Blender scene
+site: blender
+name: export
+description: Export all objects from a Blender file to a specified format
+type: desktop
+binary: blender
+detect: which blender
+timeout: 120000
+
+args:
+  input:
+    type: str
+    required: true
+    positional: true
+    description: Path to .blend file
+  output:
+    type: str
+    required: true
+    description: Output file path
+  format:
+    type: str
+    default: fbx
+    choices: [fbx, obj, stl, gltf, glb, abc, usd]
+    description: Export format
+
+pipeline:
+  - exec:
+      command: blender
+      args:
+        - -b
+        - ${{ args.input }}
+        - --python-expr
+        - |
+          import bpy, json, os
+          fmt = "${{ args.format }}"
+          out = "${{ args.output }}"
+          os.makedirs(os.path.dirname(os.path.abspath(out)) or ".", exist_ok=True)
+          bpy.ops.object.select_all(action='SELECT')
+          exporters = {
+              "fbx": lambda: bpy.ops.export_scene.fbx(filepath=out, use_selection=True),
+              "obj": lambda: bpy.ops.wm.obj_export(filepath=out, export_selected_objects=True),
+              "stl": lambda: bpy.ops.export_mesh.stl(filepath=out, use_selection=True),
+              "gltf": lambda: bpy.ops.export_scene.gltf(filepath=out, use_selection=True, export_format="GLTF_SEPARATE"),
+              "glb": lambda: bpy.ops.export_scene.gltf(filepath=out, use_selection=True, export_format="GLB"),
+              "abc": lambda: bpy.ops.wm.alembic_export(filepath=out, selected=True),
+              "usd": lambda: bpy.ops.wm.usd_export(filepath=out, selected_objects_only=True),
+          }
+          exporters[fmt]()
+          size = os.path.getsize(out)
+          print("UNICLI_JSON:" + json.dumps({"output": out, "format": fmt, "file_size": size}))
+      parse: text
+      timeout: 120000
+
+columns: [output, format, file_size]

package/src/adapters/blender/import.yaml

@@ -0,0 +1,55 @@
+# Desktop adapter — import a 3D file into a new Blender document
+site: blender
+name: import
+description: Import a 3D file (FBX, OBJ, STL, GLTF) into a Blender file
+type: desktop
+binary: blender
+detect: which blender
+timeout: 120000
+
+args:
+  input:
+    type: str
+    required: true
+    positional: true
+    description: Path to 3D file to import
+  output:
+    type: str
+    required: true
+    description: Output .blend file path
+
+pipeline:
+  - exec:
+      command: blender
+      args:
+        - -b
+        - --python-expr
+        - |
+          import bpy, json, os
+          inp = "${{ args.input }}"
+          out = "${{ args.output }}"
+          ext = os.path.splitext(inp)[1].lower()
+          os.makedirs(os.path.dirname(os.path.abspath(out)) or ".", exist_ok=True)
+          for obj in bpy.data.objects:
+              bpy.data.objects.remove(obj)
+          importers = {
+              ".fbx": lambda: bpy.ops.import_scene.fbx(filepath=inp),
+              ".obj": lambda: bpy.ops.wm.obj_import(filepath=inp),
+              ".stl": lambda: bpy.ops.import_mesh.stl(filepath=inp),
+              ".gltf": lambda: bpy.ops.import_scene.gltf(filepath=inp),
+              ".glb": lambda: bpy.ops.import_scene.gltf(filepath=inp),
+              ".abc": lambda: bpy.ops.wm.alembic_import(filepath=inp),
+              ".usd": lambda: bpy.ops.wm.usd_import(filepath=inp),
+              ".usda": lambda: bpy.ops.wm.usd_import(filepath=inp),
+              ".usdc": lambda: bpy.ops.wm.usd_import(filepath=inp),
+          }
+          if ext in importers:
+              importers[ext]()
+          count = len(bpy.data.objects)
+          bpy.ops.wm.save_as_mainfile(filepath=out)
+          size = os.path.getsize(out)
+          print("UNICLI_JSON:" + json.dumps({"output": out, "objects": count, "file_size": size}))
+      parse: text
+      timeout: 120000
+
+columns: [output, objects, file_size]

package/src/adapters/blender/info.yaml

@@ -0,0 +1,26 @@
+# Desktop adapter — extracts scene metadata from a .blend file via headless Python
+site: blender
+name: info
+description: Extract scene metadata from a Blender file (objects, meshes, materials, frames, engine, resolution)
+type: desktop
+binary: blender
+detect: which blender
+
+args:
+  file:
+    type: str
+    required: true
+    positional: true
+    description: Path to .blend file
+
+execArgs:
+  - -b
+  - ${{ args.file }}
+  - --python-expr
+  - "import bpy,json;s=bpy.context.scene;print('UNICLI_JSON:'+json.dumps({'objects':len(bpy.data.objects),'meshes':len(bpy.data.meshes),'materials':len(bpy.data.materials),'frames':[s.frame_start,s.frame_end],'engine':s.render.engine,'resolution':[s.render.resolution_x,s.render.resolution_y]}))"
+
+pipeline:
+  - exec:
+      command: blender
+      args: ${{ execArgs }}
+      parse: text

package/src/adapters/blender/lighting.yaml

@@ -0,0 +1,44 @@
+# Desktop adapter — list lights and their settings in a Blender file
+site: blender
+name: lighting
+description: List all lights and their properties (type, color, energy, shadow)
+type: desktop
+binary: blender
+detect: which blender
+
+args:
+  file:
+    type: str
+    required: true
+    positional: true
+    description: Path to .blend file
+
+pipeline:
+  - exec:
+      command: blender
+      args:
+        - -b
+        - ${{ args.file }}
+        - --python-expr
+        - |
+          import bpy, json
+          lights = []
+          for obj in bpy.data.objects:
+              if obj.type != "LIGHT":
+                  continue
+              light = obj.data
+              entry = {
+                  "name": obj.name,
+                  "type": light.type,
+                  "energy": round(light.energy, 2),
+                  "color": [round(light.color.r, 3), round(light.color.g, 3), round(light.color.b, 3)],
+                  "shadow": light.use_shadow,
+                  "location": [round(obj.location.x, 3), round(obj.location.y, 3), round(obj.location.z, 3)],
+              }
+              if light.type == "SPOT":
+                  entry["spot_size"] = round(light.spot_size, 3)
+              lights.append(entry)
+          print("UNICLI_JSON:" + json.dumps({"lights": lights, "count": len(lights)}))
+      parse: text
+
+columns: [lights, count]

package/src/adapters/blender/materials.yaml

@@ -0,0 +1,37 @@
+# Desktop adapter — list all materials in a Blender file
+site: blender
+name: materials
+description: List all materials and their properties from a Blender file
+type: desktop
+binary: blender
+detect: which blender
+
+args:
+  file:
+    type: str
+    required: true
+    positional: true
+    description: Path to .blend file
+
+pipeline:
+  - exec:
+      command: blender
+      args:
+        - -b
+        - ${{ args.file }}
+        - --python-expr
+        - |
+          import bpy, json
+          materials = []
+          for mat in bpy.data.materials:
+              entry = {"name": mat.name, "users": mat.users, "use_nodes": mat.use_nodes}
+              if mat.use_nodes and mat.node_tree:
+                  entry["nodes"] = len(mat.node_tree.nodes)
+              if hasattr(mat, "diffuse_color"):
+                  c = mat.diffuse_color
+                  entry["color"] = [round(c[0], 3), round(c[1], 3), round(c[2], 3), round(c[3], 3)]
+              materials.append(entry)
+          print("UNICLI_JSON:" + json.dumps({"materials": materials, "count": len(materials)}))
+      parse: text
+
+columns: [materials, count]

package/src/adapters/blender/objects.yaml

@@ -0,0 +1,40 @@
+# Desktop adapter — list all objects in a Blender scene
+site: blender
+name: objects
+description: List all objects (meshes, cameras, lights, empties) in a Blender file
+type: desktop
+binary: blender
+detect: which blender
+
+args:
+  file:
+    type: str
+    required: true
+    positional: true
+    description: Path to .blend file
+
+pipeline:
+  - exec:
+      command: blender
+      args:
+        - -b
+        - ${{ args.file }}
+        - --python-expr
+        - |
+          import bpy, json
+          objects = []
+          for obj in bpy.data.objects:
+              entry = {
+                  "name": obj.name,
+                  "type": obj.type,
+                  "location": [round(obj.location.x, 3), round(obj.location.y, 3), round(obj.location.z, 3)],
+                  "visible": not obj.hide_viewport,
+              }
+              if obj.type == "MESH" and obj.data:
+                  entry["vertices"] = len(obj.data.vertices)
+                  entry["faces"] = len(obj.data.polygons)
+              objects.append(entry)
+          print("UNICLI_JSON:" + json.dumps({"objects": objects, "count": len(objects)}))
+      parse: text
+
+columns: [objects, count]

package/src/adapters/blender/render.yaml

@@ -0,0 +1,43 @@
+# Desktop adapter — renders a Blender scene via headless CLI
+site: blender
+name: render
+description: Render a Blender scene to image
+type: desktop
+binary: blender
+detect: which blender
+
+args:
+  file:
+    type: str
+    required: true
+    positional: true
+    description: Path to .blend file
+  output:
+    type: str
+    default: //output.png
+    description: Output path (// = relative to .blend file)
+  frame:
+    type: int
+    default: 1
+    description: Frame number to render
+  engine:
+    type: str
+    default: CYCLES
+    choices: [CYCLES, EEVEE, WORKBENCH]
+    description: Render engine
+
+execArgs:
+  - --background
+  - ${{ args.file }}
+  - --engine
+  - ${{ args.engine }}
+  - --render-output
+  - ${{ args.output }}
+  - --render-frame
+  - ${{ args.frame }}
+
+pipeline:
+  - exec:
+      command: blender
+      args: ${{ execArgs }}
+      parse: text

package/src/adapters/blender/scene.yaml

@@ -0,0 +1,39 @@
+# Desktop adapter — list scene details from a Blender file
+site: blender
+name: scene
+description: List all scenes, their settings, and world properties
+type: desktop
+binary: blender
+detect: which blender
+
+args:
+  file:
+    type: str
+    required: true
+    positional: true
+    description: Path to .blend file
+
+pipeline:
+  - exec:
+      command: blender
+      args:
+        - -b
+        - ${{ args.file }}
+        - --python-expr
+        - |
+          import bpy, json
+          scenes = []
+          for sc in bpy.data.scenes:
+              scenes.append({
+                  "name": sc.name,
+                  "frames": [sc.frame_start, sc.frame_end],
+                  "fps": sc.render.fps,
+                  "engine": sc.render.engine,
+                  "resolution": [sc.render.resolution_x, sc.render.resolution_y],
+                  "world": sc.world.name if sc.world else None,
+                  "objects": len(sc.objects),
+              })
+          print("UNICLI_JSON:" + json.dumps({"scenes": scenes, "count": len(scenes)}))
+      parse: text
+
+columns: [scenes, count]

package/src/adapters/blender/screenshot.yaml

@@ -0,0 +1,52 @@
+# Desktop adapter — capture a viewport screenshot from a Blender file
+site: blender
+name: screenshot
+description: Capture a viewport render screenshot from a Blender scene
+type: desktop
+binary: blender
+detect: which blender
+timeout: 120000
+
+args:
+  file:
+    type: str
+    required: true
+    positional: true
+    description: Path to .blend file
+  output:
+    type: str
+    required: true
+    description: Output PNG image path
+  width:
+    type: int
+    default: 1920
+    description: Image width
+  height:
+    type: int
+    default: 1080
+    description: Image height
+
+pipeline:
+  - exec:
+      command: blender
+      args:
+        - -b
+        - ${{ args.file }}
+        - --python-expr
+        - |
+          import bpy, json, os
+          out = "${{ args.output }}"
+          os.makedirs(os.path.dirname(os.path.abspath(out)) or ".", exist_ok=True)
+          s = bpy.context.scene
+          s.render.resolution_x = ${{ args.width }}
+          s.render.resolution_y = ${{ args.height }}
+          s.render.resolution_percentage = 100
+          s.render.filepath = out
+          s.render.image_settings.file_format = "PNG"
+          bpy.ops.render.render(write_still=True)
+          size = os.path.getsize(out)
+          print("UNICLI_JSON:" + json.dumps({"output": out, "width": ${{ args.width }}, "height": ${{ args.height }}, "file_size": size}))
+      parse: text
+      timeout: 120000
+
+columns: [output, width, height, file_size]