@zenalexa/unicli 0.207.1

package/src/adapters/yollomi/models.yaml

@@ -0,0 +1,33 @@
+site: yollomi
+name: models
+description: List available Yollomi AI models
+domain: yollomi.com
+strategy: intercept
+browser: true
+
+columns: [model, credits, type, description]
+
+pipeline:
+  - navigate:
+      url: https://yollomi.com
+      settleMs: 2000
+
+  - evaluate: |
+      (() => {
+        return [
+          { model: 'z-image-turbo', credits: 1, type: 'image', description: 'Alibaba Qwen turbo (cheapest)' },
+          { model: 'flux-schnell', credits: 2, type: 'image', description: 'High-speed Flux' },
+          { model: 'ideogram-v3-turbo', credits: 3, type: 'image', description: 'Ideogram V3 Turbo' },
+          { model: 'imagen-4-fast', credits: 3, type: 'image', description: 'Google Imagen 4 Fast' },
+          { model: 'seedream-4-5', credits: 4, type: 'image', description: 'ByteDance Seedream 4.5' },
+          { model: 'flux', credits: 4, type: 'image', description: 'Flux 1.1 Pro' },
+          { model: 'imagen-4-ultra', credits: 6, type: 'image', description: 'Google Imagen 4 Ultra' },
+          { model: 'flux-2-pro', credits: 15, type: 'image', description: 'Flux 2 Pro (premium)' },
+          { model: 'remove-bg', credits: 0, type: 'tool', description: 'Remove background (free)' },
+          { model: 'image-upscaler', credits: 1, type: 'tool', description: 'Enhance resolution' },
+          { model: 'face-swap', credits: 3, type: 'tool', description: 'Swap faces' },
+          { model: 'virtual-try-on', credits: 3, type: 'tool', description: 'Try clothes on photos' },
+          { model: 'object-remover', credits: 3, type: 'tool', description: 'Remove objects' },
+          { model: 'photo-restoration', credits: 4, type: 'tool', description: 'Restore old photos' },
+        ];
+      })()

package/src/adapters/yollomi/object-remover.yaml

@@ -0,0 +1,39 @@
+site: yollomi
+name: object-remover
+description: Remove unwanted objects from image
+domain: yollomi.com
+strategy: intercept
+browser: true
+
+args:
+  image:
+    type: str
+    required: true
+    positional: true
+    description: Image URL
+  mask:
+    type: str
+    required: true
+    positional: true
+    description: Mask image URL (white = remove area)
+
+columns: [status, image_url]
+
+pipeline:
+  - navigate:
+      url: https://yollomi.com
+      settleMs: 3000
+
+  - evaluate: |
+      (async () => {
+        const image = ${{ args.image | json }};
+        const mask = ${{ args.mask | json }};
+        const res = await fetch('/api/ai/object-remover', {
+          method: 'POST', credentials: 'include',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ image, mask }),
+        });
+        if (!res.ok) throw new Error('Object removal failed: HTTP ' + res.status);
+        const data = await res.json();
+        return [{ status: 'success', image_url: data.images?.[0]?.url || data.url || '' }];
+      })()

package/src/adapters/yollomi/remove-bg.yaml

@@ -0,0 +1,33 @@
+site: yollomi
+name: remove-bg
+description: Remove background from image (free)
+domain: yollomi.com
+strategy: intercept
+browser: true
+
+args:
+  image:
+    type: str
+    required: true
+    positional: true
+    description: Image URL or local path
+
+columns: [status, image_url]
+
+pipeline:
+  - navigate:
+      url: https://yollomi.com
+      settleMs: 3000
+
+  - evaluate: |
+      (async () => {
+        const image = ${{ args.image | json }};
+        const res = await fetch('/api/ai/remove-bg', {
+          method: 'POST', credentials: 'include',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ image }),
+        });
+        if (!res.ok) throw new Error('Remove BG failed: HTTP ' + res.status);
+        const data = await res.json();
+        return [{ status: 'success', image_url: data.images?.[0]?.url || data.url || '' }];
+      })()

package/src/adapters/yollomi/restore.yaml

