@jackwener/opencli 0.9.6 → 1.0.0

package/dist/clis/discord-app/members.js

@@ -0,0 +1,38 @@
+import { cli, Strategy } from '../../registry.js';
+export const membersCommand = cli({
+    site: 'discord-app',
+    name: 'members',
+    description: 'List online members in the current Discord channel',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [],
+    columns: ['Index', 'Name', 'Status'],
+    func: async (page) => {
+        const members = await page.evaluate(`
+      (function() {
+        const results = [];
+        // Discord member list sidebar
+        const items = document.querySelectorAll('[class*="member_"], [data-list-item-id*="members"]');
+        
+        items.forEach((item, i) => {
+          const nameEl = item.querySelector('[class*="username_"], [class*="nameTag"]');
+          const statusEl = item.querySelector('[class*="activity"], [class*="customStatus"]');
+          
+          const name = nameEl ? nameEl.textContent.trim() : (item.textContent || '').trim().substring(0, 50);
+          const status = statusEl ? statusEl.textContent.trim() : '';
+          
+          if (name && name.length > 0) {
+            results.push({ Index: i + 1, Name: name, Status: status || 'Online' });
+          }
+        });
+        
+        return results.slice(0, 50); // Limit to 50
+      })()
+    `);
+        if (members.length === 0) {
+            return [{ Index: 0, Name: 'No members visible', Status: 'Toggle member list first' }];
+        }
+        return members;
+    },
+});

package/dist/clis/discord-app/read.d.ts

@@ -0,0 +1 @@
+export declare const readCommand: import("../../registry.js").CliCommand;

package/dist/clis/discord-app/read.js

@@ -0,0 +1,45 @@
+import { cli, Strategy } from '../../registry.js';
+export const readCommand = cli({
+    site: 'discord-app',
+    name: 'read',
+    description: 'Read recent messages from the active Discord channel',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [
+        { name: 'count', required: false, help: 'Number of messages to read (default: 20)', default: '20' },
+    ],
+    columns: ['Author', 'Time', 'Message'],
+    func: async (page, kwargs) => {
+        const count = parseInt(kwargs.count, 10) || 20;
+        const messages = await page.evaluate(`
+      (function(limit) {
+        const results = [];
+        // Discord renders messages in list items with id starting with "chat-messages-"
+        const msgNodes = document.querySelectorAll('[id^="chat-messages-"] > div, [class*="messageListItem"]');
+        
+        const slice = Array.from(msgNodes).slice(-limit);
+        
+        slice.forEach(node => {
+          const authorEl = node.querySelector('[class*="username"], [class*="headerText"] span');
+          const timeEl = node.querySelector('time');
+          const contentEl = node.querySelector('[id^="message-content-"], [class*="messageContent"]');
+          
+          if (contentEl) {
+            results.push({
+              Author: authorEl ? authorEl.textContent.trim() : '—',
+              Time: timeEl ? timeEl.getAttribute('datetime') || timeEl.textContent.trim() : '',
+              Message: (contentEl.textContent || '').trim().substring(0, 300),
+            });
+          }
+        });
+        
+        return results;
+      })(${count})
+    `);
+        if (messages.length === 0) {
+            return [{ Author: 'System', Time: '', Message: 'No messages found in the current channel.' }];
+        }
+        return messages;
+    },
+});

package/dist/clis/discord-app/search.d.ts

@@ -0,0 +1 @@
+export declare const searchCommand: import("../../registry.js").CliCommand;

package/dist/clis/discord-app/search.js

