@zenalexa/unicli 0.218.1 → 0.220.0

package/dist/adapters/qwen/web.js

@@ -0,0 +1,672 @@
+/**
+ * @owner   src/adapters/qwen/web.ts
+ * @does    Register agent-facing Qwen web chat commands implemented with site-specific safety checks.
+ * @needs   Logged-in qianwen.com browser session, Qwen chat DOM/API, optional local image output directory.
+ * @feeds   surface coverage ledger and Qwen ask/read/send/history/detail/new/status/image workflows.
+ * @breaks  Qwen DOM/API drift or weak session-id validation can miss or target the wrong chat.
+ */
+import { mkdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { cli, Strategy } from "../../registry.js";
+import { boolArg, js, str } from "../_shared/browser-tools.js";
+const QWEN_HOME = "https://www.qianwen.com/";
+const QWEN_API_DOMAIN = "chat2-api.qianwen.com";
+const SESSION_ID_RE = /^[a-f0-9]{32}$/i;
+const VISIBLE_JS = `const isVisible = (node) => {
+  if (!(node instanceof Element)) return false;
+  const style = window.getComputedStyle(node);
+  if (style.visibility === 'hidden' || style.display === 'none') return false;
+  const rect = node.getBoundingClientRect();
+  return rect.width > 0 && rect.height > 0;
+};`;
+export function parseQwenSessionId(value) {
+    const raw = str(value).trim();
+    if (!raw)
+        throw new Error("Qwen session ID cannot be empty.");
+    const urlMatch = raw.match(/qianwen\.com\/chat\/([a-f0-9]{32})(?:[/?#]|$)/i);
+    const candidate = urlMatch?.[1] ?? raw;
+    if (!SESSION_ID_RE.test(candidate)) {
+        throw new Error(`Invalid Qwen session ID: ${raw}. Expected a 32-character hex ID or https://www.qianwen.com/chat/<id>.`);
+    }
+    return candidate.toLowerCase();
+}
+export function qwenHtmlToMarkdown(value) {
+    return str(value)
+        .replace(/<br\s*\/?>/gi, "\n")
+        .replace(/<\/(p|div|li|h[1-6]|pre)>/gi, "\n")
+        .replace(/<[^>]+>/g, " ")
+        .replace(/&nbsp;/g, " ")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&amp;/g, "&")
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/[ \t]+\n/g, "\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .replace(/[ \t]{2,}/g, " ")
+        .trim();
+}
+export function normalizeQwenBoolean(value, fallback = false) {
+    if (typeof value === "boolean")
+        return value;
+    if (value === undefined || value === null || value === "")
+        return fallback;
+    return /^(true|1|yes|on)$/i.test(str(value).trim());
+}
+export function mapQwenBubbles(bubbles, wantMarkdown) {
+    return bubbles
+        .map((bubble) => {
+        const role = str(bubble.role) === "Assistant" ? "Assistant" : "User";
+        const text = wantMarkdown && role === "Assistant" && str(bubble.html).trim()
+            ? qwenHtmlToMarkdown(bubble.html) || str(bubble.text)
+            : str(bubble.text);
+        return { Role: role, Text: text.trim() };
+    })
+        .filter((row) => row.Text);
+}
+export function formatQwenDate(value) {
+    const n = Number(value);
+    if (!Number.isFinite(n) || n <= 0)
+        return "";
+    const date = new Date(n);
+    if (Number.isNaN(date.getTime()))
+        return "";
+    const pad = (part) => String(part).padStart(2, "0");
+    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}`;
+}
+export function mapQwenSessions(sessions) {
+    return sessions
+        .map((session, index) => {
+        const id = str(session.id);
+        return {
+            Index: index + 1,
+            Title: str(session.title, "(untitled)").trim() || "(untitled)",
+            Updated: formatQwenDate(session.updated_at),
+            Url: `${QWEN_HOME}chat/${id}`,
+        };
+    })
+        .filter((row) => /\/chat\/[a-f0-9]{32}$/i.test(str(row.Url)));
+}
+function qwenOutputDir(value) {
+    return str(value, "~/Pictures/qianwen").replace(/^~(?=$|\/)/, homedir());
+}
+function qwenBoundedInt(value, fallback, max, label) {
+    const raw = value ?? fallback;
+    const n = Number(raw);
+    if (!Number.isInteger(n) || n <= 0) {
+        throw new Error(`Qwen ${label} must be a positive integer.`);
+    }
+    if (n > max) {
+        throw new Error(`Qwen ${label} must be <= ${max}.`);
+    }
+    return n;
+}
+function qwenImageExt(mime) {
+    const value = str(mime).toLowerCase();
+    if (value.includes("png"))
+        return ".png";
+    if (value.includes("webp"))
+        return ".webp";
+    if (value.includes("gif"))
+        return ".gif";
+    return ".jpg";
+}
+function displayPath(filePath) {
+    return filePath.startsWith(homedir())
+        ? `~${filePath.slice(homedir().length)}`
+        : filePath;
+}
+async function currentUrl(page) {
+    const value = await page.evaluate("window.location.href").catch(() => "");
+    return typeof value === "string" ? value : "";
+}
+async function ensureOnQwen(page) {
+    const url = await currentUrl(page);
+    if (!url.includes("qianwen.com")) {
+        await page.goto(QWEN_HOME, { waitUntil: "load", settleMs: 2500 });
+        await page.wait(2);
+    }
+}
+async function dismissLoginModal(page) {
+    await page.evaluate(`(() => {
+    ${VISIBLE_JS}
+    const modal = document.querySelector('[role=alert-biz-modal]');
+    if (!modal || !isVisible(modal)) return false;
+    const target = Array.from(modal.querySelectorAll('div, button, span'))
+      .filter((node) => node instanceof HTMLElement && isVisible(node))
+      .find((node) => /close|dismiss|cancel/i.test(String(node.className || '')) || node.getAttribute('aria-label') === '关闭')
+      || modal.querySelector('svg')?.parentElement;
+    if (target instanceof HTMLElement) {
+      target.click();
+      return true;
+    }
+    document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', code: 'Escape', bubbles: true }));
+    return true;
+  })()`);
+}
+async function hasLoginGate(page) {
+    const result = await page.evaluate(`(() => {
+    ${VISIBLE_JS}
+    const modal = document.querySelector('[role=alert-biz-modal]');
+    if (modal && isVisible(modal)) {
+      const src = modal.querySelector('iframe')?.getAttribute('src') || '';
+      if (src.includes('passport.qianwen.com') || src.includes('login')) return true;
+    }
+    return false;
+  })()`);
+    return Boolean(result);
+}
+async function isLoggedIn(page) {
+    const result = await page.evaluate(`(() => {
+    ${VISIBLE_JS}
+    const loginButton = Array.from(document.querySelectorAll('button'))
+      .find((node) => (node.textContent || '').trim() === '登录' && isVisible(node));
+    if (loginButton) return false;
+    const hint = Array.from(document.querySelectorAll('p'))
+      .find((node) => (node.textContent || '').includes('登录可同步历史对话'));
+    return !(hint && isVisible(hint));
+  })()`);
+    return Boolean(result);
+}
+async function startNewChat(page) {
+    const result = await page.evaluate(`(() => {
+    ${VISIBLE_JS}
+    const button = Array.from(document.querySelectorAll('button'))
+      .find((node) => isVisible(node) && (node.innerText || '').trim() === '新建对话');
+    if (button instanceof HTMLElement) {
+      button.click();
+      return true;
+    }
+    return false;
+  })()`);
+    if (result) {
+        await page.wait(1.5);
+        return;
+    }
+    await page.goto(QWEN_HOME, { waitUntil: "load", settleMs: 2500 });
+    await page.wait(2);
+}
+async function setFeatureToggle(page, feature, enabled) {
+    const labels = {
+        think: "深度思考",
+        research: "深度研究",
+        image: "AI生图",
+    };
+    await page.evaluate(`(async () => {
+    ${VISIBLE_JS}
+    const waitFor = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+    const button = Array.from(document.querySelectorAll('button[aria-label]'))
+      .find((node) => isVisible(node) && node.getAttribute('aria-label') === ${js(labels[feature])});
+    if (!(button instanceof HTMLElement)) return false;
+    const selected = button.getAttribute('aria-pressed') === 'true'
+      || /active|selected|bg-primary/.test(String(button.className || ''));
+    if (selected === ${JSON.stringify(enabled)}) return true;
+    button.click();
+    await waitFor(300);
+    return true;
+  })()`);
+}
+async function sendQwenMessage(page, prompt) {
+    const result = (await page.evaluate(`(async () => {
+    ${VISIBLE_JS}
+    const waitFor = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+    const editor = Array.from(document.querySelectorAll('[role=textbox][contenteditable=true]'))
+      .find((node) => isVisible(node));
+    if (!(editor instanceof HTMLElement)) return { ok: false, reason: 'Qwen composer not found.' };
+    editor.focus();
+    const selection = window.getSelection();
+    const range = document.createRange();
+    range.selectNodeContents(editor);
+    selection?.removeAllRanges();
+    selection?.addRange(range);
+    document.execCommand('delete', false);
+    await waitFor(100);
+    editor.dispatchEvent(new InputEvent('beforeinput', {
+      inputType: 'insertText',
+      data: ${js(prompt)},
+      bubbles: true,
+      cancelable: true,
+    }));
+    await waitFor(400);
+    const sendButton = document.querySelector('button[aria-label="发送消息"]');
+    if (sendButton instanceof HTMLButtonElement && !sendButton.disabled) {
+      sendButton.click();
+      return { ok: true, action: 'click' };
+    }
+    editor.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', code: 'Enter', keyCode: 13, bubbles: true }));
+    editor.dispatchEvent(new KeyboardEvent('keyup', { key: 'Enter', code: 'Enter', keyCode: 13, bubbles: true }));
+    return { ok: true, action: 'enter' };
+  })()`));
+    if (!result?.ok)
+        throw new Error(result?.reason || "Failed to send Qwen prompt.");
+}
+async function getMessageBubbles(page) {
+    const result = await page.evaluate(`(() => {
+    ${VISIBLE_JS}
+    const wraps = Array.from(document.querySelectorAll('[data-chat-question-wrap], [data-chat-answers-wrap]'))
+      .filter((node) => node instanceof HTMLElement && isVisible(node));
+    const findTurnId = (node) => {
+      let parent = node.parentElement;
+      while (parent && parent !== document.body) {
+        const reqEl = parent.querySelector('[data-req-id]');
+        if (reqEl?.getAttribute('data-req-id')) return reqEl.getAttribute('data-req-id');
+        parent = parent.parentElement;
+      }
+      return '';
+    };
+    return wraps.map((node, index) => {
+      const isAnswer = node.hasAttribute('data-chat-answers-wrap');
+      const contentNode = isAnswer
+        ? (node.querySelector('#qk-markdown-react') || node.querySelector('[class*="markdown"]') || node)
+        : node;
+      const html = contentNode instanceof HTMLElement ? (contentNode.innerHTML || '') : '';
+      const text = contentNode instanceof HTMLElement ? (contentNode.innerText || contentNode.textContent || '') : '';
+      const baseId = findTurnId(node) || ('pos-' + index);
+      return {
+        id: baseId + (isAnswer ? '-answer' : '-question'),
+        role: isAnswer ? 'Assistant' : 'User',
+        text: String(text || '').replace(/\\s+/g, ' ').trim(),
+        html,
+      };
+    });
+  })()`);
+    return Array.isArray(result)
+        ? result.filter((bubble) => str(bubble.id) && str(bubble.text))
+        : [];
+}
+async function waitForQwenAnswer(page, prompt, timeout) {
+    const startedAt = Date.now();
+    let previous = "";
+    let stable = 0;
+    let candidate = null;
+    while (Date.now() - startedAt < timeout * 1000) {
+        await page.wait(2);
+        if (await hasLoginGate(page))
+            throw new Error("Qwen login is required.");
+        const bubbles = await getMessageBubbles(page);
+        const assistant = [...bubbles]
+            .reverse()
+            .find((bubble) => bubble.role === "Assistant");
+        const text = str(assistant?.text).trim();
+        if (!text || text === prompt.trim())
+            continue;
+        candidate = assistant ?? null;
+        if (text === previous) {
+            stable += 1;
+            if (Date.now() - startedAt >= 6000 && stable >= 2 && candidate) {
+                return candidate;
+            }
+        }
+        else {
+            previous = text;
+            stable = 0;
+        }
+    }
+    if (candidate)
+        return candidate;
+    throw new Error("No Qwen reply observed before timeout.");
+}
+async function getSessionList(page, limit) {
+    const raw = (await page.evaluate(`(async () => {
+    try {
+      const utdid = (document.cookie.match(/(?:^|;\\s*)b-user-id=([^;]+)/)?.[1])
+        || (document.cookie.match(/(?:^|;\\s*)utdid=([^;]+)/)?.[1])
+        || '';
+      const query = new URLSearchParams({
+        biz_id: 'ai_qwen',
+        chat_client: 'h5',
+        device: 'pc',
+        fr: 'pc',
+        pr: 'qwen',
+        ut: utdid,
+        la: 'zh-CN',
+        tz: 'Asia/Shanghai',
+        ve: '2.4.9',
+      }).toString();
+      const response = await fetch('https://${QWEN_API_DOMAIN}/api/v2/session/page/list?' + query, {
+        method: 'POST',
+        credentials: 'include',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ page_num: 1, page_size: ${limit}, page_no: 1 }),
+      });
+      const text = await response.text();
+      let body = null;
+      try { body = text ? JSON.parse(text) : null; } catch { body = null; }
+      return { ok: response.ok, status: response.status, body };
+    } catch (error) {
+      return { ok: false, status: 0, error: String(error?.message || error) };
+    }
+  })()`));
+    if (!raw?.ok)
+        throw new Error(`Qwen history API failed (status=${raw?.status ?? 0}).`);
+    const data = (raw.body?.data || raw.body?.result || {});
+    const list = Array.isArray(data.list)
+        ? data.list
+        : Array.isArray(data.items)
+            ? data.items
+            : Array.isArray(data.page_list)
+                ? data.page_list
+                : Array.isArray(raw.body?.list)
+                    ? raw.body.list
+                    : [];
+    const sessions = list
+        .map((item) => {
+        const row = item;
+        return {
+            id: str(row.session_id || row.sessionId || row.id),
+            title: str(row.title || row.name || row.summary).trim(),
+            updated_at: Number(row.updated_at ||
+                row.last_req_timestamp ||
+                row.updatedAt ||
+                row.gmt_modified ||
+                row.update_time ||
+                0),
+        };
+    })
+        .filter((item) => item.id);
+    const rows = mapQwenSessions(sessions).slice(0, limit);
+    if (!rows.length)
+        throw new Error("No Qwen conversations found.");
+    return rows;
+}
+async function collectImageUrls(page, assistantId) {
+    const urls = await page.evaluate(`(() => {
+    const scope = ${js(assistantId)};
+    const bubbles = Array.from(document.querySelectorAll('[data-msgid$="-answer"], [data-chat-answers-wrap]'));
+    const target = scope
+      ? bubbles.find((node) => node.getAttribute('data-msgid') === scope)
+      : bubbles[bubbles.length - 1];
+    if (!target) return [];
+    const imgs = Array.from(target.querySelectorAll('img'))
+      .map((node) => node.getAttribute('src') || '')
+      .filter((src) => src && !src.startsWith('data:') && !/\\.(svg)$/i.test(src) && !src.includes('alicdn.com/imgextra'));
+    return Array.from(new Set(imgs));
+  })()`);
+    return Array.isArray(urls) ? urls.map(String) : [];
+}
+async function waitForImageUrls(page, assistantId, timeout) {
+    const startedAt = Date.now();
+    let lastUrls = [];
+    while (Date.now() - startedAt < timeout * 1000) {
+        await page.wait(2);
+        if (await hasLoginGate(page))
+            throw new Error("Qwen login is required.");
+        const urls = await collectImageUrls(page, assistantId);
+        if (urls.length &&
+            urls.length === lastUrls.length &&
+            urls.every((url, i) => url === lastUrls[i])) {
+            return urls;
+        }
+        lastUrls = urls;
+    }
+    if (lastUrls.length)
+        return lastUrls;
+    throw new Error("No generated Qwen images observed before timeout.");
+}
+async function fetchImageAsset(page, url) {
+    const result = (await page.evaluate(`(async () => {
+    const response = await fetch(${js(url)}, { credentials: 'include' });
+    if (!response.ok) return { ok: false, status: response.status };
+    const mime = response.headers.get('content-type') || '';
+    const bytes = new Uint8Array(await response.arrayBuffer());
+    let binary = '';
+    const chunk = 0x8000;
+    for (let i = 0; i < bytes.length; i += chunk) {
+      binary += String.fromCharCode.apply(null, bytes.subarray(i, i + chunk));
+    }
+    return { ok: true, mime, base64: btoa(binary) };
+  })()`));
+    if (!result?.ok || !result.base64) {
+        throw new Error(`Failed to fetch generated Qwen image: status=${result?.status ?? "?"}.`);
+    }
+    return { mime: str(result.mime), base64: result.base64 };
+}
+cli({
+    site: "qwen",
+    name: "ask",
+    description: "Send a prompt to Qwen and return the assistant reply",
+    domain: "www.qianwen.com",
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: "prompt", type: "str", required: true, positional: true },
+        { name: "timeout", type: "int", default: 120 },
+        { name: "new", type: "bool", default: false },
+        { name: "think", type: "bool", default: false },
+        { name: "research", type: "bool", default: false },
+        { name: "markdown", type: "bool", default: false },
+    ],
+    columns: ["Role", "Text"],
+    func: async (page, kwargs) => {
+        const prompt = str(kwargs.prompt).trim();
+        if (!prompt)
+            throw new Error("Qwen prompt cannot be empty.");
+        const p = page;
+        const timeout = qwenBoundedInt(kwargs.timeout, 120, 600, "timeout");
+        await ensureOnQwen(p);
+        await dismissLoginModal(p);
+        if (boolArg(kwargs.new))
+            await startNewChat(p);
+        if (boolArg(kwargs.think))
+            await setFeatureToggle(p, "think", true);
+        if (boolArg(kwargs.research))
+            await setFeatureToggle(p, "research", true);
+        await sendQwenMessage(p, prompt);
+        const answer = await waitForQwenAnswer(p, prompt, timeout);
+        return [
+            { Role: "User", Text: prompt },
+            ...mapQwenBubbles([answer], normalizeQwenBoolean(kwargs.markdown)),
+        ];
+    },
+});
+cli({
+    site: "qwen",
+    name: "read",
+    description: "Read messages in the current Qwen conversation",
+    domain: "www.qianwen.com",
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [{ name: "markdown", type: "bool", default: false }],
+    columns: ["Role", "Text"],
+    func: async (page, kwargs) => {
+        const p = page;
+        await ensureOnQwen(p);
+        await dismissLoginModal(p);
+        await p.wait(2);
+        const rows = mapQwenBubbles(await getMessageBubbles(p), normalizeQwenBoolean(kwargs.markdown));
+        if (!rows.length)
+            throw new Error("No visible Qwen messages found.");
+        return rows;
+    },
+});
+cli({
+    site: "qwen",
+    name: "send",
+    description: "Send a prompt to Qwen without waiting for the reply",
+    domain: "www.qianwen.com",
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: "prompt", type: "str", required: true, positional: true },
+        { name: "new", type: "bool", default: false },
+        { name: "think", type: "bool", default: false },
+        { name: "research", type: "bool", default: false },
+    ],
+    columns: ["Status", "Prompt"],
+    func: async (page, kwargs) => {
+        const prompt = str(kwargs.prompt).trim();
+        if (!prompt)
+            throw new Error("Qwen prompt cannot be empty.");
+        const p = page;
+        await ensureOnQwen(p);
+        await dismissLoginModal(p);
+        if (boolArg(kwargs.new))
+            await startNewChat(p);
+        if (boolArg(kwargs.think))
+            await setFeatureToggle(p, "think", true);
+        if (boolArg(kwargs.research))
+            await setFeatureToggle(p, "research", true);
+        await sendQwenMessage(p, prompt);
+        return [{ Status: "sent", Prompt: prompt }];
+    },
+});
+cli({
+    site: "qwen",
+    name: "history",
+    description: "List recent Qwen conversations",
+    domain: "www.qianwen.com",
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [{ name: "limit", type: "int", default: 20 }],
+    columns: ["Index", "Title", "Updated", "Url"],
+    func: async (page, kwargs) => {
+        const limit = qwenBoundedInt(kwargs.limit, 20, 100, "history limit");
+        const p = page;
+        await ensureOnQwen(p);
+        await dismissLoginModal(p);
+        return getSessionList(p, limit);
+    },
+});
+cli({
+    site: "qwen",
+    name: "detail",
+    description: "Open a Qwen conversation by ID and read its messages",
+    domain: "www.qianwen.com",
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: "id", type: "str", required: true, positional: true },
+        { name: "markdown", type: "bool", default: false },
+    ],
+    columns: ["Role", "Text"],
+    func: async (page, kwargs) => {
+        const p = page;
+        const id = parseQwenSessionId(kwargs.id);
+        await p.goto(`${QWEN_HOME}chat/${id}`, {
+            waitUntil: "load",
+            settleMs: 2500,
+        });
+        await dismissLoginModal(p);
+        const startedAt = Date.now();
+        while (Date.now() - startedAt < 20_000) {
+            const rows = mapQwenBubbles(await getMessageBubbles(p), normalizeQwenBoolean(kwargs.markdown));
+            if (rows.length)
+                return rows;
+            await p.wait(1);
+        }
+        throw new Error(`No visible Qwen messages found for conversation ${id}.`);
+    },
+});
+cli({
+    site: "qwen",
+    name: "new",
+    description: "Start a new conversation in Qwen",
+    domain: "www.qianwen.com",
+    strategy: Strategy.COOKIE,
+    browser: true,
+    columns: ["Status"],
+    func: async (page) => {
+        const p = page;
+        await p.goto(QWEN_HOME, { waitUntil: "load", settleMs: 2500 });
+        await dismissLoginModal(p);
+        await startNewChat(p);
+        return [{ Status: "New chat started" }];
+    },
+});
+cli({
+    site: "qwen",
+    name: "status",
+    description: "Check Qwen page availability, login state, current session and model",
+    domain: "www.qianwen.com",
+    strategy: Strategy.COOKIE,
+    browser: true,
+    columns: ["Status", "Login", "Model", "SessionId", "Url"],
+    func: async (page) => {
+        const p = page;
+        await ensureOnQwen(p);
+        await p.wait(2);
+        const [loggedIn, sessionId, model, url] = await Promise.all([
+            isLoggedIn(p),
+            p.evaluate(`(() => {
+        const match = window.location.href.match(/\\/chat\\/([A-Za-z0-9_-]+)/);
+        return match ? match[1] : '';
+      })()`),
+            p.evaluate(`(() => {
+        ${VISIBLE_JS}
+        const trigger = Array.from(document.querySelectorAll('[aria-haspopup=dialog]'))
+          .find((node) => isVisible(node) && (node.innerText || '').includes('Qwen'));
+        return trigger ? (trigger.innerText || '').split('\\n')[0].trim() : '';
+      })()`),
+            currentUrl(p),
+        ]);
+        return [
+            {
+                Status: "Connected",
+                Login: loggedIn ? "Yes" : "No (guest mode)",
+                Model: str(model) || null,
+                SessionId: str(sessionId) || null,
+                Url: url,
+            },
+        ];
+    },
+});
+cli({
+    site: "qwen",
+    name: "image",
+    description: "Generate images with Qwen and save them locally",
+    domain: "www.qianwen.com",
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: "prompt", type: "str", required: true, positional: true },
+        { name: "op", type: "str", default: "~/Pictures/qianwen" },
+        { name: "new", type: "bool", default: true },
+        { name: "sd", type: "bool", default: false },
+        { name: "timeout", type: "int", default: 180 },
+    ],
+    columns: ["Status", "File", "Link"],
+    func: async (page, kwargs) => {
+        const prompt = str(kwargs.prompt).trim();
+        if (!prompt)
+            throw new Error("Qwen image prompt cannot be empty.");
+        const p = page;
+        const timeout = qwenBoundedInt(kwargs.timeout, 180, 600, "image timeout");
+        await ensureOnQwen(p);
+        await dismissLoginModal(p);
+        if (normalizeQwenBoolean(kwargs.new, true))
+            await startNewChat(p);
+        await setFeatureToggle(p, "image", true);
+        await sendQwenMessage(p, prompt);
+        let assistantId = "";
+        for (let i = 0; i < 5; i += 1) {
+            await p.wait(1);
+            const assistant = [...(await getMessageBubbles(p))]
+                .reverse()
+                .find((bubble) => bubble.role === "Assistant");
+            if (assistant) {
+                assistantId = str(assistant.id);
+                break;
+            }
+        }
+        const link = await currentUrl(p);
+        if (boolArg(kwargs.sd))
+            return [{ Status: "generated", File: null, Link: link }];
+        const urls = await waitForImageUrls(p, assistantId, timeout);
+        const outputDir = qwenOutputDir(kwargs.op);
+        mkdirSync(outputDir, { recursive: true });
+        const stamp = Date.now();
+        const rows = [];
+        for (const [index, url] of urls.entries()) {
+            const asset = await fetchImageAsset(p, url);
+            const suffix = urls.length > 1 ? `_${index + 1}` : "";
+            const filePath = join(outputDir, `qwen_${stamp}${suffix}${qwenImageExt(asset.mime)}`);
+            writeFileSync(filePath, Buffer.from(asset.base64, "base64"));
+            rows.push({ Status: "saved", File: displayPath(filePath), Link: link });
+        }
+        if (!rows.length)
+            throw new Error("No generated Qwen images were available to download.");
+        return rows;
+    },
+});
+//# sourceMappingURL=web.js.map