@@ -0,0 +1,33 @@
+site: yollomi
+name: restore
+description: Restore old/damaged photos
+domain: yollomi.com
+strategy: intercept
+browser: true
+
+args:
+  image:
+    type: str
+    required: true
+    positional: true
+    description: Image URL or local path
+
+columns: [status, image_url]
+
+pipeline:
+  - navigate:
+      url: https://yollomi.com
+      settleMs: 3000
+
+  - evaluate: |
+      (async () => {
+        const image = ${{ args.image | json }};
+        const res = await fetch('/api/ai/photo-restoration', {
+          method: 'POST', credentials: 'include',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ image }),
+        });
+        if (!res.ok) throw new Error('Restore failed: HTTP ' + res.status);
+        const data = await res.json();
+        return [{ status: 'success', image_url: data.images?.[0]?.url || data.url || '' }];
+      })()

package/src/adapters/yollomi/try-on.yaml

@@ -0,0 +1,39 @@
+site: yollomi
+name: try-on
+description: Virtual clothing try-on
+domain: yollomi.com
+strategy: intercept
+browser: true
+
+args:
+  person:
+    type: str
+    required: true
+    positional: true
+    description: Person image URL
+  garment:
+    type: str
+    required: true
+    positional: true
+    description: Garment image URL
+
+columns: [status, image_url]
+
+pipeline:
+  - navigate:
+      url: https://yollomi.com
+      settleMs: 3000
+
+  - evaluate: |
+      (async () => {
+        const person = ${{ args.person | json }};
+        const garment = ${{ args.garment | json }};
+        const res = await fetch('/api/ai/virtual-try-on', {
+          method: 'POST', credentials: 'include',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ person_image: person, garment_image: garment }),
+        });
+        if (!res.ok) throw new Error('Try-on failed: HTTP ' + res.status);
+        const data = await res.json();
+        return [{ status: 'success', image_url: data.images?.[0]?.url || data.url || '' }];
+      })()

package/src/adapters/yollomi/upload.yaml

@@ -0,0 +1,27 @@
+site: yollomi
+name: upload
+description: Upload an image to Yollomi for processing
+domain: yollomi.com
+strategy: intercept
+browser: true
+
+args:
+  image:
+    type: str
+    required: true
+    positional: true
+    description: Image URL or local file path
+
+columns: [status, url]
+
+pipeline:
+  - navigate:
+      url: https://yollomi.com
+      settleMs: 3000
+
+  - evaluate: |
+      (async () => {
+        const image = ${{ args.image | json }};
+        if (image.startsWith('http')) return [{ status: 'ready', url: image }];
+        return [{ status: 'note', url: 'Local files must be converted to base64 or uploaded separately. Use a URL instead.' }];
+      })()

package/src/adapters/yollomi/upscale.yaml

@@ -0,0 +1,33 @@
+site: yollomi
+name: upscale
+description: Upscale/enhance image resolution
+domain: yollomi.com
+strategy: intercept
+browser: true
+
+args:
+  image:
+    type: str
+    required: true
+    positional: true
+    description: Image URL or local path
+
+columns: [status, image_url]
+
+pipeline:
+  - navigate:
+      url: https://yollomi.com
+      settleMs: 3000
+
+  - evaluate: |
+      (async () => {
+        const image = ${{ args.image | json }};
+        const res = await fetch('/api/ai/image-upscaler', {
+          method: 'POST', credentials: 'include',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ image }),
+        });
+        if (!res.ok) throw new Error('Upscale failed: HTTP ' + res.status);
+        const data = await res.json();
+        return [{ status: 'success', image_url: data.images?.[0]?.url || data.url || '' }];
+      })()

package/src/adapters/yollomi/video.yaml

@@ -0,0 +1,42 @@
+site: yollomi
+name: video
+description: Generate video with Yollomi AI
+domain: yollomi.com
+strategy: intercept
+browser: true
+
+args:
+  prompt:
+    type: str
+    required: true
+    positional: true
+    description: Video description prompt
+  model:
+    type: str
+    default: wan-2-5-t2v
+    description: "Model: wan-2-5-t2v, kling-2-1, pixverse-5, google-veo-3-fast"
+
+columns: [status, model, video_url]
+
+pipeline:
+  - navigate:
+      url: https://yollomi.com
+      settleMs: 3000
+
+  - evaluate: |
+      (async () => {
+        const prompt = ${{ args.prompt | json }};
+        const model = ${{ args.model | json }};
+        const res = await fetch('/api/ai/video', {
+          method: 'POST', credentials: 'include',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ prompt, model }),
+        });
+        if (!res.ok) {
+          const err = await res.text();
+          throw new Error('Video gen failed: HTTP ' + res.status + ' ' + err.substring(0, 200));
+        }
+        const data = await res.json();
+        const url = data.video?.url || data.output?.url || data.url || '';
+        return [{ status: url ? 'success' : 'processing', model, video_url: url || 'Video is being generated...' }];
+      })()