@@ -0,0 +1,56 @@
+import { cli, Strategy } from '../../registry.js';
+export const searchCommand = cli({
+    site: 'discord-app',
+    name: 'search',
+    description: 'Search messages in the current Discord server/channel (Cmd+F)',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [{ name: 'query', required: true, positional: true, help: 'Search query' }],
+    columns: ['Index', 'Author', 'Message'],
+    func: async (page, kwargs) => {
+        const query = kwargs.query;
+        // Open search with Cmd+F
+        const isMac = process.platform === 'darwin';
+        await page.pressKey(isMac ? 'Meta+F' : 'Control+F');
+        await page.wait(0.5);
+        // Type query into search box
+        await page.evaluate(`
+      (function(q) {
+        const input = document.querySelector('[aria-label*="Search"], [class*="searchBar"] input, [placeholder*="Search"]');
+        if (!input) throw new Error('Search input not found');
+        input.focus();
+        const setter = Object.getOwnPropertyDescriptor(window.HTMLInputElement.prototype, 'value').set;
+        setter.call(input, q);
+        input.dispatchEvent(new Event('input', { bubbles: true }));
+      })(${JSON.stringify(query)})
+    `);
+        await page.pressKey('Enter');
+        await page.wait(2);
+        // Scrape search results
+        const results = await page.evaluate(`
+      (function() {
+        const items = [];
+        const resultNodes = document.querySelectorAll('[class*="searchResult_"], [id*="search-result"]');
+        
+        resultNodes.forEach((node, i) => {
+          const author = node.querySelector('[class*="username"]')?.textContent?.trim() || '—';
+          const content = node.querySelector('[id^="message-content-"], [class*="messageContent"]')?.textContent?.trim() || node.textContent?.trim();
+          items.push({
+            Index: i + 1,
+            Author: author,
+            Message: (content || '').substring(0, 200),
+          });
+        });
+        
+        return items;
+      })()
+    `);
+        // Close search
+        await page.pressKey('Escape');
+        if (results.length === 0) {
+            return [{ Index: 0, Author: 'System', Message: `No results for "${query}"` }];
+        }
+        return results;
+    },
+});

package/dist/clis/discord-app/send.d.ts

@@ -0,0 +1 @@
+export declare const sendCommand: import("../../registry.js").CliCommand;

package/dist/clis/discord-app/send.js

@@ -0,0 +1,27 @@
+import { cli, Strategy } from '../../registry.js';
+export const sendCommand = cli({
+    site: 'discord-app',
+    name: 'send',
+    description: 'Send a message in the active Discord channel',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [{ name: 'text', required: true, positional: true, help: 'Message to send' }],
+    columns: ['Status'],
+    func: async (page, kwargs) => {
+        const text = kwargs.text;
+        await page.evaluate(`
+      (function(text) {
+        // Discord uses a Slate-based editor with [data-slate-editor="true"] or role="textbox"
+        const editor = document.querySelector('[role="textbox"][data-slate-editor="true"], [class*="slateTextArea"]');
+        if (!editor) throw new Error('Could not find Discord message input. Make sure a channel is open.');
+        
+        editor.focus();
+        document.execCommand('insertText', false, text);
+      })(${JSON.stringify(text)})
+    `);
+        await page.wait(0.3);
+        await page.pressKey('Enter');
+        return [{ Status: 'Success' }];
+    },
+});

package/dist/clis/discord-app/servers.d.ts

@@ -0,0 +1 @@
+export declare const serversCommand: import("../../registry.js").CliCommand;

package/dist/clis/discord-app/servers.js

@@ -0,0 +1,36 @@
+import { cli, Strategy } from '../../registry.js';
+export const serversCommand = cli({
+    site: 'discord-app',
+    name: 'servers',
+    description: 'List all Discord servers (guilds) in the sidebar',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [],
+    columns: ['Index', 'Server'],
+    func: async (page) => {
+        const servers = await page.evaluate(`
+      (function() {
+        const results = [];
+        // Discord guild icons in the sidebar
+        const items = document.querySelectorAll('[data-list-item-id*="guildsnav___"], [class*="listItem_"]');
+        
+        items.forEach((item, i) => {
+          const nameAttr = item.querySelector('[data-dnd-name]');
+          const ariaLabel = item.getAttribute('aria-label') || (item.querySelector('[aria-label]') || {}).getAttribute?.('aria-label');
+          const name = nameAttr ? nameAttr.getAttribute('data-dnd-name') : (ariaLabel || (item.textContent || '').trim());
+          
+          if (name && name.length > 0) {
+            results.push({ Index: i + 1, Server: name.substring(0, 80) });
+          }
+        });
+        
+        return results;
+      })()
+    `);
+        if (servers.length === 0) {
+            return [{ Index: 0, Server: 'No servers found' }];
+        }
+        return servers;
+    },
+});

package/dist/clis/discord-app/status.d.ts

@@ -0,0 +1 @@
+export declare const statusCommand: import("../../registry.js").CliCommand;

package/dist/clis/discord-app/status.js

@@ -0,0 +1,16 @@
+import { cli, Strategy } from '../../registry.js';
+export const statusCommand = cli({
+    site: 'discord-app',
+    name: 'status',
+    description: 'Check active CDP connection to Discord Desktop',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [],
+    columns: ['Status', 'Url', 'Title'],
+    func: async (page) => {
+        const url = await page.evaluate('window.location.href');
+        const title = await page.evaluate('document.title');
+        return [{ Status: 'Connected', Url: url, Title: title }];
+    },
+});

package/dist/clis/feishu/new.d.ts

@@ -0,0 +1 @@
+export declare const newCommand: import("../../registry.js").CliCommand;

package/dist/clis/feishu/new.js

@@ -0,0 +1,27 @@
+import { execSync } from 'node:child_process';
+import { cli, Strategy } from '../../registry.js';
+export const newCommand = cli({
+    site: 'feishu',
+    name: 'new',
+    description: 'Create a new message or document in Feishu',
+    domain: 'localhost',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [],
+    columns: ['Status'],
+    func: async (page) => {
+        try {
+            execSync("osascript -e 'tell application \"Lark\" to activate'");
+            execSync("osascript -e 'delay 0.3'");
+            // Cmd+N for new conversation/document
+            execSync("osascript " +
+                "-e 'tell application \"System Events\"' " +
+                "-e 'keystroke \"n\" using command down' " +
+                "-e 'end tell'");
+            return [{ Status: 'New item dialog opened (Cmd+N)' }];
+        }
+        catch (err) {
+            return [{ Status: 'Error: ' + err.message }];
+        }
+    },
+});

package/dist/clis/feishu/read.d.ts

@@ -0,0 +1 @@
+export declare const readCommand: import("../../registry.js").CliCommand;

package/dist/clis/feishu/read.js

@@ -0,0 +1,40 @@
+import { execSync, spawnSync } from 'node:child_process';
+import { cli, Strategy } from '../../registry.js';
+export const readCommand = cli({
+    site: 'feishu',
+    name: 'read',
+    description: 'Read the current chat content by selecting all and copying',
+    domain: 'localhost',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [],
+    columns: ['Content'],
+    func: async (page) => {
+        try {
+            let clipBackup = '';
+            try {
+                clipBackup = execSync('pbpaste', { encoding: 'utf-8' });
+            }
+            catch { /* empty */ }
+            execSync("osascript -e 'tell application \"Lark\" to activate'");
+            execSync("osascript -e 'delay 0.3'");
+            execSync("osascript " +
+                "-e 'tell application \"System Events\"' " +
+                "-e 'keystroke \"a\" using command down' " +
+                "-e 'delay 0.2' " +
+                "-e 'keystroke \"c\" using command down' " +
+                "-e 'delay 0.2' " +
+                "-e 'end tell'");
+            const content = execSync('pbpaste', { encoding: 'utf-8' }).trim();
+            if (clipBackup) {
+                spawnSync('pbcopy', { input: clipBackup });
+            }
+            // Deselect
+            execSync("osascript -e 'tell application \"System Events\" to key code 53'");
+            return [{ Content: content || '(no content captured)' }];
+        }
+        catch (err) {
+            return [{ Content: 'Error: ' + err.message }];
+        }
+    },
+});

package/dist/clis/feishu/search.d.ts

@@ -0,0 +1 @@
+export declare const searchCommand: import("../../registry.js").CliCommand;

package/dist/clis/feishu/search.js