package/src/adapters/youtube/channel.ts

@@ -0,0 +1,58 @@
+/**
+ * YouTube channel info — retrieve channel metadata by channel ID.
+ *
+ * Uses InnerTube "browse" endpoint with browseId set to the channel ID.
+ */
+
+import { cli, Strategy } from "../../registry.js";
+import { innertubeFetch } from "./innertube.js";
+
+interface ChannelResponse {
+  metadata?: {
+    channelMetadataRenderer?: {
+      title?: string;
+      description?: string;
+      channelUrl?: string;
+    };
+  };
+  header?: {
+    c4TabbedHeaderRenderer?: {
+      subscriberCountText?: { simpleText?: string };
+    };
+  };
+}
+
+cli({
+  site: "youtube",
+  name: "channel",
+  description: "Get YouTube channel info",
+  domain: "www.youtube.com",
+  strategy: Strategy.PUBLIC,
+  args: [
+    {
+      name: "channelId",
+      type: "str",
+      required: true,
+      positional: true,
+      description: "YouTube channel ID (e.g. UCxxxxxx)",
+    },
+  ],
+  columns: ["name", "subscribers", "url"],
+  async func(_page, kwargs) {
+    const channelId = kwargs.channelId as string;
+
+    const data = (await innertubeFetch("browse", {
+      browseId: channelId,
+    })) as ChannelResponse;
+
+    const meta = data.metadata?.channelMetadataRenderer ?? {};
+    const header = data.header?.c4TabbedHeaderRenderer ?? {};
+
+    return {
+      name: meta.title ?? "",
+      subscribers: header.subscriberCountText?.simpleText ?? "",
+      description: meta.description ?? "",
+      url: meta.channelUrl ?? `https://youtube.com/channel/${channelId}`,
+    };
+  },
+});

package/src/adapters/youtube/comments.ts

@@ -0,0 +1,101 @@
+/**
+ * YouTube comments — retrieve top-level comments for a video.
+ *
+ * Uses InnerTube "next" endpoint which returns engagement panels
+ * including the comment section.
+ */
+
+import { cli, Strategy } from "../../registry.js";
+import { innertubeFetch } from "./innertube.js";
+
+interface CommentRenderer {
+  commentRenderer?: {
+    authorText?: { simpleText?: string };
+    contentText?: { runs?: Array<{ text: string }> };
+    voteCount?: { simpleText?: string };
+    replyCount?: number;
+  };
+}
+
+interface CommentSection {
+  itemSectionRenderer?: {
+    contents?: Array<{
+      commentThreadRenderer?: {
+        comment?: CommentRenderer;
+      };
+    }>;
+  };
+}
+
+interface NextEndpoint {
+  reloadContinuationItemsCommand?: {
+    continuationItems?: CommentSection[];
+  };
+  appendContinuationItemsAction?: {
+    continuationItems?: CommentSection[];
+  };
+}
+
+interface NextResponse {
+  onResponseReceivedEndpoints?: NextEndpoint[];
+}
+
+function extractComments(data: NextResponse): Array<Record<string, unknown>> {
+  const endpoints = data.onResponseReceivedEndpoints ?? [];
+  const results: Array<Record<string, unknown>> = [];
+
+  for (const ep of endpoints) {
+    const items =
+      ep.reloadContinuationItemsCommand?.continuationItems ??
+      ep.appendContinuationItemsAction?.continuationItems ??
+      [];
+
+    for (const section of items) {
+      const contents = section.itemSectionRenderer?.contents ?? [];
+      for (const thread of contents) {
+        const c = thread.commentThreadRenderer?.comment?.commentRenderer;
+        if (!c) continue;
+        results.push({
+          author: c.authorText?.simpleText ?? "",
+          text: c.contentText?.runs?.map((r) => r.text).join("") ?? "",
+          likes: c.voteCount?.simpleText ?? "0",
+          replies: c.replyCount ?? 0,
+        });
+      }
+    }
+  }
+
+  return results;
+}
+
+cli({
+  site: "youtube",
+  name: "comments",
+  description: "Get YouTube video comments",
+  domain: "www.youtube.com",
+  strategy: Strategy.PUBLIC,
+  args: [
+    {
+      name: "videoId",
+      type: "str",
+      required: true,
+      positional: true,
+      description: "YouTube video ID",
+    },
+    {
+      name: "limit",
+      type: "int",
+      default: 20,
+      description: "Max comments to return",
+    },
+  ],
+  columns: ["author", "text", "likes", "replies"],
+  async func(_page, kwargs) {
+    const videoId = kwargs.videoId as string;
+    const limit = (kwargs.limit as number) ?? 20;
+
+    const data = (await innertubeFetch("next", { videoId })) as NextResponse;
+
+    return extractComments(data).slice(0, limit);
+  },
+});