@@ -0,0 +1,30 @@
+import { execSync } from 'node:child_process';
+import { cli, Strategy } from '../../registry.js';
+export const searchCommand = cli({
+    site: 'feishu',
+    name: 'search',
+    description: 'Open Feishu global search and type a query (Cmd+K)',
+    domain: 'localhost',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [{ name: 'query', required: true, positional: true, help: 'Search query' }],
+    columns: ['Status'],
+    func: async (page, kwargs) => {
+        const query = kwargs.query;
+        try {
+            execSync("osascript -e 'tell application \"Lark\" to activate'");
+            execSync("osascript -e 'delay 0.3'");
+            // Feishu uses Cmd+K for global search (similar to Slack/Notion)
+            execSync("osascript " +
+                "-e 'tell application \"System Events\"' " +
+                "-e 'keystroke \"k\" using command down' " +
+                "-e 'delay 0.5' " +
+                `-e 'keystroke ${JSON.stringify(query)}' ` +
+                "-e 'end tell'");
+            return [{ Status: `Searching for: ${query}` }];
+        }
+        catch (err) {
+            return [{ Status: 'Error: ' + err.message }];
+        }
+    },
+});

package/dist/clis/feishu/send.d.ts

@@ -0,0 +1 @@
+export declare const sendCommand: import("../../registry.js").CliCommand;

package/dist/clis/feishu/send.js

@@ -0,0 +1,39 @@
+import { execSync, spawnSync } from 'node:child_process';
+import { cli, Strategy } from '../../registry.js';
+export const sendCommand = cli({
+    site: 'feishu',
+    name: 'send',
+    description: 'Send a message in the active Feishu (Lark) conversation',
+    domain: 'localhost',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [{ name: 'text', required: true, positional: true, help: 'Message to send' }],
+    columns: ['Status'],
+    func: async (page, kwargs) => {
+        const text = kwargs.text;
+        try {
+            // Backup clipboard
+            let clipBackup = '';
+            try {
+                clipBackup = execSync('pbpaste', { encoding: 'utf-8' });
+            }
+            catch { /* empty */ }
+            spawnSync('pbcopy', { input: text });
+            execSync("osascript -e 'tell application \"Lark\" to activate'");
+            execSync("osascript -e 'delay 0.5'");
+            execSync("osascript " +
+                "-e 'tell application \"System Events\"' " +
+                "-e 'keystroke \"v\" using command down' " +
+                "-e 'delay 0.2' " +
+                "-e 'keystroke return' " +
+                "-e 'end tell'");
+            if (clipBackup) {
+                spawnSync('pbcopy', { input: clipBackup });
+            }
+            return [{ Status: 'Success' }];
+        }
+        catch (err) {
+            return [{ Status: 'Error: ' + err.message }];
+        }
+    },
+});

package/dist/clis/feishu/status.d.ts

@@ -0,0 +1 @@
+export declare const statusCommand: import("../../registry.js").CliCommand;

package/dist/clis/feishu/status.js

@@ -0,0 +1,28 @@
+import { execSync } from 'node:child_process';
+import { cli, Strategy } from '../../registry.js';
+export const statusCommand = cli({
+    site: 'feishu',
+    name: 'status',
+    description: 'Check if Feishu (Lark) Desktop is running on macOS',
+    domain: 'localhost',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [],
+    columns: ['Status', 'Detail'],
+    func: async (page) => {
+        try {
+            const running = execSync("osascript -e 'application \"Lark\" is running'", { encoding: 'utf-8' }).trim();
+            if (running !== 'true') {
+                return [{ Status: 'Stopped', Detail: 'Feishu/Lark is not running' }];
+            }
+            const windowCount = execSync("osascript -e 'tell application \"System Events\" to count windows of application process \"Lark\"'", { encoding: 'utf-8' }).trim();
+            return [{
+                    Status: 'Running',
+                    Detail: `${windowCount} window(s) open`,
+                }];
+        }
+        catch (err) {
+            return [{ Status: 'Error', Detail: err.message }];
+        }
+    },
+});

package/dist/clis/grok/ask.d.ts

@@ -0,0 +1 @@
+export declare const askCommand: import("../../registry.js").CliCommand;

package/dist/clis/grok/ask.js