package/src/adapters/youtube/innertube.ts

@@ -0,0 +1,36 @@
+/**
+ * YouTube InnerTube client — low-level API wrapper for YouTube's internal API.
+ *
+ * InnerTube is YouTube's internal RPC layer. Public endpoints don't require
+ * authentication for most read operations (search, player, browse, next).
+ */
+
+import { USER_AGENT } from "../../constants.js";
+
+const INNERTUBE_API_KEY = "AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8";
+const INNERTUBE_CLIENT = {
+  clientName: "WEB",
+  clientVersion: "2.20240101.00.00",
+  hl: "en",
+  gl: "US",
+};
+
+export async function innertubeFetch(
+  endpoint: string,
+  body: Record<string, unknown>,
+): Promise<unknown> {
+  const url = `https://www.youtube.com/youtubei/v1/${endpoint}?key=${INNERTUBE_API_KEY}&prettyPrint=false`;
+  const resp = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "User-Agent": USER_AGENT,
+    },
+    body: JSON.stringify({
+      context: { client: INNERTUBE_CLIENT },
+      ...body,
+    }),
+  });
+  if (!resp.ok) throw new Error(`YouTube API error: ${resp.status}`);
+  return resp.json();
+}

package/src/adapters/youtube/search.ts

@@ -0,0 +1,90 @@
+/**
+ * YouTube search — find videos by query.
+ *
+ * Uses InnerTube "search" endpoint with EgIQAQ%3D%3D param (video filter).
+ */
+
+import { cli, Strategy } from "../../registry.js";
+import { innertubeFetch } from "./innertube.js";
+
+interface VideoRenderer {
+  videoId?: string;
+  title?: { runs?: Array<{ text: string }> };
+  ownerText?: { runs?: Array<{ text: string }> };
+  viewCountText?: { simpleText?: string };
+}
+
+interface SectionContent {
+  itemSectionRenderer?: {
+    contents?: Array<{ videoRenderer?: VideoRenderer }>;
+  };
+}
+
+interface SearchResponse {
+  contents?: {
+    twoColumnSearchResultsRenderer?: {
+      primaryContents?: {
+        sectionListRenderer?: {
+          contents?: SectionContent[];
+        };
+      };
+    };
+  };
+}
+
+function extractVideos(data: SearchResponse): Array<Record<string, unknown>> {
+  const sections =
+    data.contents?.twoColumnSearchResultsRenderer?.primaryContents
+      ?.sectionListRenderer?.contents ?? [];
+
+  const items = sections[0]?.itemSectionRenderer?.contents ?? [];
+
+  return items
+    .filter((item) => item.videoRenderer?.videoId)
+    .map((item) => {
+      const v = item.videoRenderer!;
+      const videoId = v.videoId ?? "";
+      return {
+        title: v.title?.runs?.map((r) => r.text).join("") ?? "",
+        channel: v.ownerText?.runs?.[0]?.text ?? "",
+        views: v.viewCountText?.simpleText ?? "",
+        videoId,
+        url: `https://youtube.com/watch?v=${videoId}`,
+      };
+    });
+}
+
+cli({
+  site: "youtube",
+  name: "search",
+  description: "Search YouTube videos",
+  domain: "www.youtube.com",
+  strategy: Strategy.PUBLIC,
+  args: [
+    {
+      name: "query",
+      type: "str",
+      required: true,
+      positional: true,
+      description: "Search query",
+    },
+    {
+      name: "limit",
+      type: "int",
+      default: 10,
+      description: "Max results to return",
+    },
+  ],
+  columns: ["title", "channel", "views", "videoId"],
+  async func(_page, kwargs) {
+    const query = kwargs.query as string;
+    const limit = (kwargs.limit as number) ?? 10;
+
+    const data = (await innertubeFetch("search", {
+      query,
+      params: "EgIQAQ%3D%3D", // video filter
+    })) as SearchResponse;
+
+    return extractVideos(data).slice(0, limit);
+  },
+});