@@ -0,0 +1,82 @@
+import { cli, Strategy } from '../../registry.js';
+export const askCommand = cli({
+    site: 'grok',
+    name: 'ask',
+    description: 'Send a message to Grok and get response',
+    domain: 'grok.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: 'prompt', type: 'string', required: true },
+        { name: 'timeout', type: 'int', default: 120 },
+        { name: 'new', type: 'boolean', default: false },
+    ],
+    columns: ['response'],
+    func: async (page, kwargs) => {
+        const prompt = kwargs.prompt;
+        const timeoutMs = (kwargs.timeout || 120) * 1000;
+        const newChat = kwargs.new;
+        if (newChat) {
+            await page.goto('https://grok.com');
+            await page.wait(2);
+            await page.evaluate(`(() => {
+        const btn = [...document.querySelectorAll('a, button')].find(b => {
+          const t = (b.textContent || '').trim().toLowerCase();
+          return t.includes('new') || b.getAttribute('href') === '/';
+        });
+        if (btn) btn.click();
+      })()`);
+            await page.wait(2);
+        }
+        await page.goto('https://grok.com');
+        await page.wait(3);
+        const promptJson = JSON.stringify(prompt);
+        const sendResult = await page.evaluate(`(async () => {
+      try {
+        const box = document.querySelector('textarea');
+        if (!box) return { ok: false, msg: 'no textarea' };
+        box.focus(); box.value = '';
+        document.execCommand('selectAll');
+        document.execCommand('insertText', false, ${promptJson});
+        await new Promise(r => setTimeout(r, 1500));
+        const btn = document.querySelector('button[aria-label="\\u63d0\\u4ea4"]');
+        if (btn && !btn.disabled) { btn.click(); return { ok: true, msg: 'clicked' }; }
+        const sub = [...document.querySelectorAll('button[type="submit"]')].find(b => !b.disabled);
+        if (sub) { sub.click(); return { ok: true, msg: 'clicked-submit' }; }
+        box.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', code: 'Enter', keyCode: 13, bubbles: true }));
+        return { ok: true, msg: 'enter' };
+      } catch (e) { return { ok: false, msg: e.toString() }; }
+    })()`);
+        if (!sendResult || !sendResult.ok) {
+            return [{ response: '[SEND FAILED] ' + JSON.stringify(sendResult) }];
+        }
+        const startTime = Date.now();
+        let lastText = '';
+        let stableCount = 0;
+        while (Date.now() - startTime < timeoutMs) {
+            await page.wait(3);
+            const response = await page.evaluate(`(() => {
+        const bubbles = document.querySelectorAll('div.message-bubble, [data-testid="message-bubble"]');
+        if (bubbles.length < 2) return '';
+        const last = bubbles[bubbles.length - 1];
+        const text = (last.innerText || '').trim();
+        if (!text || text.length < 2) return '';
+        return text;
+      })()`);
+            if (response && response.length > 2) {
+                if (response === lastText) {
+                    stableCount++;
+                    if (stableCount >= 2)
+                        return [{ response }];
+                }
+                else {
+                    stableCount = 0;
+                }
+            }
+            lastText = response || '';
+        }
+        if (lastText)
+            return [{ response: lastText }];
+        return [{ response: '[NO RESPONSE]' }];
+    },
+});

package/dist/clis/grok/debug.d.ts

@@ -0,0 +1 @@
+export declare const debugCommand: import("../../registry.js").CliCommand;

package/dist/clis/grok/debug.js