package/src/adapters/youtube/transcript.ts

@@ -0,0 +1,121 @@
+/**
+ * YouTube transcript — retrieve video subtitles/captions.
+ *
+ * Strategy:
+ *   1. Use InnerTube "player" endpoint to get caption track URLs
+ *   2. Fetch the timedtext XML from the caption URL
+ *   3. Parse XML segments into { start, duration, text } entries
+ */
+
+import { USER_AGENT } from "../../constants.js";
+import { cli, Strategy } from "../../registry.js";
+import { innertubeFetch } from "./innertube.js";
+
+interface CaptionTrack {
+  baseUrl?: string;
+  languageCode?: string;
+  name?: { simpleText?: string };
+}
+
+interface PlayerCaptionsResponse {
+  captions?: {
+    playerCaptionsTracklistRenderer?: {
+      captionTracks?: CaptionTrack[];
+    };
+  };
+}
+
+interface TranscriptSegment {
+  start: string;
+  duration: string;
+  text: string;
+}
+
+/** Parse timedtext XML into transcript segments */
+function parseTimedTextXml(xml: string): TranscriptSegment[] {
+  const segments: TranscriptSegment[] = [];
+  const regex =
+    /<text\s+start="([^"]*)"(?:\s+dur="([^"]*)")?[^>]*>([\s\S]*?)<\/text>/g;
+  let match: RegExpExecArray | null;
+
+  while ((match = regex.exec(xml)) !== null) {
+    const text = (match[3] ?? "")
+      .replace(/&amp;/g, "&")
+      .replace(/&lt;/g, "<")
+      .replace(/&gt;/g, ">")
+      .replace(/&quot;/g, '"')
+      .replace(/&#39;/g, "'")
+      .replace(/<[^>]+>/g, "") // strip inline tags like <font>
+      .trim();
+
+    if (text) {
+      segments.push({
+        start: match[1] ?? "0",
+        duration: match[2] ?? "0",
+        text,
+      });
+    }
+  }
+
+  return segments;
+}
+
+cli({
+  site: "youtube",
+  name: "transcript",
+  description: "Get YouTube video transcript/subtitles",
+  domain: "www.youtube.com",
+  strategy: Strategy.PUBLIC,
+  args: [
+    {
+      name: "videoId",
+      type: "str",
+      required: true,
+      positional: true,
+      description: "YouTube video ID",
+    },
+    {
+      name: "lang",
+      type: "str",
+      default: "en",
+      description: "Language code (e.g. en, zh, ja)",
+    },
+  ],
+  columns: ["start", "duration", "text"],
+  async func(_page, kwargs) {
+    const videoId = kwargs.videoId as string;
+    const lang = (kwargs.lang as string) ?? "en";
+
+    // Step 1: Get caption tracks from player endpoint
+    const playerData = (await innertubeFetch("player", {
+      videoId,
+    })) as PlayerCaptionsResponse;
+
+    const tracks =
+      playerData.captions?.playerCaptionsTracklistRenderer?.captionTracks ?? [];
+
+    if (tracks.length === 0) {
+      throw new Error(`No captions available for video ${videoId}`);
+    }
+
+    // Step 2: Find matching language track, fall back to first available
+    const track = tracks.find((t) => t.languageCode === lang) ?? tracks[0]!;
+
+    const captionUrl = track.baseUrl;
+    if (!captionUrl) {
+      throw new Error("Caption track has no URL");
+    }
+
+    // Step 3: Fetch timedtext XML
+    const resp = await fetch(captionUrl, {
+      headers: { "User-Agent": USER_AGENT },
+    });
+    if (!resp.ok) {
+      throw new Error(`Failed to fetch captions: ${resp.status}`);
+    }
+    const xml = await resp.text();
+
+    // Step 4: Parse and return segments
+    return parseTimedTextXml(xml);
+  },
+});