@@ -0,0 +1,45 @@
+import { cli, Strategy } from '../../registry.js';
+export const debugCommand = cli({
+    site: 'grok',
+    name: 'debug',
+    description: 'Debug grok page structure',
+    domain: 'grok.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    columns: ['data'],
+    func: async (page, _kwargs) => {
+        await page.goto('https://grok.com');
+        await page.wait(3);
+        // Get all button-like elements near textarea
+        const debug = await page.evaluate(`(() => {
+      const ta = document.querySelector('textarea');
+      if (!ta) return { error: 'no textarea' };
+
+      // Get parent containers
+      let parent = ta.parentElement;
+      const parents = [];
+      for (let i = 0; i < 5 && parent; i++) {
+        parents.push({
+          tag: parent.tagName,
+          class: parent.className?.substring(0, 80),
+          childCount: parent.children.length,
+        });
+        parent = parent.parentElement;
+      }
+
+      // Find buttons in the form/container near textarea
+      const form = ta.closest('form') || ta.closest('[class*="composer"]') || ta.closest('[class*="input"]') || ta.parentElement?.parentElement;
+      const buttons = form ? [...form.querySelectorAll('button')].map(b => ({
+        testid: b.getAttribute('data-testid'),
+        type: b.type,
+        disabled: b.disabled,
+        text: (b.textContent || '').substring(0, 30),
+        html: b.outerHTML.substring(0, 200),
+        rect: b.getBoundingClientRect().toJSON(),
+      })) : [];
+
+      return { parents, buttons, formTag: form?.tagName, formClass: form?.className?.substring(0, 80) };
+    })()`);
+        return [{ data: JSON.stringify(debug, null, 2) }];
+    },
+});

package/dist/clis/jimeng/generate.yaml

@@ -0,0 +1,84 @@
+site: jimeng
+name: generate
+description: 即梦AI 文生图 — 输入 prompt 生成图片
+domain: jimeng.jianying.com
+strategy: cookie
+browser: true
+
+args:
+  prompt:
+    type: string
+    required: true
+    description: "图片描述 prompt"
+  model:
+    type: string
+    default: "high_aes_general_v50"
+    description: "模型: high_aes_general_v50 (5.0 Lite), high_aes_general_v42 (4.6), high_aes_general_v40 (4.0)"
+  wait:
+    type: int
+    default: 40
+    description: "等待生成完成的秒数"
+
+columns: [status, prompt, image_count, image_urls]
+
+pipeline:
+  - navigate: https://jimeng.jianying.com/ai-tool/generate?type=image&workspace=0
+  - wait: 3
+  - evaluate: |
+      (async () => {
+        const prompt = ${{ args.prompt | json }};
+        const waitSec = ${{ args.wait }};
+        
+        // Step 1: Count existing images before generation
+        const beforeImgs = document.querySelectorAll('img[src*="dreamina-sign"], img[src*="tb4s082cfz"]').length;
+        
+        // Step 2: Clear and set prompt
+        const editors = document.querySelectorAll('[contenteditable="true"]');
+        const editor = editors[0];
+        if (!editor) return [{ status: 'failed', prompt: prompt, image_count: 0, image_urls: 'Editor not found' }];
+        
+        editor.focus();
+        await new Promise(r => setTimeout(r, 200));
+        document.execCommand('selectAll');
+        await new Promise(r => setTimeout(r, 100));
+        document.execCommand('delete');
+        await new Promise(r => setTimeout(r, 200));
+        document.execCommand('insertText', false, prompt);
+        await new Promise(r => setTimeout(r, 500));
+        
+        // Step 3: Click generate
+        const btn = document.querySelector('.lv-btn.lv-btn-primary[class*="circle"]');
+        if (!btn) return [{ status: 'failed', prompt: prompt, image_count: 0, image_urls: 'Generate button not found' }];
+        btn.click();
+        
+        // Step 4: Wait for new images to appear
+        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) {
+            // New images appeared — generation complete
+            newImgs = Array.from(allImgs).slice(0, allImgs.length - beforeImgs);
+            break;
+          }
+        }
+        
+        if (newImgs.length === 0) {
+          return [{ status: 'timeout', prompt: prompt, image_count: 0, image_urls: 'Generation may still be in progress' }];
+        }
+        
+        // Step 5: Extract image URLs (use thumbnail URLs which are accessible)
+        const urls = newImgs.map(img => img.src);
+        
+        return [{ 
+          status: 'success', 
+          prompt: prompt.substring(0, 80), 
+          image_count: urls.length, 
+          image_urls: urls.join('\n')
+        }];
+      })()
+  - map:
+      status: ${{ item.status }}
+      prompt: ${{ item.prompt }}
+      image_count: ${{ item.image_count }}
+      image_urls: ${{ item.image_urls }}